1 /*
2  * Copyright (c) 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 <arpa/inet.h>
17 #include <gtest/gtest.h>
18 
19 #include "netfirewall_rule_manager.h"
20 #include "net_manager_constants.h"
21 #include "singleton.h"
22 
23 namespace OHOS {
24 namespace NetManagerStandard {
25 namespace {
26 using namespace testing::ext;
27 constexpr int32_t USER_ID = 100;
28 
GetNetFirewallRuleSptr(NetFirewallRuleType type,int32_t appUid=0)29 sptr<NetFirewallRule> GetNetFirewallRuleSptr(NetFirewallRuleType type, int32_t appUid = 0)
30 {
31     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
32     if (!rule) {
33         return rule;
34     }
35     rule->ruleId = 1;
36     rule->userId = USER_ID;
37     rule->ruleName = "testRule";
38     rule->ruleDescription = "testRuleDes";
39     rule->ruleDirection = NetFirewallRuleDirection::RULE_OUT;
40     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
41     rule->ruleType = type;
42     rule->isEnabled = true;
43     rule->appUid = appUid;
44     switch (type) {
45         case NetFirewallRuleType::RULE_IP: {
46             const uint8_t mask = 24;
47             std::vector<NetFirewallIpParam> localParamList;
48             NetFirewallIpParam localParam;
49             localParam.family = FAMILY_IPV4;
50             localParam.type = SINGLE_IP;
51             localParam.mask = mask;
52             inet_pton(AF_INET, "192.168.9.6", &localParam.ipv4.startIp);
53             localParamList.emplace_back(std::move(localParam));
54             rule->remoteIps = localParamList;
55             break;
56         }
57         case NetFirewallRuleType::RULE_DOMAIN: {
58             std::vector<NetFirewallDomainParam> domainList;
59             NetFirewallDomainParam domain;
60             domain.isWildcard = false;
61             domain.domain = "www.openharmony.netfirewallrulemanagertest.cn";
62             domainList.emplace_back(domain);
63             rule->domains = domainList;
64             break;
65         }
66         case NetFirewallRuleType::RULE_DNS: {
67             NetFirewallDnsParam dns;
68             dns.primaryDns = "192.168.9.1";
69             rule->dns = dns;
70             break;
71         }
72         default:
73             break;
74     }
75 
76     return rule;
77 }
78 }
79 
80 class NetFirewallRuleManagerTest : public testing::Test {
81 public:
SetUpTestCase()82     static void SetUpTestCase(){};
TearDownTestCase()83     static void TearDownTestCase(){};
SetUp()84     void SetUp(){};
TearDown()85     void TearDown(){};
86     static inline auto instance_ = DelayedSingleton<NetFirewallRuleManager>::GetInstance();
87 };
88 
89 HWTEST_F(NetFirewallRuleManagerTest, UpdateNetFirewallRule001, TestSize.Level1)
90 {
91     sptr<NetFirewallRule> rule = nullptr;
92     int32_t ret = instance_->UpdateNetFirewallRule(rule);
93     EXPECT_EQ(ret, FIREWALL_ERR_PARAMETER_ERROR);
94     rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP);
95     rule->userId++;
96     ret = instance_->UpdateNetFirewallRule(rule);
97     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
98 }
99 
100 HWTEST_F(NetFirewallRuleManagerTest, UpdateNetFirewallRule002, TestSize.Level1)
101 {
102     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP);
103     int32_t ruleId;
104     rule->isEnabled = false;
105     int32_t ret = instance_->AddNetFirewallRule(rule, ruleId);
106     EXPECT_NE(ruleId, 0);
107     rule->ruleDescription = "UpdateNetFirewallRule002";
108     rule->ruleId = ruleId;
109     ret = instance_->UpdateNetFirewallRule(rule);
110     instance_->DeleteNetFirewallRule(rule->userId, ruleId);
111     EXPECT_EQ(ret, FIREWALL_SUCCESS);
112 }
113 
114 HWTEST_F(NetFirewallRuleManagerTest, DeleteNetFirewallRule001, TestSize.Level1)
115 {
116     int32_t userId = USER_ID;
117     int32_t ruleId = 100;
118     int32_t ret = instance_->DeleteNetFirewallRule(userId + 1, ruleId);
119     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
120 
121     ret = instance_->DeleteNetFirewallRule(userId, ruleId);
122     EXPECT_EQ(ret, FIREWALL_ERR_NO_RULE);
123 
124     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP);
125     rule->isEnabled = false;
126     ret = instance_->AddNetFirewallRule(rule, ruleId);
127     EXPECT_NE(ruleId, 100);
128     ret = instance_->DeleteNetFirewallRule(rule->userId, ruleId);
129     EXPECT_EQ(ret, FIREWALL_SUCCESS);
130 }
131 
132 HWTEST_F(NetFirewallRuleManagerTest, GetEnabledNetFirewallRules001, TestSize.Level1)
133 {
134     std::vector<NetFirewallRule> list;
135     int32_t userId = USER_ID + 1;
136     int32_t ret = instance_->GetEnabledNetFirewallRules(userId, list);
137     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
138 }
139 
140 HWTEST_F(NetFirewallRuleManagerTest, GetNetFirewallRules001, TestSize.Level1)
141 {
142     int32_t userId = USER_ID;
143     sptr<RequestParam> param = nullptr;
144     sptr<FirewallRulePage> info = nullptr;
145     int32_t ret = instance_->GetNetFirewallRules(userId, param, info);
146     EXPECT_EQ(ret, FIREWALL_ERR_PARAMETER_ERROR);
147     param = new (std::nothrow) RequestParam();
148     param->page = 0;
149     param->pageSize = 5;
150     param->orderType = NetFirewallOrderType::ORDER_ASC;
151     param->orderField = NetFirewallOrderField::ORDER_BY_RULE_NAME;
152     ret = instance_->GetNetFirewallRules(userId, param, info);
153     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
154 }
155 }
156 }