1 /*
2 * Copyright (c) 2023 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
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <cstdint>
19 #include <unistd.h>
20
21 #include "dfs_error.h"
22 #include "net_conn_client.h"
23 #include "parameter.h"
24 #include "net_conn_callback_observer.h"
25 #include "network_status.h"
26 #include "utils_log.h"
27 #include "net_conn_client_mock.h"
28 #include "net_handle.h"
29
30 namespace OHOS::FileManagement::CloudSync::Test {
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace std;
34 using namespace CloudFile;
35
36 class NetworkStatusTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 static inline shared_ptr<NetConnClientMock> dfsNetConnClient_ = nullptr;
43 };
SetUpTestCase(void)44 void NetworkStatusTest::SetUpTestCase(void)
45 {
46 dfsNetConnClient_ = make_shared<NetConnClientMock>();
47 NetConnClientMock::dfsNetConnClient = dfsNetConnClient_;
48 GTEST_LOG_(INFO) << "SetUpTestCase";
49 }
50
TearDownTestCase(void)51 void NetworkStatusTest::TearDownTestCase(void)
52 {
53 NetConnClientMock::dfsNetConnClient = nullptr;
54 dfsNetConnClient_ = nullptr;
55 GTEST_LOG_(INFO) << "TearDownTestCase";
56 }
57
SetUp(void)58 void NetworkStatusTest::SetUp(void)
59 {
60 GTEST_LOG_(INFO) << "SetUp";
61 }
62
TearDown(void)63 void NetworkStatusTest::TearDown(void)
64 {
65 GTEST_LOG_(INFO) << "TearDown";
66 }
67
68 /**
69 * @tc.name: RegisterNetConnCallbackTest
70 * @tc.desc: Verify the RegisterNetConnCallback function
71 * @tc.type: FUNC
72 * @tc.require: I6JPKG
73 */
74 HWTEST_F(NetworkStatusTest, RegisterNetConnCallbackTest001, TestSize.Level1)
75 {
76 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest Start";
77 try {
78 auto dataSyncManager = std::make_shared<DataSyncManager>();
79 int32_t ret = NetworkStatus::RegisterNetConnCallback(dataSyncManager);
80 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
81 } catch (...) {
82 EXPECT_TRUE(false);
83 GTEST_LOG_(INFO) << " RegisterNetConnCallbackTest FAILED";
84 }
85 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest End";
86 }
87
88 /**
89 * @tc.name: GetDefaultNetTest001
90 * @tc.desc: Verify the GetDefaultNet function
91 * @tc.type: FUNC
92 * @tc.require: I6JPKG
93 */
94 HWTEST_F(NetworkStatusTest, GetDefaultNetTest001, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "GetDefaultNetTest001 Start";
97 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_GET_NETWORK_MANAGER_FAILED));
98 NetworkStatus netStatus;
99 int32_t ret = netStatus.GetDefaultNet();
100 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
101 GTEST_LOG_(INFO) << "GetDefaultNetTest001 End";
102 }
103
104 /**
105 * @tc.name: GetDefaultNetTest002
106 * @tc.desc: Verify the GetDefaultNet function
107 * @tc.type: FUNC
108 * @tc.require: I6JPKG
109 */
110 HWTEST_F(NetworkStatusTest, GetDefaultNetTest002, TestSize.Level1)
111 {
112 GTEST_LOG_(INFO) << "GetDefaultNetTest002 Start";
113 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(NetManagerStandard::NETMANAGER_SUCCESS));
114 NetworkStatus netStatus;
115 int32_t ret = netStatus.GetDefaultNet();
116 EXPECT_EQ(ret, E_OK);
117 GTEST_LOG_(INFO) << "GetDefaultNetTest002 End";
118 }
119
120 /**
121 * @tc.name: SetNetConnStatusTest001
122 * @tc.desc: Verify the SetNetConnStatus function
123 * @tc.type: FUNC
124 * @tc.require: I6JPKG
125 */
126 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest001, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
129 try {
130 NetManagerStandard::NetAllCapabilities netAllCap;
131 NetworkStatus::SetNetConnStatus(netAllCap);
132 EXPECT_TRUE(true);
133 } catch (...) {
134 EXPECT_TRUE(false);
135 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
136 }
137 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
138 }
139
140 /**
141 * @tc.name: SetNetConnStatusTest002
142 * @tc.desc: Verify the SetNetConnStatus function
143 * @tc.type: FUNC
144 * @tc.require: I6JPKG
145 */
146 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest002, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
149 try {
150 NetManagerStandard::NetAllCapabilities netAllCap;
151 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
152 NetworkStatus::SetNetConnStatus(netAllCap);
153 EXPECT_TRUE(true);
154 } catch (...) {
155 EXPECT_TRUE(false);
156 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
157 }
158 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
159 }
160
161 /**
162 * @tc.name: SetNetConnStatusTest003
163 * @tc.desc: Verify the SetNetConnStatus function
164 * @tc.type: FUNC
165 * @tc.require: I6JPKG
166 */
167 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest003, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
170 try {
171 NetManagerStandard::NetAllCapabilities netAllCap;
172 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
173 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_ETHERNET);
174 NetworkStatus::SetNetConnStatus(netAllCap);
175 EXPECT_TRUE(true);
176 } catch (...) {
177 EXPECT_TRUE(false);
178 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
179 }
180 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
181 }
182
183 /**
184 * @tc.name: SetNetConnStatusTest004
185 * @tc.desc: Verify the SetNetConnStatus function
186 * @tc.type: FUNC
187 * @tc.require: I6JPKG
188 */
189 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest004, TestSize.Level1)
190 {
191 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
192 try {
193 NetManagerStandard::NetAllCapabilities netAllCap;
194 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
195 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_WIFI);
196 NetworkStatus::SetNetConnStatus(netAllCap);
197 EXPECT_TRUE(true);
198 } catch (...) {
199 EXPECT_TRUE(false);
200 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
201 }
202 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
203 }
204
205 /**
206 * @tc.name: SetNetConnStatusTest005
207 * @tc.desc: Verify the SetNetConnStatus function
208 * @tc.type: FUNC
209 * @tc.require: I6JPKG
210 */
211 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest005, TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
214 try {
215 NetManagerStandard::NetAllCapabilities netAllCap;
216 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
217 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_CELLULAR);
218 NetworkStatus::SetNetConnStatus(netAllCap);
219 EXPECT_TRUE(true);
220 } catch (...) {
221 EXPECT_TRUE(false);
222 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
223 }
224 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
225 }
226
227 /**
228 * @tc.name: GetAndRegisterNetworkTest
229 * @tc.desc: Verify the GetAndRegisterNetwork function
230 * @tc.type: FUNC
231 * @tc.require: I6JPKG
232 */
233 HWTEST_F(NetworkStatusTest, GetAndRegisterNetworkTest, TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest Start";
236 try {
237 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_OK));
238 auto dataSyncManager = std::make_shared<DataSyncManager>();
239 int32_t ret = NetworkStatus::GetAndRegisterNetwork(dataSyncManager);
240 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
241 } catch (...) {
242 EXPECT_TRUE(false);
243 GTEST_LOG_(INFO) << " GetAndRegisterNetworkTest FAILED";
244 }
245 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest End";
246 }
247
248 /**
249 * @tc.name: InitNetworkTest
250 * @tc.desc: Verify the InitNetwork function
251 * @tc.type: FUNC
252 * @tc.require: I6JPKG
253 */
254 HWTEST_F(NetworkStatusTest, InitNetworkTest, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "InitNetworkTest Start";
257 try {
258 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_OK)).WillRepeatedly(Return(E_OK));
259 auto dataSyncManager = std::make_shared<DataSyncManager>();
260 NetworkStatus::InitNetwork(dataSyncManager);
261 EXPECT_TRUE(true);
262 } catch (...) {
263 EXPECT_TRUE(false);
264 GTEST_LOG_(INFO) << " InitNetworkTest FAILED";
265 }
266 GTEST_LOG_(INFO) << "InitNetworkTest End";
267 }
268
269 /**
270 * @tc.name: CheckMobileNetworkTest001
271 * @tc.desc: Verify the CheckMobileNetwork function
272 * @tc.type: FUNC
273 * @tc.require: I6JPKG
274 */
275 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest001, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
278 try {
279 NetworkStatus networkStatus;
280 string bundleName = "";
281 int32_t userId = 100;
282 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
283 EXPECT_EQ(ret, true);
284 } catch (...) {
285 EXPECT_TRUE(false);
286 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
287 }
288 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
289 }
290
291 /**
292 * @tc.name: CheckMobileNetworkTest002
293 * @tc.desc: Verify the CheckMobileNetwork function
294 * @tc.type: FUNC
295 * @tc.require: I6JPKG
296 */
297 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest002, TestSize.Level1)
298 {
299 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
300 try {
301 NetworkStatus networkStatus;
302 string bundleName = "com.ohos.photos";
303 int32_t userId = 1;
304 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
305 EXPECT_EQ(ret, true);
306 } catch (...) {
307 EXPECT_TRUE(false);
308 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
309 }
310 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
311 }
312
313 /**
314 * @tc.name: CheckMobileNetworkTest003
315 * @tc.desc: Verify the CheckMobileNetwork function
316 * @tc.type: FUNC
317 * @tc.require: I6JPKG
318 */
319 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest003, TestSize.Level1)
320 {
321 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
322 try {
323 NetworkStatus networkStatus;
324 string bundleName = "com.ohos.photos";
325 int32_t userId = 100;
326 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
327 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
328 EXPECT_EQ(ret, true);
329 } catch (...) {
330 EXPECT_TRUE(false);
331 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
332 }
333 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
334 }
335
336 /**
337 * @tc.name: CheckMobileNetworkTest004
338 * @tc.desc: Verify the CheckMobileNetwork function
339 * @tc.type: FUNC
340 * @tc.require: I6JPKG
341 */
342 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest004, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
345 try {
346 NetworkStatus networkStatus;
347 string bundleName = "com.ohos.photos";
348 int32_t userId = 100;
349 networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK);
350 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
351 EXPECT_EQ(ret, false);
352 } catch (...) {
353 EXPECT_TRUE(false);
354 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
355 }
356 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
357 }
358
359 /**
360 * @tc.name: CheckNetworkTest001
361 * @tc.desc: Verify the CheckNetwork function
362 * @tc.type: FUNC
363 * @tc.require: I6JPKG
364 */
365 HWTEST_F(NetworkStatusTest, CheckNetworkTest001, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
368 try {
369 NetworkStatus networkStatus;
370 string bundleName = "";
371 int32_t userId = 100;
372 bool ret = networkStatus.CheckNetwork(bundleName, userId);
373 EXPECT_EQ(ret, true);
374 } catch (...) {
375 EXPECT_TRUE(false);
376 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
377 }
378 GTEST_LOG_(INFO) << "CheckNetworkTest End";
379 }
380
381 /**
382 * @tc.name: CheckNetworkTest002
383 * @tc.desc: Verify the CheckNetwork function
384 * @tc.type: FUNC
385 * @tc.require: I6JPKG
386 */
387 HWTEST_F(NetworkStatusTest, CheckNetworkTest002, TestSize.Level1)
388 {
389 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
390 try {
391 NetworkStatus networkStatus;
392 string bundleName = "com.ohos.photos";
393 int32_t userId = 1;
394 bool ret = networkStatus.CheckNetwork(bundleName, userId);
395 EXPECT_EQ(ret, true);
396 } catch (...) {
397 EXPECT_TRUE(false);
398 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
399 }
400 GTEST_LOG_(INFO) << "CheckNetworkTest End";
401 }
402
403 /**
404 * @tc.name: CheckNetworkTest003
405 * @tc.desc: Verify the CheckNetwork function
406 * @tc.type: FUNC
407 * @tc.require: I6JPKG
408 */
409 HWTEST_F(NetworkStatusTest, CheckNetworkTest003, TestSize.Level1)
410 {
411 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
412 try {
413 NetworkStatus networkStatus;
414 string bundleName = "com.ohos.photos";
415 int32_t userId = 100;
416 bool ret = networkStatus.CheckNetwork(bundleName, userId);
417 EXPECT_EQ(ret, false);
418 } catch (...) {
419 EXPECT_TRUE(false);
420 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
421 }
422 GTEST_LOG_(INFO) << "CheckNetworkTest End";
423 }
424
425 /**
426 * @tc.name: OnNetworkAvailTest001
427 * @tc.desc: Verify the OnNetworkAvail function
428 * @tc.type: FUNC
429 * @tc.require: I6JPKG
430 */
431 HWTEST_F(NetworkStatusTest, OnNetworkAvailTest001, TestSize.Level1)
432 {
433 GTEST_LOG_(INFO) << "OnNetworkAvailTest Start";
434 try {
435 NetworkStatus networkStatus;
436 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
437 } catch (...) {
438 EXPECT_TRUE(false);
439 GTEST_LOG_(INFO) << "OnNetworkAvailTest FAILED";
440 }
441 GTEST_LOG_(INFO) << "OnNetworkAvailTest End";
442 }
443 } // namespace OHOS::FileManagement::CloudSync::Test