1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "network/softbus/softbus_agent.h"
16
17 #include "gtest/gtest.h"
18 #include "gmock/gmock.h"
19 #include <memory>
20 #include <unistd.h>
21
22 #include "dm_constants.h"
23
24 #include "device_manager_agent_mock.h"
25 #include "device_manager_impl_mock.h"
26 #include "dm_constants.h"
27 #include "network/softbus/softbus_session_dispatcher.h"
28 #include "network/softbus/softbus_session.h"
29 #include "utils_log.h"
30 #include "connect_count/connect_count.h"
31
32 using namespace std;
33
34 namespace OHOS {
35 namespace Storage {
36 namespace DistributedFile {
37 namespace Test {
38 using namespace testing::ext;
39 using namespace testing;
40
41 const std::string NETWORKID_ONE = "45656596896323231";
42 const std::string NETWORKID_TWO = "45656596896323232";
43 constexpr int32_t NETWORKTYPE_WITH_WIFI = 2;
44 constexpr int32_t NETWORKTYPE_NONE_WIFI = 4;
45 constexpr int USER_ID = 100;
46 static const string SAME_ACCOUNT = "account";
47
48 class SoftbusAgentSupTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
SetUp()52 void SetUp() {};
TearDown()53 void TearDown() {};
54 static inline std::shared_ptr<DeviceManagerAgentMock> deviceManagerAgentMock_ = nullptr;
55 static inline shared_ptr<DeviceManagerImplMock> deviceManagerImplMock_ = nullptr;
56 };
57
SetUpTestCase(void)58 void SoftbusAgentSupTest::SetUpTestCase(void)
59 {
60 GTEST_LOG_(INFO) << "SetUpTestCase";
61 deviceManagerAgentMock_ = std::make_shared<DeviceManagerAgentMock>();
62 IDeviceManagerAgentMock::iDeviceManagerAgentMock_ = deviceManagerAgentMock_;
63 deviceManagerImplMock_ = make_shared<DeviceManagerImplMock>();
64 DeviceManagerImplMock::dfsDeviceManagerImpl = deviceManagerImplMock_;
65 }
66
TearDownTestCase(void)67 void SoftbusAgentSupTest::TearDownTestCase(void)
68 {
69 GTEST_LOG_(INFO) << "TearDownTestCase";
70 IDeviceManagerAgentMock::iDeviceManagerAgentMock_ = nullptr;
71 deviceManagerAgentMock_ = nullptr;
72 DeviceManagerImplMock::dfsDeviceManagerImpl = nullptr;
73 deviceManagerImplMock_ = nullptr;
74 }
75
76 /**
77 * @tc.name: SoftbusAgentSupTest_ConnectOnlineDevices_0100
78 * @tc.desc: Verify the ConnectOnlineDevices function.
79 * @tc.type: FUNC
80 * @tc.require: SR000H0387
81 */
82 HWTEST_F(SoftbusAgentSupTest, SoftbusAgentSupTest_ConnectOnlineDevices_0100, TestSize.Level1)
83 {
84 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_ConnectOnlineDevices_0100 start";
85 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
86 shared_ptr<MountPoint> smp = move(mp);
87 weak_ptr<MountPoint> wmp(smp);
88 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
89 bool res = true;
90 try {
91 vector<DeviceInfo> infos;
92 DeviceInfo testA;
93 infos.push_back(testA);
94 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
95 agent->ConnectOnlineDevices();
96
97 DistributedHardware::DmDeviceInfo nodeInfo{.extraData = "test"};
98 DeviceInfo testB(nodeInfo);
99 infos.clear();
100 infos.push_back(testB);
101 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
102 agent->ConnectOnlineDevices();
103
104 nodeInfo.extraData = R"({"OS_TYPE":"test"})";
105 DeviceInfo testC(nodeInfo);
106 infos.clear();
107 infos.push_back(testC);
108 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
109 agent->ConnectOnlineDevices();
110
111 nodeInfo.extraData = R"({"OS_TYPE":3})";
112 DeviceInfo testD(nodeInfo);
113 infos.clear();
114 infos.push_back(testD);
115 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
116 agent->ConnectOnlineDevices();
117
118 nodeInfo.extraData = R"({"OS_TYPE":10})";
119 memset_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN, 0, DM_MAX_DEVICE_ID_LEN);
120 (void)memcpy_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN - 1,
121 NETWORKID_ONE.c_str(), NETWORKID_ONE.size());
122 DeviceInfo testE(nodeInfo);
123 infos.clear();
124 infos.push_back(testE);
125 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
126 EXPECT_CALL(*deviceManagerImplMock_, GetNetworkTypeByNetworkId(_, _, _))
127 .WillOnce(Return(ERR_DM_INPUT_PARA_INVALID));
128 agent->ConnectOnlineDevices();
129 } catch (const exception &e) {
130 res = false;
131 LOGE("%{public}s", e.what());
132 }
133 EXPECT_TRUE(res);
134 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_ConnectOnlineDevices_0100 end";
135 }
136
137 /**
138 * @tc.name: SoftbusAgentSupTest_ConnectOnlineDevices_0200
139 * @tc.desc: Verify the ConnectOnlineDevices function.
140 * @tc.type: FUNC
141 * @tc.require: I9JXPR
142 */
143 HWTEST_F(SoftbusAgentSupTest, SoftbusAgentSupTest_ConnectOnlineDevices_0200, TestSize.Level1)
144 {
145 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_ConnectOnlineDevices_0200 start";
146 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
147 shared_ptr<MountPoint> smp = move(mp);
148 weak_ptr<MountPoint> wmp(smp);
149 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
150 bool res = true;
151 try {
152 vector<DeviceInfo> infos;
153 DistributedHardware::DmDeviceInfo nodeInfo{.networkId = "testNetWork",
154 .extraData = R"({"OS_TYPE":10})"};
155 memset_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN, 0, DM_MAX_DEVICE_ID_LEN);
156 (void)memcpy_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN - 1,
157 NETWORKID_ONE.c_str(), NETWORKID_ONE.size());
158 DeviceInfo testC(nodeInfo);
159 infos.push_back(testC);
160 memset_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN, 0, DM_MAX_DEVICE_ID_LEN);
161 (void)memcpy_s(nodeInfo.networkId, DM_MAX_DEVICE_ID_LEN - 1,
162 NETWORKID_TWO.c_str(), NETWORKID_TWO.size());
163 DeviceInfo testD(nodeInfo);
164 infos.push_back(testD);
165
166 EXPECT_CALL(*deviceManagerAgentMock_, GetRemoteDevicesInfo()).WillOnce(Return(infos));
167 EXPECT_CALL(*deviceManagerImplMock_, GetNetworkTypeByNetworkId(_, _, _))
168 .WillOnce(DoAll(SetArgReferee<2>(NETWORKTYPE_WITH_WIFI), Return(DM_OK)))
169 .WillOnce(DoAll(SetArgReferee<2>(NETWORKTYPE_NONE_WIFI), Return(DM_OK)));
170 agent->ConnectOnlineDevices();
171 } catch (const exception &e) {
172 res = false;
173 LOGE("%{public}s", e.what());
174 }
175 EXPECT_TRUE(res);
176 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_ConnectOnlineDevices_0200 end";
177 }
178
179 /**
180 * @tc.name: SoftbusAgentSupTest_GetSessionProcessInner_0100
181 * @tc.desc: Verify the GetSessionProcessInner function.
182 * @tc.type: FUNC
183 * @tc.require: I9JXPR
184 */
185 HWTEST_F(SoftbusAgentSupTest, SoftbusAgentSupTest_GetSessionProcessInner_0100, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_GetSessionProcessInner_0100 start";
188 auto mp = make_unique<MountPoint>(Utils::DfsuMountArgumentDescriptors::Alpha(USER_ID, SAME_ACCOUNT));
189 shared_ptr<MountPoint> smp = move(mp);
190 weak_ptr<MountPoint> wmp(smp);
191 std::shared_ptr<SoftbusAgent> agent = std::make_shared<SoftbusAgent>(wmp);
192
193 NotifyParam param {.fd = 1, .remoteCid = "testNetworkId"};
194 agent->sessionPool_.ReleaseAllSession();
195 agent->GetSessionProcessInner(param);
196 EXPECT_FALSE(agent->sessionPool_.FindCid("testNetworkId"));
197
198 param.fd = -1;
199 auto session = make_shared<SoftbusSession>(1, "testNetworkId");
200 session->SetFromServer(false);
201 agent->sessionPool_.AddSessionToPool(session);
202 ConnectCount::GetInstance()->RemoveAllConnect();
203 agent->GetSessionProcessInner(param);
204 EXPECT_FALSE(agent->sessionPool_.FindCid("testNetworkId"));
205
206 sptr<IFileDfsListener> listener = nullptr;
207 agent->sessionPool_.AddSessionToPool(session);
208 ConnectCount::GetInstance()->AddConnect(1, "testNetworkId", listener);
209 agent->GetSessionProcessInner(param);
210 EXPECT_FALSE(agent->sessionPool_.FindCid("testNetworkId"));
211
212 GTEST_LOG_(INFO) << "SoftbusAgentSupTest_GetSessionProcessInner_0100 end";
213 }
214 } // namespace Test
215 } // namespace DistributedFile
216 } // namespace Storage
217 } // namespace OHOS
218