1 /*
2 * Copyright (c) 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 "network_manager_proxy.h"
17
18 #include <gtest/gtest.h>
19 #include <system_ability_definition.h>
20
21 #include <string>
22 #include <vector>
23
24 #include "edm_sys_manager_mock.h"
25 #include "enterprise_device_mgr_stub_mock.h"
26 #include "iptables_utils.h"
27 #include "utils.h"
28
29 using namespace testing::ext;
30 using namespace testing;
31
32 namespace OHOS {
33 namespace EDM {
34 namespace TEST {
35 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
36 class NetworkManagerProxyTest : public testing::Test {
37 protected:
38 void SetUp() override;
39
40 void TearDown() override;
41
42 static void TearDownTestSuite(void);
43 std::shared_ptr<NetworkManagerProxy> networkManagerProxy = nullptr;
44 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
45 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
46 };
47
SetUp()48 void NetworkManagerProxyTest::SetUp()
49 {
50 networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
51 edmSysManager_ = std::make_shared<EdmSysManager>();
52 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
53 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
54 Utils::SetEdmServiceEnable();
55 }
56
TearDown()57 void NetworkManagerProxyTest::TearDown()
58 {
59 networkManagerProxy.reset();
60 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
61 object_ = nullptr;
62 Utils::SetEdmServiceDisable();
63 }
64
TearDownTestSuite()65 void NetworkManagerProxyTest::TearDownTestSuite()
66 {
67 ASSERT_FALSE(Utils::GetEdmServiceState());
68 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
69 }
70
71 /**
72 * @tc.name: TestGetAllNetworkInterfacesSuc
73 * @tc.desc: Test GetAllNetworkInterfaces func.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(NetworkManagerProxyTest, TestGetAllNetworkInterfacesSuc, TestSize.Level1)
77 {
78 AppExecFwk::ElementName admin;
79 admin.SetBundleName(ADMIN_PACKAGENAME);
80 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
81 .Times(1)
82 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeArrayStringSendRequestGetPolicy));
83 std::vector<std::string> networkInterfaces;
84 int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(admin, networkInterfaces);
85 ASSERT_TRUE(ret == ERR_OK);
86 ASSERT_TRUE(networkInterfaces.size() == 1);
87 ASSERT_TRUE(networkInterfaces[0] == RETURN_STRING);
88 }
89
90 /**
91 * @tc.name: TestGetAllNetworkInterfacesFail
92 * @tc.desc: Test GetAllNetworkInterfaces func.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(NetworkManagerProxyTest, TestGetAllNetworkInterfacesFail, TestSize.Level1)
96 {
97 Utils::SetEdmServiceDisable();
98 AppExecFwk::ElementName admin;
99 admin.SetBundleName(ADMIN_PACKAGENAME);
100 std::vector<std::string> networkInterfaces;
101 int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(admin, networkInterfaces);
102 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
103 }
104
105 /**
106 * @tc.name: TestGetIpOrMacAddressSuc
107 * @tc.desc: Test GetIpOrMacAddress func.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(NetworkManagerProxyTest, TestGetIpOrMacAddressSuc, TestSize.Level1)
111 {
112 AppExecFwk::ElementName admin;
113 admin.SetBundleName(ADMIN_PACKAGENAME);
114 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
115 .Times(1)
116 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
117 std::string info;
118 int32_t ret = networkManagerProxy->GetIpOrMacAddress(admin, "eth0", EdmInterfaceCode::GET_MAC, info);
119 ASSERT_TRUE(ret == ERR_OK);
120 ASSERT_TRUE(info == RETURN_STRING);
121 }
122
123 /**
124 * @tc.name: TestGetIpOrMacAddressFail
125 * @tc.desc: Test GetIpOrMacAddress func.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(NetworkManagerProxyTest, TestGetIpOrMacAddressFail, TestSize.Level1)
129 {
130 Utils::SetEdmServiceDisable();
131 AppExecFwk::ElementName admin;
132 admin.SetBundleName(ADMIN_PACKAGENAME);
133 std::string info;
134 int32_t ret = networkManagerProxy->GetIpOrMacAddress(admin, "eth0", EdmInterfaceCode::GET_MAC, info);
135 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
136 }
137
138 /**
139 * @tc.name: TestIsNetworkInterfaceDisabledSuc
140 * @tc.desc: Test IsNetworkInterfaceDisabled func.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledSuc, TestSize.Level1)
144 {
145 AppExecFwk::ElementName admin;
146 admin.SetBundleName(ADMIN_PACKAGENAME);
147 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
148 .Times(1)
149 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
150 bool status = false;
151 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(admin, "eth0", status);
152 ASSERT_TRUE(ret == ERR_OK);
153 ASSERT_TRUE(status);
154 }
155
156 /**
157 * @tc.name: TestIsNetworkInterfaceDisabledFail
158 * @tc.desc: Test IsNetworkInterfaceDisabled func.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledFail, TestSize.Level1)
162 {
163 Utils::SetEdmServiceDisable();
164 AppExecFwk::ElementName admin;
165 admin.SetBundleName(ADMIN_PACKAGENAME);
166 bool status = false;
167 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(admin, "eth0", status);
168 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
169 ASSERT_FALSE(status);
170 }
171
172 /**
173 * @tc.name: TestSetNetworkInterfaceDisabledSuc
174 * @tc.desc: Test SetNetworkInterfaceDisabled func.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledSuc, TestSize.Level1)
178 {
179 AppExecFwk::ElementName admin;
180 admin.SetBundleName(ADMIN_PACKAGENAME);
181 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
182 .Times(1)
183 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
184 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
185 ASSERT_TRUE(ret == ERR_OK);
186 }
187
188 /**
189 * @tc.name: TestSetNetworkInterfaceDisabledFail
190 * @tc.desc: Test SetNetworkInterfaceDisabled func.
191 * @tc.type: FUNC
192 */
193 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledFail, TestSize.Level1)
194 {
195 Utils::SetEdmServiceDisable();
196 AppExecFwk::ElementName admin;
197 admin.SetBundleName(ADMIN_PACKAGENAME);
198 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
199 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
200 }
201
202 /**
203 * @tc.name: TestAddIptablesFilterRuleSuc
204 * @tc.desc: Test AddIptablesFilterRule func.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleSuc, TestSize.Level1)
208 {
209 AppExecFwk::ElementName admin;
210 admin.SetBundleName(ADMIN_PACKAGENAME);
211 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
212 .Times(1)
213 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
214 IPTABLES::AddFilter addFilter;
215 int32_t ret = networkManagerProxy->AddIptablesFilterRule(admin, addFilter);
216 ASSERT_TRUE(ret == ERR_OK);
217 }
218
219 /**
220 * @tc.name: TestAddIptablesFilterRuleFail
221 * @tc.desc: Test AddIptablesFilterRule func.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleFail, TestSize.Level1)
225 {
226 Utils::SetEdmServiceDisable();
227 AppExecFwk::ElementName admin;
228 admin.SetBundleName(ADMIN_PACKAGENAME);
229 IPTABLES::AddFilter addFilter;
230 int32_t ret = networkManagerProxy->AddIptablesFilterRule(admin, addFilter);
231 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
232 }
233
234 /**
235 * @tc.name: TestRemoveIptablesFilterRuleSuc
236 * @tc.desc: Test RemoveIptablesFilterRule func.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleSuc, TestSize.Level1)
240 {
241 AppExecFwk::ElementName admin;
242 admin.SetBundleName(ADMIN_PACKAGENAME);
243 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
244 .Times(1)
245 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
246 IPTABLES::RemoveFilter removeFilter;
247 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(admin, removeFilter);
248 ASSERT_TRUE(ret == ERR_OK);
249 }
250
251 /**
252 * @tc.name: TestRemoveIptablesFilterRuleFail
253 * @tc.desc: Test RemoveIptablesFilterRule func.
254 * @tc.type: FUNC
255 */
256 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleFail, TestSize.Level1)
257 {
258 Utils::SetEdmServiceDisable();
259 AppExecFwk::ElementName admin;
260 admin.SetBundleName(ADMIN_PACKAGENAME);
261 IPTABLES::RemoveFilter removeFilter;
262 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(admin, removeFilter);
263 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
264 }
265
266 /**
267 * @tc.name: TestListIptablesFilterRulesSuc
268 * @tc.desc: Test ListIptablesFilterRules func.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesSuc, TestSize.Level1)
272 {
273 AppExecFwk::ElementName admin;
274 admin.SetBundleName(ADMIN_PACKAGENAME);
275 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
276 .Times(1)
277 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
278 std::string result;
279 int32_t ret = networkManagerProxy->ListIptablesFilterRules(admin, result);
280 ASSERT_TRUE(ret == ERR_OK);
281 }
282
283 /**
284 * @tc.name: TestListIptablesFilterRulesFail
285 * @tc.desc: Test ListIptablesFilterRules func.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesFail, TestSize.Level1)
289 {
290 Utils::SetEdmServiceDisable();
291 AppExecFwk::ElementName admin;
292 admin.SetBundleName(ADMIN_PACKAGENAME);
293 std::string result;
294 int32_t ret = networkManagerProxy->ListIptablesFilterRules(admin, result);
295 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
296 }
297
298 /**
299 * @tc.name: TestSetGlobalHttpProxySuc
300 * @tc.desc: Test SetGlobalHttpProxy func.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxySuc, TestSize.Level1)
304 {
305 AppExecFwk::ElementName admin;
306 admin.SetBundleName(ADMIN_PACKAGENAME);
307 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
308 .Times(1)
309 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
310 OHOS::NetManagerStandard::HttpProxy httpProxy;
311 httpProxy.SetHost("baidu.com");
312 httpProxy.SetPort(1234);
313 std::list<std::string> list = {"192.168.1.100"};
314 httpProxy.SetExclusionList(list);
315 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(admin, httpProxy);
316 ASSERT_TRUE(ret == ERR_OK);
317 }
318
319 /**
320 * @tc.name: TestSetGlobalHttpProxyFail
321 * @tc.desc: Test SetGlobalHttpProxy func.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxyFail, TestSize.Level1)
325 {
326 Utils::SetEdmServiceDisable();
327 AppExecFwk::ElementName admin;
328 admin.SetBundleName(ADMIN_PACKAGENAME);
329 OHOS::NetManagerStandard::HttpProxy httpProxy;
330 httpProxy.SetHost("baidu.com");
331 httpProxy.SetPort(1234);
332 std::list<std::string> list = {"192.168.1.100"};
333 httpProxy.SetExclusionList(list);
334 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(admin, httpProxy);
335 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
336 }
337
338 /**
339 * @tc.name: TestGetGlobalHttpProxySuc
340 * @tc.desc: Test GetGlobalHttpProxy func.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxySuc, TestSize.Level1)
344 {
345 AppExecFwk::ElementName admin;
346 admin.SetBundleName(ADMIN_PACKAGENAME);
347 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
348 .Times(1)
349 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeHttpProxySendRequestGetPolicy));
350 NetManagerStandard::HttpProxy httpProxy;
351 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
352 ASSERT_TRUE(ret == ERR_OK);
353 }
354
355 /**
356 * @tc.name: TestGetGlobalHttpProxyFail
357 * @tc.desc: Test GetGlobalHttpProxy func.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxyFail, TestSize.Level1)
361 {
362 Utils::SetEdmServiceDisable();
363 AppExecFwk::ElementName admin;
364 admin.SetBundleName(ADMIN_PACKAGENAME);
365 NetManagerStandard::HttpProxy httpProxy;
366 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
367 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
368 }
369
370 /**
371 * @tc.name: TestAddFirewallRuleSuc
372 * @tc.desc: Test AddFirewallRule func.
373 * @tc.type: FUNC
374 */
375 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleSuc, TestSize.Level1)
376 {
377 AppExecFwk::ElementName admin;
378 admin.SetBundleName(ADMIN_PACKAGENAME);
379 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
380 .Times(1)
381 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
382 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
383 "", "", "", "", ""};
384 int32_t ret = networkManagerProxy->AddFirewallRule(admin, rule);
385 ASSERT_TRUE(ret == ERR_OK);
386 }
387
388 /**
389 * @tc.name: TestAddFirewallRuleFail
390 * @tc.desc: Test AddFirewallRule func.
391 * @tc.type: FUNC
392 */
393 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleFail, TestSize.Level1)
394 {
395 Utils::SetEdmServiceDisable();
396 AppExecFwk::ElementName admin;
397 admin.SetBundleName(ADMIN_PACKAGENAME);
398 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
399 "", "", "", "", ""};
400 int32_t ret = networkManagerProxy->AddFirewallRule(admin, rule);
401 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
402 }
403
404 /**
405 * @tc.name: TestRemoveFirewallRuleSuc
406 * @tc.desc: Test RemoveFirewallRule func.
407 * @tc.type: FUNC
408 */
409 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleSuc, TestSize.Level1)
410 {
411 AppExecFwk::ElementName admin;
412 admin.SetBundleName(ADMIN_PACKAGENAME);
413 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
414 .Times(1)
415 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
416 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
417 "", "", "", "", ""};
418 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
419 ASSERT_TRUE(ret == ERR_OK);
420 }
421
422 /**
423 * @tc.name: TestRemoveFirewallRuleFail
424 * @tc.desc: Test RemoveFirewallRule func.
425 * @tc.type: FUNC
426 */
427 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleFail, TestSize.Level1)
428 {
429 Utils::SetEdmServiceDisable();
430 AppExecFwk::ElementName admin;
431 admin.SetBundleName(ADMIN_PACKAGENAME);
432 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
433 "", "", "", "", ""};
434 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
435 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
436 }
437
438 /**
439 * @tc.name: TestGetFirewallRulesSuc
440 * @tc.desc: Test GetFirewallRules func.
441 * @tc.type: FUNC
442 */
443 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesSuc, TestSize.Level1)
444 {
445 AppExecFwk::ElementName admin;
446 admin.SetBundleName(ADMIN_PACKAGENAME);
447
448 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
449 .Times(1)
450 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetFirewallRule));
451 std::vector<IPTABLES::FirewallRule> result;
452 int32_t ret = networkManagerProxy->GetFirewallRules(admin, result);
453 ASSERT_TRUE(ret == ERR_OK);
454 ASSERT_TRUE(result.size() == 1);
455 }
456
457 /**
458 * @tc.name: TestGetFirewallRulesFail
459 * @tc.desc: Test GetFirewallRules func.
460 * @tc.type: FUNC
461 */
462 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesFail, TestSize.Level1)
463 {
464 Utils::SetEdmServiceDisable();
465 AppExecFwk::ElementName admin;
466 admin.SetBundleName(ADMIN_PACKAGENAME);
467 std::vector<IPTABLES::FirewallRule> result;
468 int32_t ret = networkManagerProxy->GetFirewallRules(admin, result);
469 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
470 }
471
472 /**
473 * @tc.name: TestAddAddDomainFilterRuleSuc
474 * @tc.desc: Test AddDomainFilterRule func.
475 * @tc.type: FUNC
476 */
477 HWTEST_F(NetworkManagerProxyTest, TestAddAddDomainFilterRuleSuc, TestSize.Level1)
478 {
479 AppExecFwk::ElementName admin;
480 admin.SetBundleName(ADMIN_PACKAGENAME);
481 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
482 .Times(1)
483 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
484 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com"};
485 int32_t ret = networkManagerProxy->AddDomainFilterRule(admin, rule);
486 ASSERT_TRUE(ret == ERR_OK);
487 }
488
489 /**
490 * @tc.name: TestAddDomainFilterRuleFail
491 * @tc.desc: Test AddDomainFilterRule func.
492 * @tc.type: FUNC
493 */
494 HWTEST_F(NetworkManagerProxyTest, TestAddDomainFilterRuleFail, TestSize.Level1)
495 {
496 Utils::SetEdmServiceDisable();
497 AppExecFwk::ElementName admin;
498 admin.SetBundleName(ADMIN_PACKAGENAME);
499 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com"};
500 int32_t ret = networkManagerProxy->AddDomainFilterRule(admin, rule);
501 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
502 }
503
504 /**
505 * @tc.name: TestRemoveDomainFilterRuleSuc
506 * @tc.desc: Test RemoveDomainFilterRule func.
507 * @tc.type: FUNC
508 */
509 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleSuc, TestSize.Level1)
510 {
511 AppExecFwk::ElementName admin;
512 admin.SetBundleName(ADMIN_PACKAGENAME);
513 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
514 .Times(1)
515 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
516 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com"};
517 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
518 ASSERT_TRUE(ret == ERR_OK);
519 }
520
521 /**
522 * @tc.name: TestRemoveDomainFilterRuleFail
523 * @tc.desc: Test RemoveDomainFilterRule func.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleFail, TestSize.Level1)
527 {
528 Utils::SetEdmServiceDisable();
529 AppExecFwk::ElementName admin;
530 admin.SetBundleName(ADMIN_PACKAGENAME);
531 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com"};
532 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
533 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
534 }
535
536 /**
537 * @tc.name: TestGetDomainFilterRulesSuc
538 * @tc.desc: Test GetDomainFilterRules func.
539 * @tc.type: FUNC
540 */
541 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesSuc, TestSize.Level1)
542 {
543 AppExecFwk::ElementName admin;
544 admin.SetBundleName(ADMIN_PACKAGENAME);
545
546 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
547 .Times(1)
548 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetDomainFilterRules));
549 std::vector<IPTABLES::DomainFilterRule> result;
550 int32_t ret = networkManagerProxy->GetDomainFilterRules(admin, result);
551 ASSERT_TRUE(ret == ERR_OK);
552 ASSERT_TRUE(result.size() == 1);
553 }
554
555 /**
556 * @tc.name: TestGetDomainFilterRulesFail
557 * @tc.desc: Test GetDomainFilterRules func.
558 * @tc.type: FUNC
559 */
560 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesFail, TestSize.Level1)
561 {
562 Utils::SetEdmServiceDisable();
563 AppExecFwk::ElementName admin;
564 admin.SetBundleName(ADMIN_PACKAGENAME);
565 std::vector<IPTABLES::DomainFilterRule> result;
566 int32_t ret = networkManagerProxy->GetDomainFilterRules(admin, result);
567 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
568 }
569 } // namespace TEST
570 } // namespace EDM
571 } // namespace OHOS
572