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: TestIsNetworkInterfaceDisabledSuc_01
174 * @tc.desc: Test IsNetworkInterfaceDisabled func.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledSuc_01, 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::InvokeBoolSendRequestGetPolicy));
184 bool status = false;
185 std::string networkInterface = "eth0";
186 MessageParcel data;
187 data.WriteInt32(HAS_ADMIN);
188 data.WriteParcelable(&admin);
189 data.WriteString(networkInterface);
190 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(data, status);
191 ASSERT_TRUE(ret == ERR_OK);
192 ASSERT_TRUE(status);
193 }
194
195 /**
196 * @tc.name: TestIsNetworkInterfaceDisabledFail_01
197 * @tc.desc: Test IsNetworkInterfaceDisabled func.
198 * @tc.type: FUNC
199 */
200 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledFail_01, TestSize.Level1)
201 {
202 Utils::SetEdmServiceDisable();
203 AppExecFwk::ElementName admin;
204 admin.SetBundleName(ADMIN_PACKAGENAME);
205 bool status = false;
206 std::string networkInterface = "eth0";
207 MessageParcel data;
208 data.WriteInt32(HAS_ADMIN);
209 data.WriteParcelable(&admin);
210 data.WriteString(networkInterface);
211 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(data, status);
212 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
213 ASSERT_FALSE(status);
214 }
215
216 /**
217 * @tc.name: TestSetNetworkInterfaceDisabledSuc
218 * @tc.desc: Test SetNetworkInterfaceDisabled func.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledSuc, TestSize.Level1)
222 {
223 AppExecFwk::ElementName admin;
224 admin.SetBundleName(ADMIN_PACKAGENAME);
225 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
226 .Times(1)
227 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
228 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
229 ASSERT_TRUE(ret == ERR_OK);
230 }
231
232 /**
233 * @tc.name: TestSetNetworkInterfaceDisabledFail
234 * @tc.desc: Test SetNetworkInterfaceDisabled func.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledFail, TestSize.Level1)
238 {
239 Utils::SetEdmServiceDisable();
240 AppExecFwk::ElementName admin;
241 admin.SetBundleName(ADMIN_PACKAGENAME);
242 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
243 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
244 }
245
246 /**
247 * @tc.name: TestAddIptablesFilterRuleSuc
248 * @tc.desc: Test AddIptablesFilterRule func.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleSuc, TestSize.Level1)
252 {
253 AppExecFwk::ElementName admin;
254 admin.SetBundleName(ADMIN_PACKAGENAME);
255 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
256 .Times(1)
257 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
258 IPTABLES::AddFilter addFilter;
259 MessageParcel data;
260 data.WriteParcelable(&admin);
261 IPTABLES::IptablesUtils::WriteAddFilterConfig(addFilter, data);
262 int32_t ret = networkManagerProxy->AddIptablesFilterRule(data);
263 ASSERT_TRUE(ret == ERR_OK);
264 }
265
266 /**
267 * @tc.name: TestAddIptablesFilterRuleFail
268 * @tc.desc: Test AddIptablesFilterRule func.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleFail, TestSize.Level1)
272 {
273 Utils::SetEdmServiceDisable();
274 AppExecFwk::ElementName admin;
275 admin.SetBundleName(ADMIN_PACKAGENAME);
276 IPTABLES::AddFilter addFilter;
277 MessageParcel data;
278 data.WriteParcelable(&admin);
279 IPTABLES::IptablesUtils::WriteAddFilterConfig(addFilter, data);
280 int32_t ret = networkManagerProxy->AddIptablesFilterRule(data);
281 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
282 }
283
284 /**
285 * @tc.name: TestRemoveIptablesFilterRuleSuc
286 * @tc.desc: Test RemoveIptablesFilterRule func.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleSuc, TestSize.Level1)
290 {
291 AppExecFwk::ElementName admin;
292 admin.SetBundleName(ADMIN_PACKAGENAME);
293 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
294 .Times(1)
295 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
296 IPTABLES::RemoveFilter removeFilter;
297 MessageParcel data;
298 data.WriteParcelable(&admin);
299 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(removeFilter, data);
300 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(data);
301 ASSERT_TRUE(ret == ERR_OK);
302 }
303
304 /**
305 * @tc.name: TestRemoveIptablesFilterRuleFail
306 * @tc.desc: Test RemoveIptablesFilterRule func.
307 * @tc.type: FUNC
308 */
309 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleFail, TestSize.Level1)
310 {
311 Utils::SetEdmServiceDisable();
312 AppExecFwk::ElementName admin;
313 admin.SetBundleName(ADMIN_PACKAGENAME);
314 IPTABLES::RemoveFilter removeFilter;
315 MessageParcel data;
316 data.WriteParcelable(&admin);
317 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(removeFilter, data);
318 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(data);
319 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
320 }
321
322 /**
323 * @tc.name: TestListIptablesFilterRulesSuc
324 * @tc.desc: Test ListIptablesFilterRules func.
325 * @tc.type: FUNC
326 */
327 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesSuc, TestSize.Level1)
328 {
329 AppExecFwk::ElementName admin;
330 admin.SetBundleName(ADMIN_PACKAGENAME);
331 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
332 .Times(1)
333 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
334 std::string result;
335 MessageParcel data;
336 data.WriteInt32(HAS_ADMIN);
337 data.WriteParcelable(&admin);
338 int32_t ret = networkManagerProxy->ListIptablesFilterRules(data, result);
339 ASSERT_TRUE(ret == ERR_OK);
340 }
341
342 /**
343 * @tc.name: TestListIptablesFilterRulesFail
344 * @tc.desc: Test ListIptablesFilterRules func.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesFail, TestSize.Level1)
348 {
349 Utils::SetEdmServiceDisable();
350 AppExecFwk::ElementName admin;
351 admin.SetBundleName(ADMIN_PACKAGENAME);
352 std::string result;
353 MessageParcel data;
354 data.WriteInt32(HAS_ADMIN);
355 data.WriteParcelable(&admin);
356 int32_t ret = networkManagerProxy->ListIptablesFilterRules(data, result);
357 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
358 }
359
360 /**
361 * @tc.name: TestSetGlobalHttpProxySuc
362 * @tc.desc: Test SetGlobalHttpProxy func.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxySuc, TestSize.Level1)
366 {
367 AppExecFwk::ElementName admin;
368 admin.SetBundleName(ADMIN_PACKAGENAME);
369 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
370 .Times(1)
371 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
372 OHOS::NetManagerStandard::HttpProxy httpProxy;
373 httpProxy.SetHost("baidu.com");
374 httpProxy.SetPort(1234);
375 std::list<std::string> list = {"192.168.1.100"};
376 httpProxy.SetExclusionList(list);
377 MessageParcel data;
378 data.WriteParcelable(&admin);
379 bool retBool = httpProxy.Marshalling(data);
380 ASSERT_TRUE(retBool);
381 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(data);
382 ASSERT_TRUE(ret == ERR_OK);
383 }
384
385 /**
386 * @tc.name: TestSetGlobalHttpProxyFail
387 * @tc.desc: Test SetGlobalHttpProxy func.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxyFail, TestSize.Level1)
391 {
392 Utils::SetEdmServiceDisable();
393 AppExecFwk::ElementName admin;
394 admin.SetBundleName(ADMIN_PACKAGENAME);
395 OHOS::NetManagerStandard::HttpProxy httpProxy;
396 httpProxy.SetHost("baidu.com");
397 httpProxy.SetPort(1234);
398 std::list<std::string> list = {"192.168.1.100"};
399 httpProxy.SetExclusionList(list);
400 MessageParcel data;
401 data.WriteParcelable(&admin);
402 bool retBool = httpProxy.Marshalling(data);
403 ASSERT_TRUE(retBool);
404 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(data);
405 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
406 }
407
408 /**
409 * @tc.name: TestGetGlobalHttpProxySuc
410 * @tc.desc: Test GetGlobalHttpProxy func.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxySuc, TestSize.Level1)
414 {
415 AppExecFwk::ElementName admin;
416 admin.SetBundleName(ADMIN_PACKAGENAME);
417 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
418 .Times(1)
419 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeHttpProxySendRequestGetPolicy));
420 NetManagerStandard::HttpProxy httpProxy;
421 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
422 ASSERT_TRUE(ret == ERR_OK);
423 }
424
425 /**
426 * @tc.name: TestGetGlobalHttpProxyFail
427 * @tc.desc: Test GetGlobalHttpProxy func.
428 * @tc.type: FUNC
429 */
430 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxyFail, TestSize.Level1)
431 {
432 Utils::SetEdmServiceDisable();
433 AppExecFwk::ElementName admin;
434 admin.SetBundleName(ADMIN_PACKAGENAME);
435 NetManagerStandard::HttpProxy httpProxy;
436 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
437 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
438 }
439
440 /**
441 * @tc.name: TestAddFirewallRuleSuc
442 * @tc.desc: Test AddFirewallRule func.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleSuc, TestSize.Level1)
446 {
447 AppExecFwk::ElementName admin;
448 admin.SetBundleName(ADMIN_PACKAGENAME);
449 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
450 .Times(1)
451 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
452 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
453 "", "", "", "", ""};
454 MessageParcel data;
455 data.WriteParcelable(&admin);
456 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
457 bool retBool = firewallRuleParcel.Marshalling(data);
458 ASSERT_TRUE(retBool);
459 int32_t ret = networkManagerProxy->AddFirewallRule(data);
460 ASSERT_TRUE(ret == ERR_OK);
461 }
462
463 /**
464 * @tc.name: TestAddFirewallRuleFail
465 * @tc.desc: Test AddFirewallRule func.
466 * @tc.type: FUNC
467 */
468 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleFail, TestSize.Level1)
469 {
470 Utils::SetEdmServiceDisable();
471 AppExecFwk::ElementName admin;
472 admin.SetBundleName(ADMIN_PACKAGENAME);
473 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
474 "", "", "", "", ""};
475 MessageParcel data;
476 data.WriteParcelable(&admin);
477 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
478 bool retBool = firewallRuleParcel.Marshalling(data);
479 ASSERT_TRUE(retBool);
480 int32_t ret = networkManagerProxy->AddFirewallRule(data);
481 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
482 }
483
484 /**
485 * @tc.name: TestRemoveFirewallRuleSuc
486 * @tc.desc: Test RemoveFirewallRule func.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleSuc, TestSize.Level1)
490 {
491 AppExecFwk::ElementName admin;
492 admin.SetBundleName(ADMIN_PACKAGENAME);
493 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
494 .Times(1)
495 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
496 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
497 "", "", "", "", ""};
498 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
499 ASSERT_TRUE(ret == ERR_OK);
500 }
501
502 /**
503 * @tc.name: TestRemoveFirewallRuleFail
504 * @tc.desc: Test RemoveFirewallRule func.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleFail, TestSize.Level1)
508 {
509 Utils::SetEdmServiceDisable();
510 AppExecFwk::ElementName admin;
511 admin.SetBundleName(ADMIN_PACKAGENAME);
512 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
513 "", "", "", "", ""};
514 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
515 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
516 }
517
518 /**
519 * @tc.name: TestGetFirewallRulesSuc
520 * @tc.desc: Test GetFirewallRules func.
521 * @tc.type: FUNC
522 */
523 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesSuc, TestSize.Level1)
524 {
525 AppExecFwk::ElementName admin;
526 admin.SetBundleName(ADMIN_PACKAGENAME);
527
528 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
529 .Times(1)
530 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetFirewallRule));
531 std::vector<IPTABLES::FirewallRule> result;
532 MessageParcel data;
533 data.WriteInt32(HAS_ADMIN);
534 data.WriteParcelable(&admin);
535 int32_t ret = networkManagerProxy->GetFirewallRules(data, result);
536 ASSERT_TRUE(ret == ERR_OK);
537 ASSERT_TRUE(result.size() == 1);
538 }
539
540 /**
541 * @tc.name: TestGetFirewallRulesFail
542 * @tc.desc: Test GetFirewallRules func.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesFail, TestSize.Level1)
546 {
547 Utils::SetEdmServiceDisable();
548 AppExecFwk::ElementName admin;
549 admin.SetBundleName(ADMIN_PACKAGENAME);
550 std::vector<IPTABLES::FirewallRule> result;
551 MessageParcel data;
552 data.WriteInt32(HAS_ADMIN);
553 data.WriteParcelable(&admin);
554 int32_t ret = networkManagerProxy->GetFirewallRules(data, result);
555 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
556 }
557
558 /**
559 * @tc.name: TestAddDomainFilterRuleSuc
560 * @tc.desc: Test AddDomainFilterRule func.
561 * @tc.type: FUNC
562 */
563 HWTEST_F(NetworkManagerProxyTest, TestAddDomainFilterRuleSuc, TestSize.Level1)
564 {
565 AppExecFwk::ElementName admin;
566 admin.SetBundleName(ADMIN_PACKAGENAME);
567 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
568 .Times(1)
569 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
570 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
571 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
572 MessageParcel data;
573 data.WriteParcelable(&admin);
574 bool retBool = domainFilterRuleParcel.Marshalling(data);
575 ASSERT_TRUE(retBool);
576 int32_t ret = networkManagerProxy->AddDomainFilterRule(data);
577 ASSERT_TRUE(ret == ERR_OK);
578 }
579
580 /**
581 * @tc.name: TestAddDomainFilterRuleFail
582 * @tc.desc: Test AddDomainFilterRule func.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(NetworkManagerProxyTest, TestAddDomainFilterRuleFail, TestSize.Level1)
586 {
587 Utils::SetEdmServiceDisable();
588 AppExecFwk::ElementName admin;
589 admin.SetBundleName(ADMIN_PACKAGENAME);
590 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
591 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
592 MessageParcel data;
593 data.WriteParcelable(&admin);
594 bool retBool = domainFilterRuleParcel.Marshalling(data);
595 ASSERT_TRUE(retBool);
596 int32_t ret = networkManagerProxy->AddDomainFilterRule(data);
597 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
598 }
599
600 /**
601 * @tc.name: TestRemoveDomainFilterRuleSuc
602 * @tc.desc: Test RemoveDomainFilterRule func.
603 * @tc.type: FUNC
604 */
605 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleSuc, TestSize.Level1)
606 {
607 AppExecFwk::ElementName admin;
608 admin.SetBundleName(ADMIN_PACKAGENAME);
609 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
610 .Times(1)
611 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
612 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
613 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
614 ASSERT_TRUE(ret == ERR_OK);
615 }
616
617 /**
618 * @tc.name: TestRemoveDomainFilterRuleFail
619 * @tc.desc: Test RemoveDomainFilterRule func.
620 * @tc.type: FUNC
621 */
622 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleFail, TestSize.Level1)
623 {
624 Utils::SetEdmServiceDisable();
625 AppExecFwk::ElementName admin;
626 admin.SetBundleName(ADMIN_PACKAGENAME);
627 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
628 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
629 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
630 }
631
632 /**
633 * @tc.name: TestGetDomainFilterRulesSuc
634 * @tc.desc: Test GetDomainFilterRules func.
635 * @tc.type: FUNC
636 */
637 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesSuc, TestSize.Level1)
638 {
639 AppExecFwk::ElementName admin;
640 admin.SetBundleName(ADMIN_PACKAGENAME);
641
642 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
643 .Times(1)
644 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetDomainFilterRules));
645 std::vector<IPTABLES::DomainFilterRule> result;
646 MessageParcel data;
647 data.WriteInt32(HAS_ADMIN);
648 data.WriteParcelable(&admin);
649 int32_t ret = networkManagerProxy->GetDomainFilterRules(data, result);
650 ASSERT_TRUE(ret == ERR_OK);
651 ASSERT_TRUE(result.size() == 1);
652 }
653
654 /**
655 * @tc.name: TestGetDomainFilterRulesFail
656 * @tc.desc: Test GetDomainFilterRules func.
657 * @tc.type: FUNC
658 */
659 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesFail, TestSize.Level1)
660 {
661 Utils::SetEdmServiceDisable();
662 AppExecFwk::ElementName admin;
663 admin.SetBundleName(ADMIN_PACKAGENAME);
664 std::vector<IPTABLES::DomainFilterRule> result;
665 MessageParcel data;
666 data.WriteInt32(HAS_ADMIN);
667 data.WriteParcelable(&admin);
668 int32_t ret = networkManagerProxy->GetDomainFilterRules(data, result);
669 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
670 }
671 } // namespace TEST
672 } // namespace EDM
673 } // namespace OHOS
674