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 }
45 
46 namespace NetManagerStandard {
RegisterNetConnCallback(const sptr<INetConnCallback> callback)47 int32_t NetConnClient::RegisterNetConnCallback(const sptr<INetConnCallback> callback)
48 {
49     return g_regNetConnCallback;
50 }
UnregisterNetConnCallback(const sptr<INetConnCallback> & callback)51 int32_t NetConnClient::UnregisterNetConnCallback(const sptr<INetConnCallback> &callback)
52 {
53     return g_unregNetConnCallback;
54 }
GetDefaultNet(NetHandle & nethamdle)55 int32_t NetConnClient::GetDefaultNet(NetHandle &nethamdle)
56 {
57     return g_getDefaultNet;
58 }
GetNetCapabilities(const NetHandle & nethamdle,NetAllCapabilities & netAllCap)59 int32_t NetConnClient::GetNetCapabilities(const NetHandle &nethamdle, NetAllCapabilities &netAllCap)
60 {
61     netAllCap.bearerTypes_.insert(NetBearType::BEARER_WIFI);
62     netAllCap.bearerTypes_.insert(NetBearType::BEARER_CELLULAR);
63     return g_getNetCap;
64 }
GetConnectionProperties(const NetHandle & nethandle,NetLinkInfo & netLinkInfo)65 int32_t NetConnClient::GetConnectionProperties(const NetHandle &nethandle, NetLinkInfo &netLinkInfo)
66 {
67     if (g_getNetProp != 0) {
68         return g_getNetProp;
69     }
70     INetAddr dns;
71     dns.type_ = INetAddr::IPV4;
72     dns.family_ = 0x10;
73     dns.prefixlen_ = 0x17;
74     dns.address_ = "192.168.2.1";
75     dns.netMask_ = "192.255.255.255";
76     dns.hostName_ = "netAddr";
77     netLinkInfo.dnsList_.push_back(dns);
78     return g_getNetProp;
79 }
GetAllNets(std::list<sptr<NetHandle>> & netList)80 int32_t NetConnClient::GetAllNets(std::list<sptr<NetHandle>> &netList)
81 {
82     if (g_getAllNets != 0) {
83         return g_getAllNets;
84     }
85     sptr<NetManagerStandard::NetHandle> netHandle = std::make_unique<NetHandle>(g_specified_net_id).release();
86     if (netHandle != nullptr) {
87         netList.emplace_back(netHandle);
88     }
89     return g_getAllNets;
90 }
91 }
92 
93 namespace Telephony {
GetDefaultCellularDataSlotId()94 int32_t CellularDataClient::GetDefaultCellularDataSlotId()
95 {
96     return g_slotId;
97 }
98 }
99 
100 namespace NWeb {
101 using namespace OHOS::NetManagerStandard;
102 class NetConnectAdapterImplTest : public testing::Test {
103 public:
104     static void SetUpTestCase(void);
105     static void TearDownTestCase(void);
106     void SetUp();
107     void TearDown();
108 };
109 
SetUpTestCase(void)110 void NetConnectAdapterImplTest::SetUpTestCase(void)
111 {}
112 
TearDownTestCase(void)113 void NetConnectAdapterImplTest::TearDownTestCase(void)
114 {}
115 
SetUp(void)116 void NetConnectAdapterImplTest::SetUp(void)
117 {}
118 
TearDown(void)119 void NetConnectAdapterImplTest::TearDown(void)
120 {}
121 
122 class NetConnCallbackTest : public NetConnCallback {
123 public:
124     NetConnCallbackTest() = default;
125     virtual ~NetConnCallbackTest() = default;
NetAvailable()126     int32_t NetAvailable() override
127     {
128         return 0;
129     }
NetCapabilitiesChange(const NetConnectType & netConnectType,const NetConnectSubtype & netConnectSubtype)130     int32_t NetCapabilitiesChange(const NetConnectType &netConnectType,
131         const NetConnectSubtype &netConnectSubtype) override
132     {
133         return 0;
134     }
NetConnectionPropertiesChange()135     int32_t NetConnectionPropertiesChange() override
136     {
137         return 0;
138     }
NetUnavailable()139     int32_t NetUnavailable() override
140     {
141         return 0;
142     }
OnNetCapabilitiesChanged(const std::shared_ptr<NetCapabilitiesAdapter> capabilities)143     int32_t OnNetCapabilitiesChanged(
144         const std::shared_ptr<NetCapabilitiesAdapter> capabilities) override
145     {
146         return 0;
147     }
OnNetConnectionPropertiesChanged(const std::shared_ptr<NetConnectionPropertiesAdapter> properties)148     int32_t OnNetConnectionPropertiesChanged(
149         const std::shared_ptr<NetConnectionPropertiesAdapter> properties) override
150     {
151         return 0;
152     }
153 };
154 
155 /**
156  * @tc.name: NetConnectAdapterImplTest_001.
157  * @tc.desc: test lock type.
158  * @tc.type: FUNC
159  * @tc.require:
160  */
161 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_001, TestSize.Level1)
162 {
163     std::shared_ptr<NetConnCallbackTest> cb = std::make_shared<NetConnCallbackTest>();
164     std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
165     EXPECT_NE(netConnectAdapterImpl, nullptr);
166     g_regNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
167     EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(cb), 0);
168     g_regNetConnCallback = -1;
169     EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(nullptr), -1);
170     g_unregNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
171     EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(0), 0);
172     EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(-1), -1);
173 
174     g_regNetConnCallback = static_cast<int32_t>(NETMANAGER_SUCCESS);
175     EXPECT_EQ(netConnectAdapterImpl->RegisterNetConnCallback(cb), 1);
176     g_unregNetConnCallback = -1;
177     EXPECT_EQ(netConnectAdapterImpl->UnregisterNetConnCallback(1), -1);
178 }
179 
180 /**
181  * @tc.name: NetConnectAdapterImplTest_002.
182  * @tc.desc: test lock type.
183  * @tc.type: FUNC
184  * @tc.require:
185  */
186 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_002, TestSize.Level1)
187 {
188     std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
189     NetConnectType type = NetConnectType::CONNECTION_UNKNOWN;
190     NetConnectSubtype subtype = NetConnectSubtype::SUBTYPE_UNKNOWN;
191     g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
192     g_getNetCap = static_cast<int32_t>(NETMANAGER_SUCCESS);
193     EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), 0);
194     g_slotId = -1;
195     EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), 0);
196     g_getDefaultNet = -1;
197     EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), -1);
198     g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
199     g_getNetCap = -1;
200     EXPECT_EQ(netConnectAdapterImpl->GetDefaultNetConnect(type, subtype), -1);
201 }
202 
203 /**
204  * @tc.name: NetConnectAdapterImplTest_003.
205  * @tc.desc: test lock type.
206  * @tc.type: FUNC
207  * @tc.require:
208  */
209 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_003, TestSize.Level1)
210 {
211     std::shared_ptr<NetConnectAdapterImpl> netConnectAdapterImpl = std::make_shared<NetConnectAdapterImpl>();
212     g_getDefaultNet = static_cast<int32_t>(NETMANAGER_SUCCESS);
213     g_getNetProp = static_cast<int32_t>(NETMANAGER_SUCCESS);
214     std::vector<std::string> dns_servers = netConnectAdapterImpl->GetDnsServers();
215     EXPECT_EQ(dns_servers.size(), 1);
216     std::string dns_ip_str("192.168.2.1");
217     EXPECT_EQ(dns_servers.front(), dns_ip_str);
218     g_getDefaultNet = -1;
219     dns_servers = netConnectAdapterImpl->GetDnsServers();
220     EXPECT_EQ(dns_servers.size(), 0);
221     g_getNetProp = -1;
222     dns_servers = netConnectAdapterImpl->GetDnsServers();
223     EXPECT_EQ(dns_servers.size(), 0);
224 }
225 
226 /**
227  * @tc.name: NetConnectAdapterImplTest_004.
228  * @tc.desc: test lock type.
229  * @tc.type: FUNC
230  * @tc.require:
231  */
232 HWTEST_F(NetConnectAdapterImplTest, NetConnectAdapterImplTest_004, 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->GetDnsServersByNetId(-1);
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->GetDnsServersByNetId(-1);
243     EXPECT_EQ(dns_servers.size(), 0);
244     g_getAllNets = static_cast<int32_t>(NETMANAGER_SUCCESS);
245     dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(100);
246     EXPECT_EQ(dns_servers.size(), 1);
247     EXPECT_EQ(dns_servers.front(), dns_ip_str);
248     dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(101);
249     EXPECT_EQ(dns_servers.size(), 0);
250     g_getNetProp = -1;
251     dns_servers = netConnectAdapterImpl->GetDnsServersByNetId(100);
252     EXPECT_EQ(dns_servers.size(), 0);
253 }
254 }
255 }
256