1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17
18 #include "accesstoken_kit.h"
19 #include "net_all_capabilities.h"
20 #include "net_conn_service.h"
21 #include "net_conn_client.h"
22 #include "net_conn_constants.h"
23 #include "net_conn_types.h"
24 #include "net_manager_constants.h"
25 #include "net_mgr_log_wrapper.h"
26 #include "token_setproc.h"
27 #include "net_supplier_callback_stub.h"
28 #include "net_conn_callback_stub.h"
29 #include "http_proxy.h"
30
31 namespace OHOS {
32 namespace NetManagerStandard {
33 namespace {
34 using namespace testing::ext;
35 using namespace Security::AccessToken;
36 using Security::AccessToken::AccessTokenID;
37
38 HapInfoParams testInfoParms = {.bundleName = "net_conn_service_test", .userID = 1, .instIndex = 0, .appIDDesc = "test"};
39
40 PermissionDef testPermDef = {.permissionName = "ohos.permission.GET_NETWORK_INFO",
41 .bundleName = "net_conn_service_test",
42 .grantMode = 1,
43 .label = "label",
44 .labelId = 1,
45 .description = "Test net connect maneger",
46 .descriptionId = 1,
47 .availableLevel = APL_SYSTEM_BASIC};
48
49 PermissionStateFull testState = {.grantFlags = {2},
50 .grantStatus = {PermissionState::PERMISSION_GRANTED},
51 .isGeneral = true,
52 .permissionName = "ohos.permission.GET_NETWORK_INFO",
53 .resDeviceID = {"local"}};
54
55 PermissionDef testPermDef2 = {.permissionName = "ohos.permission.INTERNET",
56 .bundleName = "net_conn_service_test",
57 .grantMode = 1,
58 .label = "label",
59 .labelId = 1,
60 .description = "Test net connect maneger",
61 .descriptionId = 1,
62 .availableLevel = APL_SYSTEM_BASIC};
63
64 PermissionStateFull testState2 = {.grantFlags = {2},
65 .grantStatus = {PermissionState::PERMISSION_GRANTED},
66 .isGeneral = true,
67 .permissionName = "ohos.permission.INTERNET",
68 .resDeviceID = {"local"}};
69 PermissionDef testPermDef3 = {.permissionName = "ohos.permission.CONNECTIVITY_INTERNAL",
70 .bundleName = "net_conn_service_test",
71 .grantMode = 1,
72 .label = "label",
73 .labelId = 1,
74 .description = "Test net connect maneger",
75 .descriptionId = 1,
76 .availableLevel = APL_SYSTEM_BASIC};
77
78 PermissionStateFull testState3 = {.grantFlags = {2},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED},
80 .isGeneral = true,
81 .permissionName = "ohos.permission.CONNECTIVITY_INTERNAL",
82 .resDeviceID = {"local"}};
83
84 HapPolicyParams testPolicyPrams = {.apl = APL_SYSTEM_BASIC,
85 .domain = "test.domain",
86 .permList = {testPermDef, testPermDef2, testPermDef3},
87 .permStateList = {testState, testState2, testState3}};
88
89 constexpr const char *TEST_IDENT = "testIdent";
90 constexpr uint32_t TEST_TIMEOUTMS = 1000;
91 constexpr const char *TEST_HOST = "testHost";
92 constexpr int32_t TEST_NETID = 3;
93 constexpr int32_t TEST_SOCKETFD = 2;
94 const int32_t NET_ID = 2;
95 const int32_t SOCKET_FD = 2;
96
97 class NetSupplierTestCallback : public NetSupplierCallbackStub {
98 public:
RequestNetwork(const std::string & ident,const std::set<NetCap> & netCaps)99 inline int32_t RequestNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
100 {
101 return NETMANAGER_SUCCESS;
102 }
ReleaseNetwork(const std::string & ident,const std::set<NetCap> & netCaps)103 inline int32_t ReleaseNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
104 {
105 return NETMANAGER_SUCCESS;
106 }
107 };
108
109 class NetConnTestCallback : public NetConnCallbackStub {
110 public:
NetAvailable(sptr<NetHandle> & netHandle)111 inline int32_t NetAvailable(sptr<NetHandle> &netHandle) override
112 {
113 return 0;
114 }
NetCapabilitiesChange(sptr<NetHandle> & netHandle,const sptr<NetAllCapabilities> & netAllCap)115 inline int32_t NetCapabilitiesChange(sptr<NetHandle> &netHandle, const sptr<NetAllCapabilities> &netAllCap) override
116 {
117 return 0;
118 }
NetConnectionPropertiesChange(sptr<NetHandle> & netHandle,const sptr<NetLinkInfo> & info)119 inline int32_t NetConnectionPropertiesChange(sptr<NetHandle> &netHandle, const sptr<NetLinkInfo> &info) override
120 {
121 return 0;
122 }
NetLost(sptr<NetHandle> & netHandle)123 inline int32_t NetLost(sptr<NetHandle> &netHandle) override
124 {
125 return 0;
126 }
NetUnavailable()127 inline int32_t NetUnavailable() override
128 {
129 return 0;
130 }
NetBlockStatusChange(sptr<NetHandle> & netHandle,bool blocked)131 inline int32_t NetBlockStatusChange(sptr<NetHandle> &netHandle, bool blocked) override
132 {
133 return 0;
134 }
135 };
136 sptr<INetConnCallback> g_callback = new (std::nothrow) NetConnTestCallback();
137 uint32_t g_supplierId = 0;
138 } // namespace
139
140 class AccessToken {
141 public:
AccessToken()142 AccessToken()
143 {
144 currentID_ = GetSelfTokenID();
145 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testPolicyPrams);
146 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
147 SetSelfTokenID(accessID_);
148 }
~AccessToken()149 ~AccessToken()
150 {
151 AccessTokenKit::DeleteToken(accessID_);
152 SetSelfTokenID(currentID_);
153 }
154
155 private:
156 AccessTokenID currentID_ = 0;
157 AccessTokenID accessID_ = 0;
158 };
159
160 class NetConnServiceTest : public testing::Test {
161 public:
162 static void SetUpTestCase();
163 static void TearDownTestCase();
164 void SetUp();
165 void TearDown();
166 };
167
SetUpTestCase()168 void NetConnServiceTest::SetUpTestCase()
169 {
170 std::set<NetCap> netCaps;
171 DelayedSingleton<NetConnClient>::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT,
172 netCaps, g_supplierId);
173 }
174
TearDownTestCase()175 void NetConnServiceTest::TearDownTestCase() {}
176
SetUp()177 void NetConnServiceTest::SetUp() {}
178
TearDown()179 void NetConnServiceTest::TearDown() {}
180
181 HWTEST_F(NetConnServiceTest, OnStopTest001, TestSize.Level1)
182 {
183 DelayedSingleton<NetConnService>::GetInstance()->OnStop();
184 }
185
186 HWTEST_F(NetConnServiceTest, OnStartTest001, TestSize.Level1)
187 {
188 DelayedSingleton<NetConnService>::GetInstance()->OnStart();
189 }
190
191 HWTEST_F(NetConnServiceTest, SystemReadyTest001, TestSize.Level1)
192 {
193 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->SystemReady();
194 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
195 }
196
197 HWTEST_F(NetConnServiceTest, RegisterNetSupplierCallbackTest001, TestSize.Level1)
198 {
199 sptr<INetSupplierCallback> callback = new (std::nothrow) NetSupplierTestCallback();
200 ASSERT_NE(callback, nullptr);
201 std::set<NetCap> netCaps;
202 auto ret = DelayedSingleton<NetConnService>::GetInstance()->RegisterNetSupplierCallback(g_supplierId, callback);
203 EXPECT_EQ(ret, NETMANAGER_ERROR);
204 }
205
206 HWTEST_F(NetConnServiceTest, UpdateNetSupplierInfoTest001, TestSize.Level1)
207 {
208 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
209 ASSERT_NE(netSupplierInfo, nullptr);
210 auto ret = DelayedSingleton<NetConnService>::GetInstance()->UpdateNetSupplierInfo(g_supplierId, netSupplierInfo);
211 EXPECT_EQ(ret, NETMANAGER_ERROR);
212 }
213
214 HWTEST_F(NetConnServiceTest, UpdateNetLinkInfoTest001, TestSize.Level1)
215 {
216 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
217 ASSERT_NE(netLinkInfo, nullptr);
218 auto ret = DelayedSingleton<NetConnService>::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
219 EXPECT_EQ(ret, NETMANAGER_ERROR);
220 }
221
222 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest001, TestSize.Level1)
223 {
224 sptr<INetConnCallback> callback = new (std::nothrow) NetConnTestCallback();
225 ASSERT_NE(callback, nullptr);
226 auto ret = DelayedSingleton<NetConnService>::GetInstance()->RegisterNetConnCallback(callback);
227 EXPECT_EQ(ret, NETMANAGER_ERROR);
228 }
229
230 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest002, TestSize.Level1)
231 {
232 AccessToken token;
233 auto ret = DelayedSingleton<NetConnService>::GetInstance()->RegisterNetConnCallback(g_callback);
234 EXPECT_EQ(ret, NETMANAGER_ERROR);
235 }
236
237 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest004, TestSize.Level1)
238 {
239 AccessToken token;
240 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
241 ASSERT_NE(netSpecifier, nullptr);
242 sptr<INetConnCallback> callback = new (std::nothrow) NetConnTestCallback();
243 ASSERT_NE(callback, nullptr);
244 auto ret = DelayedSingleton<NetConnService>::GetInstance()->RegisterNetConnCallback(netSpecifier, callback,
245 TEST_TIMEOUTMS);
246 EXPECT_EQ(ret, NETMANAGER_ERROR);
247 }
248
249 HWTEST_F(NetConnServiceTest, UnregisterNetConnCallbackTest002, TestSize.Level1)
250 {
251 AccessToken token;
252 auto ret = DelayedSingleton<NetConnService>::GetInstance()->UnregisterNetConnCallback(g_callback);
253 EXPECT_EQ(ret, NETMANAGER_ERROR);
254 }
255
256 HWTEST_F(NetConnServiceTest, GetAllNetsTest002, TestSize.Level1)
257 {
258 AccessToken token;
259 std::list<int32_t> netIdList;
260 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetAllNets(netIdList);
261 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
262 }
263
264 HWTEST_F(NetConnServiceTest, GetConnectionPropertiesTest002, TestSize.Level1)
265 {
266 AccessToken token;
267 NetLinkInfo info;
268 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetConnectionProperties(TEST_NETID, info);
269 EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
270 }
271
272 HWTEST_F(NetConnServiceTest, GetAddressesByNameTest002, TestSize.Level1)
273 {
274 AccessToken token;
275 std::vector<INetAddr> addrList;
276 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetAddressesByName(TEST_HOST, TEST_NETID, addrList);
277 EXPECT_EQ(ret, NETMANAGER_ERROR);
278 }
279
280 HWTEST_F(NetConnServiceTest, GetAddressByNameTest002, TestSize.Level1)
281 {
282 AccessToken token;
283 INetAddr addr;
284 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetAddressByName(TEST_HOST, TEST_NETID, addr);
285 EXPECT_EQ(ret, NETMANAGER_ERROR);
286 }
287
288 HWTEST_F(NetConnServiceTest, BindSocketTest001, TestSize.Level1)
289 {
290 auto ret = DelayedSingleton<NetConnService>::GetInstance()->BindSocket(TEST_SOCKETFD, TEST_NETID);
291 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
292 }
293
294 HWTEST_F(NetConnServiceTest, NetDetectionTest002, TestSize.Level1)
295 {
296 AccessToken token;
297 auto ret = DelayedSingleton<NetConnService>::GetInstance()->NetDetection(TEST_NETID);
298 EXPECT_EQ(ret, NETMANAGER_ERROR);
299 }
300
301 HWTEST_F(NetConnServiceTest, GetNetIdByIdentifierTest001, TestSize.Level1)
302 {
303 int32_t netId = 0;
304 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetNetIdByIdentifier(TEST_IDENT, netId);
305 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
306 }
307
308 HWTEST_F(NetConnServiceTest, GetDefaultNetTest002, TestSize.Level1)
309 {
310 AccessToken token;
311 int32_t netId = 0;
312 auto ret = DelayedSingleton<NetConnService>::GetInstance()->GetDefaultNet(netId);
313 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
314 }
315
316 HWTEST_F(NetConnServiceTest, HasDefaultNetTest002, TestSize.Level1)
317 {
318 AccessToken token;
319 bool bFlag = false;
320 auto ret = DelayedSingleton<NetConnService>::GetInstance()->HasDefaultNet(bFlag);
321 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
322 }
323
324 HWTEST_F(NetConnServiceTest, GetNetCapabilitiesTest003, TestSize.Level1)
325 {
326 NETMGR_LOG_D("GetNetCapabilitiesTest003 In");
327 AccessToken token;
328 int32_t netId = 0;
329 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->GetDefaultNet(netId);
330 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
331
332 NetAllCapabilities netAllCap;
333 ret = DelayedSingleton<NetConnService>::GetInstance()->GetNetCapabilities(netId, netAllCap);
334 ASSERT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
335 }
336
337 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest001, TestSize.Level1)
338 {
339 AccessToken token;
340 auto ret = DelayedSingleton<NetConnService>::GetInstance()->SetAirplaneMode(true);
341 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
342 }
343
344 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest002, TestSize.Level1)
345 {
346 AccessToken token;
347 auto ret = DelayedSingleton<NetConnService>::GetInstance()->SetAirplaneMode(false);
348 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
349 }
350
351 HWTEST_F(NetConnServiceTest, IsDefaultNetMeteredTest002, TestSize.Level1)
352 {
353 AccessToken token;
354 bool bRes = false;
355 auto ret = DelayedSingleton<NetConnService>::GetInstance()->IsDefaultNetMetered(bRes);
356 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
357 ASSERT_TRUE(bRes);
358 }
359
360 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest001, TestSize.Level1)
361 {
362 AccessToken token;
363 HttpProxy httpProxy = {"testHttpProxy", 0, {}};
364 auto ret = DelayedSingleton<NetConnService>::GetInstance()->SetGlobalHttpProxy(httpProxy);
365 ASSERT_EQ(ret, NETMANAGER_ERROR);
366 }
367
368 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest002, TestSize.Level1)
369 {
370 HttpProxy httpProxy;
371 auto ret = DelayedSingleton<NetConnService>::GetInstance()->SetGlobalHttpProxy(httpProxy);
372 ASSERT_NE(ret, NETMANAGER_SUCCESS);
373 }
374
375 HWTEST_F(NetConnServiceTest, GetGlobalHttpProxyTest001, TestSize.Level1)
376 {
377 AccessToken token;
378 HttpProxy httpProxy = {"testHttpProxy", 0, {}};
379 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->SetGlobalHttpProxy(httpProxy);
380 ASSERT_EQ(ret, NETMANAGER_ERROR);
381
382 HttpProxy getGlobalHttpProxy;
383 ret = DelayedSingleton<NetConnService>::GetInstance()->GetGlobalHttpProxy(getGlobalHttpProxy);
384 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
385 }
386
387 HWTEST_F(NetConnServiceTest, GetTest001, TestSize.Level1)
388 {
389 std::list<int32_t> netIdList;
390 netIdList.push_back(NET_ID);
391 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->GetSpecificNet(BEARER_CELLULAR, netIdList);
392 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
393
394 ret = DelayedSingleton<NetConnService>::GetInstance()->RestrictBackgroundChanged(true);
395 EXPECT_EQ(ret, NETMANAGER_ERROR);
396
397 std::vector<std::u16string> args;
398 args.emplace_back(u"dummy data");
399 ret = DelayedSingleton<NetConnService>::GetInstance()->Dump(SOCKET_FD, args);
400 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
401 DelayedSingleton<NetConnService>::GetInstance()->OnNetActivateTimeOut(NET_ID);
402 }
403 } // namespace NetManagerStandard
404 } // namespace OHOS
405