1 /*
2 * Copyright (c) 2022 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 "core_service_client.h"
19 #include "cellular_data_client.h"
20
21 #define private public
22 #include "net_connect_adapter_impl.h"
23 #include "net_connect_utils.h"
24 #include "core_service_client.h"
25 #include "cellular_data_client.h"
26 #include "net_conn_client.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::NWeb;
32 using namespace OHOS::Telephony;
33
34 namespace OHOS {
35 namespace {
36 int32_t g_regNetConnCallback = 0;
37 int32_t g_unregNetConnCallback = 0;
38 int32_t g_getDefaultNet = 0;
39 int32_t g_getNetCap = 0;
40 int32_t g_slotId = 0;
41 int32_t g_getNetProp = 0;
42 int32_t g_getAllNets = 0;
43 int32_t g_specified_net_id = 100;
44 int32_t g_vpnCount = 0;
45 using Want = OHOS::AAFwk::Want;
46 const int32_t DEFAULT_VALUE = -1;
47 const int32_t TEST_BEARER_VPN = 4;
48 }
49
50 namespace NetManagerStandard {
RegisterNetConnCallback(const sptr<INetConnCallback> callback)51 int32_t NetConnClient::RegisterNetConnCallback(const sptr<INetConnCallback> callback)
52 {
53 return g_regNetConnCallback;
54 }
UnregisterNetConnCallback(const sptr<INetConnCallback> & callback)55 int32_t NetConnClient::UnregisterNetConnCallback(const sptr<INetConnCallback> &callback)
56 {
57 return g_unregNetConnCallback;
58 }
GetDefaultNet(NetHandle & nethamdle)59 int32_t NetConnClient::GetDefaultNet(NetHandle &nethamdle)
60 {
61 return g_getDefaultNet;
62 }
GetNetCapabilities(const NetHandle & nethamdle,NetAllCapabilities & netAllCap)63 int32_t NetConnClient::GetNetCapabilities(const NetHandle &nethamdle, NetAllCapabilities &netAllCap)
64 {
65 netAllCap.bearerTypes_.insert(NetBearType::BEARER_WIFI);
66 netAllCap.bearerTypes_.insert(NetBearType::BEARER_CELLULAR);
67 if (g_vpnCount != 0) {
68 netAllCap.bearerTypes_.insert(NetBearType::BEARER_VPN);
69 }
70 return g_getNetCap;
71 }
GetConnectionProperties(const NetHandle & nethandle,NetLinkInfo & netLinkInfo)72 int32_t NetConnClient::GetConnectionProperties(const NetHandle &nethandle, NetLinkInfo &netLinkInfo)
73 {
74 if (g_getNetProp != 0) {
75 return g_getNetProp;
76 }
77 INetAddr dns;
78 dns.type_ = INetAddr::IPV4;
79 dns.family_ = 0x10;
80 dns.prefixlen_ = 0x17;
81 dns.address_ = "192.168.2.1";
82 dns.netMask_ = "192.255.255.255";
83 dns.hostName_ = "netAddr";
84 netLinkInfo.dnsList_.push_back(dns);
85 return g_getNetProp;
86 }
GetAllNets(std::list<sptr<NetHandle>> & netList)87 int32_t NetConnClient::GetAllNets(std::list<sptr<NetHandle>> &netList)
88 {
89 if (g_getAllNets != 0) {
90 return g_getAllNets;
91 }
92 sptr<NetManagerStandard::NetHandle> netHandle = std::make_unique<NetHandle>(g_specified_net_id).release();
93 if (netHandle != nullptr) {
94 netList.emplace_back(netHandle);
95 }
96 return g_getAllNets;
97 }
98 }
99
100 namespace Telephony {
GetDefaultCellularDataSlotId()101 int32_t CellularDataClient::GetDefaultCellularDataSlotId()
102 {
103 return g_slotId;
104 }
105 }
106
107 namespace NWeb {
108 using namespace OHOS::NetManagerStandard;
109 class NetConnectAdapterImplTest : public testing::Test {
110 public:
111 static void SetUpTestCase(void);
112 static void TearDownTestCase(void);
113 void SetUp();
114 void TearDown();
115 };
116
SetUpTestCase(void)117 void NetConnectAdapterImplTest::SetUpTestCase(void)
118 {}
119
TearDownTestCase(void)120 void NetConnectAdapterImplTest::TearDownTestCase(void)
121 {}
122
SetUp(void)123 void NetConnectAdapterImplTest::SetUp(void)
124 {}
125
TearDown(void)126 void NetConnectAdapterImplTest::TearDown(void)
127 {}
128
129 class NetConnCallbackTest : public NetConnCallback {
130 public:
131 NetConnCallbackTest() = default;
132 virtual ~NetConnCallbackTest() = default;
NetAvailable()133 int32_t NetAvailable() override
134 {
135 return 0;
136 }
NetCapabilitiesChange(const NetConnectType & netConnectType,const NetConnectSubtype & netConnectSubtype)137 int32_t NetCapabilitiesChange(const NetConnectType &netConnectType,
138 const NetConnectSubtype &netConnectSubtype) override
139 {
140 return 0;
141 }
NetConnectionPropertiesChange()142 int32_t NetConnectionPropertiesChange() override
143 {
144 return 0;
145 }
NetUnavailable()146 int32_t NetUnavailable() override
147 {
148 return 0;
149 }
OnNetCapabilitiesChanged(const std::shared_ptr<NetCapabilitiesAdapter> capabilities)150 int32_t OnNetCapabilitiesChanged(
151 const std::shared_ptr<NetCapabilitiesAdapter> capabilities) override
152 {
153 return 0;
154 }
OnNetConnectionPropertiesChanged(const std::shared_ptr<NetConnectionPropertiesAdapter> properties)155 int32_t OnNetConnectionPropertiesChanged(
156 const std::shared_ptr<NetConnectionPropertiesAdapter> properties) override
157 {
158 return 0;
159 }
160 };
161
162 class VpnListenerTest : public VpnListener {
163 public:
164 VpnListenerTest() = default;
165 virtual ~VpnListenerTest() = default;
166
OnAvailable()167 void OnAvailable() override
168 {
169 return;
170 }
171
OnLost()172 void OnLost() override
173 {
174 return;
175 }
176 };
177
178 /**
179 * @tc.name: NetConnectAdapterImplTest_001.
180 * @tc.desc: test lock type.
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_001, TestSize.Level1)
185 {
186 std::shared_ptr<NetConnCallbackTest> cb = std::make_shared<NetConnCallbackTest>();
187 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
188 EXPECT_NE(netConnectAdapterImpl, nullptr);
189 g_regNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
190 EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(cb), 0);
191 g_regNetConnCallback = -1;
192 EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(nullptr), -1);
193 g_unregNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
194 EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(0), 0);
195 EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(-1), -1);
196
197 g_regNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
198 EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(cb), 1);
199 g_unregNetConnCallback = -1;
200 EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(1), -1);
201 }
202
203 /**
204 * @tc.name: NetConnectAdapterImplTest_002.
205 * @tc.desc: test lock type.
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_002, TestSize.Level1)
210 {
211 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
212 NetConnectType type = NetConnectType::CONNECTION_UNKNOWN;
213 NetConnectSubtype subtype = NetConnectSubtype::SUBTYPE_UNKNOWN;
214 g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
215 g_getNetCap = static_cast<int32_t>(NETMANAGER_SUCCESS);
216 EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), 0);
217 g_slotId = -1;
218 EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), 0);
219 g_getDefaultNet = -1;
220 EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), -1);
221 g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
222 g_getNetCap = -1;
223 EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), -1);
224 }
225
226 /**
227 * @tc.name: NetConnectAdapterImplTest_003.
228 * @tc.desc: test lock type.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_003, TestSize.Level1)
233 {
234 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
235 g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
236 g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
237 std::vector<std::string> dns_servers = netConnectAdapterImpl->GetDnsServers();
238 EXPECT_EQ(dns_servers.size(), 1);
239 std::string dns_ip_str("192.168.2.1");
240 EXPECT_EQ(dns_servers.front(), dns_ip_str);
241 g_getDefaultNet = -1;
242 dns_servers = netConnectAdapterImpl->GetDnsServers();
243 EXPECT_EQ(dns_servers.size(), 0);
244 g_getNetProp = -1;
245 dns_servers = netConnectAdapterImpl->GetDnsServers();
246 EXPECT_EQ(dns_servers.size(), 0);
247 }
248
249 /**
250 * @tc.name: NetConnectAdapterImplTest_004.
251 * @tc.desc: test lock type.
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_004, TestSize.Level1)
256 {
257 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
258 g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
259 g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
260 std::vector<std::string> dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(-1);
261 EXPECT_EQ(dns_servers.size(), 1);
262 std::string dns_ip_str("192.168.2.1");
263 EXPECT_EQ(dns_servers.front(), dns_ip_str);
264 g_getDefaultNet = -1;
265 dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(-1);
266 EXPECT_EQ(dns_servers.size(), 0);
267 g_getAllNets = static_cast<int32_t>(NETMANAGER_SUCCESS);
268 dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(100);
269 EXPECT_EQ(dns_servers.size(), 1);
270 EXPECT_EQ(dns_servers.front(), dns_ip_str);
271 dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(101);
272 EXPECT_EQ(dns_servers.size(), 0);
273 g_getNetProp = -1;
274 dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(100);
275 EXPECT_EQ(dns_servers.size(), 0);
276 }
277
278 /**
279 * @tc.name: NetConnectAdapterImplTest_005.
280 * @tc.desc: test lock type.
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_005, TestSize.Level1)
285 {
286 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
287 EXPECT_NE(netConnectAdapterImpl, nullptr);
288 g_getAllNets = static_cast<int32_t>(NETMANAGER_ERR_PERMISSION_DENIED);
289 std::vector<std::string> dns_servers = netConnectAdapterImpl->GetDnsServersForVpn();
290 EXPECT_EQ(dns_servers.size(), 0);
291 g_getAllNets = static_cast<int32_t>(NETMANAGER_SUCCESS);
292 g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
293 g_vpnCount = 1;
294 dns_servers = netConnectAdapterImpl->GetDnsServersForVpn();
295 EXPECT_EQ(dns_servers.size(), 1);
296 std::string dns_ip_str("192.168.2.1");
297 EXPECT_EQ(dns_servers.front(), dns_ip_str);
298 g_vpnCount = 0;
299 dns_servers = netConnectAdapterImpl->GetDnsServersForVpn();
300 EXPECT_EQ(dns_servers.size(), 0);
301 }
302
303 /**
304 * @tc.name: NetConnectAdapterImplTest_006.
305 * @tc.desc: test lock type.
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_006, TestSize.Level1)
310 {
311 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
312 EXPECT_NE(netConnectAdapterImpl, nullptr);
313 g_getAllNets = static_cast<int32_t>(NETMANAGER_ERR_PERMISSION_DENIED);
314 bool result = netConnectAdapterImpl->HasVpnTransport();
315 EXPECT_EQ(result, false);
316 g_getAllNets = static_cast<int32_t>(NETMANAGER_SUCCESS);
317 g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
318 g_vpnCount = 1;
319 result = netConnectAdapterImpl->HasVpnTransport();
320 EXPECT_EQ(result, true);
321 g_vpnCount = 0;
322 result = netConnectAdapterImpl->HasVpnTransport();
323 EXPECT_EQ(result, false);
324 }
325
326 /**
327 * @tc.name: NetConnectAdapterImplTest_007.
328 * @tc.desc: test lock type.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_007, TestSize.Level1)
333 {
334 std::shared_ptr<VpnListenerTest> cb = std::make_shared<VpnListenerTest>();
335 std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
336 EXPECT_NE(netConnectAdapterImpl, nullptr);
337 netConnectAdapterImpl->RegisterVpnListener(nullptr);
338 netConnectAdapterImpl->UnRegisterVpnListener();
339 g_getAllNets = static_cast<int32_t>(NETMANAGER_ERR_PERMISSION_DENIED);
340 netConnectAdapterImpl->RegisterVpnListener(cb);
341 netConnectAdapterImpl->UnRegisterVpnListener();
342 g_getAllNets = static_cast<int32_t>(NETMANAGER_SUCCESS);
343 g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
344 g_vpnCount = 1;
345 netConnectAdapterImpl->RegisterVpnListener(cb);
346 netConnectAdapterImpl->UnRegisterVpnListener();
347 }
348
349 /**
350 * @tc.name: NetConnectAdapterImplTest_008.
351 * @tc.desc: test lock type.
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_008, TestSize.Level1)
356 {
357 EventFwk::CommonEventSubscribeInfo in;
358 std::shared_ptr<VpnListenerTest> cb = std::make_shared<VpnListenerTest>();
359 std::shared_ptr<NetVPNEventSubscriber> subscribe = std::make_shared<NetVPNEventSubscriber>(in, cb);
360 EXPECT_NE(subscribe, nullptr);
361 Want want;
362 want.SetAction("test");
363 EventFwk::CommonEventData data(want);
364 subscribe->OnReceiveEvent(data);
365
366 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
367 want.SetParam("NetType", DEFAULT_VALUE);
368 EventFwk::CommonEventData data1(want);
369 data1.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED);
370 subscribe->OnReceiveEvent(data1);
371
372 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
373 want.SetParam("NetType", 1);
374 EventFwk::CommonEventData data2(want);
375 data2.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED);
376 subscribe->OnReceiveEvent(data2);
377
378 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
379 want.SetParam("NetType", TEST_BEARER_VPN);
380 EventFwk::CommonEventData data3(want);
381 data3.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED);
382 subscribe->OnReceiveEvent(data3);
383
384 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
385 want.SetParam("NetType", TEST_BEARER_VPN);
386 EventFwk::CommonEventData data4(want);
387 data4.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_DISCONNECTED);
388 subscribe->OnReceiveEvent(data4);
389 }
390 }
391 }
392