1 /*
2  * Copyright (c) 2023-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 
16 #include <gtest/gtest.h>
17 
18 #include "ethernet_client.h"
19 #include "gtest/gtest-message.h"
20 #include "gtest/gtest-test-part.h"
21 #include "gtest/hwext/gtest-ext.h"
22 #include "gtest/hwext/gtest-tag.h"
23 #include <vector>
24 #include "interface_configuration.h"
25 #include "interface_type.h"
26 #include "mac_address_info.h"
27 #include "net_manager_constants.h"
28 #include "netmanager_ext_test_security.h"
29 #include "netmgr_ext_log_wrapper.h"
30 #include "refbase.h"
31 #include "static_configuration.h"
32 
33 #define private public
34 #define protected public
35 #include "ethernet_client.h"
36 #include "ethernet_dhcp_controller.h"
37 #include "ethernet_management.h"
38 #include "ethernet_service.h"
39 #include "ethernet_service_proxy.h"
40 
41 namespace OHOS {
42 namespace NetManagerStandard {
43 namespace {
44 using namespace testing::ext;
45 constexpr const char *DEV_NAME = "eth0";
46 constexpr const char *IFACE_NAME = "wlan0";
47 } // namespace
48 
49 class EtherNetServiceTest : public testing::Test {
50 public:
51     static void SetUpTestCase();
52     static void TearDownTestCase();
53     sptr<InterfaceConfiguration> GetIfaceConfig();
54     void SetUp();
55     void TearDown();
56 };
57 
GetIfaceConfig()58 sptr<InterfaceConfiguration> EtherNetServiceTest::GetIfaceConfig()
59 {
60     sptr<InterfaceConfiguration> ic = (std::make_unique<InterfaceConfiguration>()).release();
61     if (!ic) {
62         return ic;
63     }
64     INetAddr ipv4Addr;
65     ipv4Addr.type_ = INetAddr::IPV4;
66     ipv4Addr.family_ = 0x01;
67     ipv4Addr.prefixlen_ = 0x01;
68     ipv4Addr.address_ = "172.17.5.234";
69     ipv4Addr.netMask_ = "255.255.254.0";
70     ipv4Addr.hostName_ = "netAddr";
71     ic->ipStatic_.ipAddrList_.push_back(ipv4Addr);
72     INetAddr route;
73     route.type_ = INetAddr::IPV4;
74     route.family_ = 0x01;
75     route.prefixlen_ = 0x01;
76     route.address_ = "0.0.0.0";
77     route.netMask_ = "0.0.0.0";
78     route.hostName_ = "netAddr";
79     ic->ipStatic_.routeList_.push_back(route);
80     INetAddr gateway;
81     gateway.type_ = INetAddr::IPV4;
82     gateway.family_ = 0x01;
83     gateway.prefixlen_ = 0x01;
84     gateway.address_ = "172.17.4.1";
85     gateway.netMask_ = "0.0.0.0";
86     gateway.hostName_ = "netAddr";
87     ic->ipStatic_.gatewayList_.push_back(gateway);
88     INetAddr netMask;
89     netMask.type_ = INetAddr::IPV4;
90     netMask.family_ = 0x01;
91     netMask.address_ = "255.255.255.0";
92     netMask.hostName_ = "netAddr";
93     ic->ipStatic_.netMaskList_.push_back(netMask);
94     INetAddr dns1;
95     dns1.type_ = INetAddr::IPV4;
96     dns1.family_ = 0x01;
97     dns1.address_ = "8.8.8.8";
98     dns1.hostName_ = "netAddr";
99     INetAddr dns2;
100     dns2.type_ = INetAddr::IPV4;
101     dns2.family_ = 0x01;
102     dns2.address_ = "114.114.114.114";
103     dns2.hostName_ = "netAddr";
104     ic->ipStatic_.dnsServers_.push_back(dns1);
105     ic->ipStatic_.dnsServers_.push_back(dns2);
106     return ic;
107 }
108 
SetUpTestCase()109 void EtherNetServiceTest::SetUpTestCase() {}
110 
TearDownTestCase()111 void EtherNetServiceTest::TearDownTestCase() {}
112 
SetUp()113 void EtherNetServiceTest::SetUp() {}
114 
TearDown()115 void EtherNetServiceTest::TearDown() {}
116 
117 HWTEST_F(EtherNetServiceTest, OnInterfaceAddressUpdatedTest001, TestSize.Level1)
118 {
119     EthernetService ethernetservice;
120     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
121     std::string addr;
122     std::string ifName;
123     int flags = 0;
124     int scope = 0;
125     int ret = globalinterfacestatecallback.OnInterfaceAddressUpdated(addr, ifName, flags, scope);
126     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
127 }
128 
129 HWTEST_F(EtherNetServiceTest, OnInterfaceAddressRemovedTest001, TestSize.Level1)
130 {
131     EthernetService ethernetservice;
132     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
133     std::string addr;
134     std::string ifName;
135     int flags = 0;
136     int scope = 0;
137     int ret = globalinterfacestatecallback.OnInterfaceAddressRemoved(addr, ifName, flags, scope);
138     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
139 }
140 
141 HWTEST_F(EtherNetServiceTest, OnInterfaceAddedTest001, TestSize.Level1)
142 {
143     EthernetService ethernetservice;
144     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
145     std::string iface;
146     int ret = globalinterfacestatecallback.OnInterfaceAdded(iface);
147     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
148 }
149 
150 HWTEST_F(EtherNetServiceTest, OnInterfaceRemovedTest001, TestSize.Level1)
151 {
152     EthernetService ethernetservice;
153     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
154     std::string iface;
155     int ret = globalinterfacestatecallback.OnInterfaceRemoved(iface);
156     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
157 }
158 
159 HWTEST_F(EtherNetServiceTest, OnInterfaceChangedTest001, TestSize.Level1)
160 {
161     EthernetService ethernetservice;
162     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
163     std::string iface;
164     int ret = globalinterfacestatecallback.OnInterfaceChanged(iface, true);
165     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
166 }
167 
168 HWTEST_F(EtherNetServiceTest, OnInterfaceLinkStateChangedTest001, TestSize.Level1)
169 {
170     EthernetService ethernetservice;
171     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
172     std::string ifName;
173     int ret = globalinterfacestatecallback.OnInterfaceLinkStateChanged(ifName, true);
174     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
175 }
176 
177 HWTEST_F(EtherNetServiceTest, OnRouteChangedTest001, TestSize.Level1)
178 {
179     EthernetService ethernetservice;
180     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
181     bool updated = true;
182     std::string route;
183     std::string gateway;
184     std::string ifName;
185     int ret = globalinterfacestatecallback.OnRouteChanged(updated, route, gateway, ifName);
186     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
187 }
188 
189 HWTEST_F(EtherNetServiceTest, OnDhcpSuccessTest001, TestSize.Level1)
190 {
191     EthernetService ethernetservice;
192     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
193     NetsysControllerCallback::DhcpResult dhcpResult;
194     int ret = globalinterfacestatecallback.OnDhcpSuccess(dhcpResult);
195     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
196 }
197 
198 HWTEST_F(EtherNetServiceTest, OnBandwidthReachedLimitTest001, TestSize.Level1)
199 {
200     EthernetService ethernetservice;
201     EthernetService::GlobalInterfaceStateCallback globalinterfacestatecallback(ethernetservice);
202     std::string limitName;
203     std::string iface;
204     int ret = globalinterfacestatecallback.OnBandwidthReachedLimit(limitName, iface);
205     EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
206 }
207 
208 HWTEST_F(EtherNetServiceTest, GetMacAddressTest001, TestSize.Level1)
209 {
210     EthernetService ethernetService;
211     std::string iface;
212     std::vector<MacAddressInfo> macAddrList;
213     int ret = ethernetService.GetMacAddress(macAddrList);
214     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
215 }
216 
217 HWTEST_F(EtherNetServiceTest, SetIfaceConfigTest001, TestSize.Level1)
218 {
219     EthernetService ethernetService;
220     sptr<InterfaceConfiguration> ic = GetIfaceConfig();
221     int ret = ethernetService.SetIfaceConfig(DEV_NAME, ic);
222     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
223 }
224 
225 HWTEST_F(EtherNetServiceTest, GetIfaceConfigTest001, TestSize.Level1)
226 {
227     EthernetService ethernetService;
228     std::string iface;
229     sptr<InterfaceConfiguration> ifaceConfig = GetIfaceConfig();
230     int ret = ethernetService.GetIfaceConfig(iface, ifaceConfig);
231     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
232 }
233 
234 HWTEST_F(EtherNetServiceTest, IsIfaceActiveTest001, TestSize.Level1)
235 {
236     EthernetService ethernetService;
237     sptr<InterfaceConfiguration> ic = GetIfaceConfig();
238     int32_t ret = ethernetService.SetIfaceConfig(DEV_NAME, ic);
239     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
240 }
241 
242 HWTEST_F(EtherNetServiceTest, GetAllActiveIfacesTest001, TestSize.Level1)
243 {
244     EthernetService ethernetService;
245     std::vector<std::string> result;
246     int32_t ret = ethernetService.GetAllActiveIfaces(result);
247     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
248 }
249 
250 HWTEST_F(EtherNetServiceTest, ResetFactoryTest001, TestSize.Level1)
251 {
252     EthernetService ethernetService;
253     int32_t ret = ethernetService.ResetFactory();
254     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
255 }
256 
257 HWTEST_F(EtherNetServiceTest, RegisterIfacesStateChangedTest001, TestSize.Level1)
258 {
259     EthernetService ethernetService;
260     sptr<InterfaceStateCallback> callback;
261     int32_t ret = ethernetService.RegisterIfacesStateChanged(callback);
262     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
263 }
264 
265 HWTEST_F(EtherNetServiceTest, UnregisterIfacesStateChangedTest001, TestSize.Level1)
266 {
267     EthernetService ethernetService;
268     sptr<InterfaceStateCallback> callback;
269     int32_t ret = ethernetService.UnregisterIfacesStateChanged(callback);
270     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
271 }
272 
273 HWTEST_F(EtherNetServiceTest, SetInterfaceUpTest001, TestSize.Level1)
274 {
275     EthernetService ethernetService;
276     int32_t ret = ethernetService.SetInterfaceUp(DEV_NAME);
277     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
278 }
279 
280 HWTEST_F(EtherNetServiceTest, SetInterfaceDownTest001, TestSize.Level1)
281 {
282     EthernetService ethernetService;
283     int32_t ret = ethernetService.SetInterfaceDown(DEV_NAME);
284     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
285 }
286 
287 HWTEST_F(EtherNetServiceTest, GetInterfaceConfigTest001, TestSize.Level1)
288 {
289     EthernetService ethernetService;
290     OHOS::nmd::InterfaceConfigurationParcel cfg;
291     int32_t ret = ethernetService.GetInterfaceConfig(DEV_NAME, cfg);
292     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
293 }
294 
295 HWTEST_F(EtherNetServiceTest, SetInterfaceConfigTest001, TestSize.Level1)
296 {
297     EthernetService ethernetService;
298     std::string deviceId;
299     int32_t systemAbilityId = 0;
300     ethernetService.OnAddSystemAbility(systemAbilityId, deviceId);
301     ethernetService.OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, deviceId);
302     ethernetService.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
303 
304     OHOS::nmd::InterfaceConfigurationParcel config;
305     config.ifName = "eth0";
306     config.hwAddr = "";
307     config.ipv4Addr = "172.17.5.234";
308     config.prefixLength = 24;
309     config.flags.push_back("up");
310     config.flags.push_back("broadcast");
311     int32_t ret = ethernetService.SetInterfaceConfig(DEV_NAME, config);
312     EXPECT_NE(ret, NETMANAGER_EXT_SUCCESS);
313 }
314 
315 HWTEST_F(EtherNetServiceTest, EthernetServiceCommonTest001, TestSize.Level1)
316 {
317     sptr<EthernetServiceCommon> serviceComm_ = new (std::nothrow) EthernetServiceCommon();
318     if (serviceComm_ == nullptr) {
319         NETMGR_EXT_LOG_E("serviceComm_ is nullptr");
320         return;
321     }
322     auto ret = serviceComm_->ResetEthernetFactory();
323     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
324 
325     NetManagerExtAccessToken token;
326     ret = serviceComm_->ResetEthernetFactory();
327     EXPECT_EQ(ret, 0);
328 }
329 
330 HWTEST_F(EtherNetServiceTest, EthernetServiceBranchTest001, TestSize.Level1)
331 {
332     EthernetService ethernetService;
333     bool ret = ethernetService.Init();
334     EXPECT_FALSE(ret);
335 
336     ethernetService.OnStop();
337 
338     NetManagerExtNotSystemAccessToken token;
339     int32_t result = ethernetService.ResetFactory();
340     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
341 
342     ethernetService.InitManagement();
343 
344     std::string iface = "";
345 
346     std::vector<MacAddressInfo> mai;
347     result = ethernetService.GetMacAddress(mai);
348     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
349 
350     sptr<InterfaceConfiguration> ic = nullptr;
351     result = ethernetService.SetIfaceConfig(iface, ic);
352     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
353 
354     result = ethernetService.GetIfaceConfig(iface, ic);
355     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
356 
357     int32_t activeStatus = 0;
358     result = ethernetService.IsIfaceActive(iface, activeStatus);
359     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
360 
361     std::vector<std::string> activeIfaces;
362     result = ethernetService.GetAllActiveIfaces(activeIfaces);
363     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
364 
365     result = ethernetService.ResetFactory();
366     EXPECT_EQ(result, NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL);
367 }
368 
369 HWTEST_F(EtherNetServiceTest, EthernetServiceBranchTest002, TestSize.Level1)
370 {
371     NetManagerExtAccessToken token;
372     EthernetService ethernetService;
373     ethernetService.InitManagement();
374 
375     sptr<InterfaceStateCallback> callback = nullptr;
376     auto result = ethernetService.RegisterIfacesStateChanged(callback);
377     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
378 
379     result = ethernetService.UnregisterMonitorIfaceCallbackAsync(callback);
380     EXPECT_EQ(result, NETMANAGER_EXT_ERR_OPERATION_FAILED);
381 
382     OHOS::nmd::InterfaceConfigurationParcel config;
383     result = ethernetService.SetInterfaceConfig(IFACE_NAME, config);
384     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
385 
386     result = ethernetService.GetInterfaceConfig(IFACE_NAME, config);
387     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
388 
389     int32_t fd = 1;
390     std::vector<std::u16string> args;
391     result = ethernetService.Dump(fd, args);
392     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
393 
394     std::string iface = "";
395 
396     std::vector<MacAddressInfo> mai;
397     result = ethernetService.GetMacAddress(mai);
398     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
399 
400     sptr<InterfaceConfiguration> ic = nullptr;
401     result = ethernetService.SetIfaceConfig(IFACE_NAME, ic);
402     EXPECT_EQ(result, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
403 
404     result = ethernetService.GetIfaceConfig(IFACE_NAME, ic);
405     EXPECT_EQ(result, ETHERNET_ERR_DEVICE_INFORMATION_NOT_EXIST);
406 
407     int32_t activeStatus = 0;
408     result = ethernetService.IsIfaceActive(iface, activeStatus);
409     EXPECT_EQ(result, ETHERNET_ERR_DEVICE_INFORMATION_NOT_EXIST);
410 
411     result = ethernetService.SetInterfaceDown(IFACE_NAME);
412     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
413 
414     OHOS::nmd::InterfaceConfigurationParcel cfg;
415     result = ethernetService.SetInterfaceConfig(IFACE_NAME, config);
416     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
417 
418     result = ethernetService.GetInterfaceConfig(IFACE_NAME, cfg);
419     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
420 
421     result = ethernetService.ResetFactory();
422     EXPECT_EQ(result, ETHERNET_ERR_USER_CONIFGURATION_CLEAR_FAIL);
423 
424     std::vector<std::string> activeIfaces;
425     result = ethernetService.GetAllActiveIfaces(activeIfaces);
426     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
427 
428     result = ethernetService.SetInterfaceUp(IFACE_NAME);
429     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
430 }
431 
432 HWTEST_F(EtherNetServiceTest, EthernetServiceBranchTest003, TestSize.Level1)
433 {
434     EthernetService ethernetService;
435     bool ret = ethernetService.Init();
436     EXPECT_FALSE(ret);
437 
438     ethernetService.OnStart();
439     ethernetService.OnStop();
440 
441     NetManagerExtAccessToken token;
442     int32_t fd = 1;
443     std::vector<std::u16string> args;
444     int32_t result = ethernetService.Dump(fd, args);
445     EXPECT_EQ(result, NETMANAGER_EXT_SUCCESS);
446 
447     std::string iface = "";
448 
449     std::vector<MacAddressInfo> mai;
450     result = ethernetService.GetMacAddress(mai);
451     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
452 
453     sptr<InterfaceConfiguration> ic = nullptr;
454     result = ethernetService.SetIfaceConfig(iface, ic);
455     EXPECT_EQ(result, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
456 
457     result = ethernetService.GetIfaceConfig(iface, ic);
458     EXPECT_EQ(result, ETHERNET_ERR_DEVICE_INFORMATION_NOT_EXIST);
459 
460     int32_t activeStatus = 0;
461     result = ethernetService.IsIfaceActive(iface, activeStatus);
462     EXPECT_EQ(result, ETHERNET_ERR_DEVICE_INFORMATION_NOT_EXIST);
463 
464     std::vector<std::string> activeIfaces;
465     result = ethernetService.GetAllActiveIfaces(activeIfaces);
466     EXPECT_EQ(result, 0);
467 }
468 
469 HWTEST_F(EtherNetServiceTest, EthernetServiceBranchTest004, TestSize.Level1)
470 {
471     EthernetService ethernetService;
472     NoPermissionAccessToken token;
473     int32_t activeStatus = 0;
474     std::string iface = "";
475     int32_t result = ethernetService.IsIfaceActive(iface, activeStatus);
476     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PERMISSION_DENIED);
477 
478     sptr<InterfaceStateCallback> callback = nullptr;
479     result = ethernetService.RegisterIfacesStateChanged(callback);
480     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
481 
482     result = ethernetService.UnregisterIfacesStateChanged(callback);
483     EXPECT_EQ(result, NETMANAGER_EXT_ERR_PARAMETER_ERROR);
484 
485     result = ethernetService.RegisterMonitorIfaceCallbackAsync(callback);
486     EXPECT_EQ(result, NETMANAGER_EXT_ERR_OPERATION_FAILED);
487 
488     result = ethernetService.UnregisterMonitorIfaceCallbackAsync(callback);
489     EXPECT_EQ(result, NETMANAGER_EXT_ERR_OPERATION_FAILED);
490 }
491 } // namespace NetManagerStandard
492 } // namespace OHOS
493