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