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 #define private public
17 #include "firewall_rule_plugin.h"
18 #undef private
19 #include <gtest/gtest.h>
20
21 #define private public
22 #define protected public
23 #include "executer_factory.h"
24 #include "executer_utils.h"
25 #include "iptables_manager.h"
26 #undef protected
27 #undef private
28
29 #include "edm_ipc_interface_code.h"
30 #include "executer_utils_mock.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34 using namespace OHOS::EDM;
35 using namespace OHOS::EDM::IPTABLES;
36 using namespace OHOS::EDM::IPTABLES::TEST;
37
38 namespace OHOS {
39 namespace EDM {
40 namespace TEST {
41 class FirewallRulePluginTest : public testing::Test {
42 public:
43 std::shared_ptr<ExecuterUtilsMock> executerUtilsMock;
44 std::shared_ptr<IptablesManager> iptablesManager;
45
46 protected:
47 void SetUp() override;
48 void TearDown() override;
49 };
50
SetUp()51 void FirewallRulePluginTest::SetUp()
52 {
53 executerUtilsMock = std::make_shared<ExecuterUtilsMock>();
54 ExecuterUtils::instance_ = executerUtilsMock;
55
56 iptablesManager = IptablesManager::GetInstance();
57 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
58 }
59
TearDown()60 void FirewallRulePluginTest::TearDown()
61 {
62 ExecuterUtils::instance_ = nullptr;
63 ExecuterFactory::instance_ = nullptr;
64 IptablesManager::instance_ = nullptr;
65 }
66
67 /**
68 * @tc.name: TestInitPluginSuccess
69 * @tc.desc: Test FirewallRulePlugin::InitPlugin success.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(FirewallRulePluginTest, TestInitPluginSuccess, TestSize.Level1)
73 {
74 std::shared_ptr<IPlugin> plugin = FirewallRulePlugin::GetPlugin();
75 ASSERT_TRUE(plugin->IsGlobalPolicy());
76 ASSERT_TRUE(!plugin->NeedSavePolicy());
77 ASSERT_TRUE(plugin->GetCode() == (std::uint32_t)EdmInterfaceCode::FIREWALL_RULE);
78 ASSERT_EQ(plugin->GetPolicyName(), "firewall_rule");
79 ASSERT_EQ(plugin->GetPermission(FuncOperateType::SET), "ohos.permission.ENTERPRISE_MANAGE_NETWORK");
80 ASSERT_TRUE(plugin->GetPermissionType(FuncOperateType::SET) == IPlugin::PermissionType::SUPER_DEVICE_ADMIN);
81 ASSERT_TRUE(plugin->GetPermission(FuncOperateType::GET) == "ohos.permission.ENTERPRISE_MANAGE_NETWORK");
82 ASSERT_TRUE(plugin->GetPermissionType(FuncOperateType::GET) == IPlugin::PermissionType::SUPER_DEVICE_ADMIN);
83 }
84
85 /**
86 * @tc.name: TestOnGetPolicyTestSuccessBeforeInit
87 * @tc.desc: Test FirewallRulePlugin::OnGetPolicy success.
88 * @tc.type: FUNC
89 */
90 HWTEST_F(FirewallRulePluginTest, TestOnGetPolicyTestSuccessBeforeInit, TestSize.Level1)
91 {
92 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
93
94 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
95 std::string policyData;
96 MessageParcel data;
97 MessageParcel reply;
98 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, 0);
99 ASSERT_TRUE(ret == ERR_OK);
100 }
101
102 /**
103 * @tc.name: TestOnSetPolicyTestSuccessBeforeInit
104 * @tc.desc: Test FirewallRulePlugin::OnSetPolicy success.
105 * @tc.type: FUNC
106 */
107 HWTEST_F(FirewallRulePluginTest, TestOnSetPolicyTestSuccessBeforeInit, TestSize.Level1)
108 {
109 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
110
111 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
112 IPTABLES::FirewallRule rule{IPTABLES::Direction::INPUT, IPTABLES::Action::DENY, IPTABLES::Protocol::UDP,
113 "192.168.2.100", "192.168.2.200", "80", "90", ""};
114 IPTABLES::FirewallRuleParcel ruleParcel{rule};
115 ErrCode ret = plugin->OnSetPolicy(ruleParcel);
116 ASSERT_TRUE(ret == ERR_OK);
117 }
118
119 /**
120 * @tc.name: TestOnSetPolicyTestSuccess
121 * @tc.desc: Test FirewallRulePlugin::OnSetPolicy success.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(FirewallRulePluginTest, TestOnSetPolicyTestSuccess, TestSize.Level1)
125 {
126 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
127
128 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
129 IPTABLES::FirewallRule rule{IPTABLES::Direction::INPUT, IPTABLES::Action::DENY, IPTABLES::Protocol::UDP,
130 "192.168.2.100", "192.168.2.200", "80", "90", ""};
131 IPTABLES::FirewallRuleParcel ruleParcel{rule};
132 ErrCode ret = plugin->OnSetPolicy(ruleParcel);
133 ASSERT_TRUE(ret == ERR_OK);
134 }
135
136 /**
137 * @tc.name: TestOnSetPolicyTestFail
138 * @tc.desc: Test FirewallRulePlugin::OnSetPolicy fail.
139 * @tc.type: FUNC
140 */
141 HWTEST_F(FirewallRulePluginTest, TestOnSetPolicyTestFail, TestSize.Level1)
142 {
143 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(-1)));
144
145 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
146 IPTABLES::FirewallRule rule{IPTABLES::Direction::INPUT, IPTABLES::Action::DENY, IPTABLES::Protocol::UDP,
147 "192.168.2.100", "192.168.2.200", "80", "90", ""};
148 IPTABLES::FirewallRuleParcel ruleParcel{rule};
149 ErrCode ret = plugin->OnSetPolicy(ruleParcel);
150 ASSERT_TRUE(ret != ERR_OK);
151 }
152
153 /**
154 * @tc.name: TestOnRemovePolicyTestSuccess
155 * @tc.desc: Test FirewallRulePlugin::OnRemovePolicy success.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(FirewallRulePluginTest, TestOnRemovePolicyTestSuccess, TestSize.Level1)
159 {
160 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
161
162 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
163 IPTABLES::FirewallRule rule{IPTABLES::Direction::INPUT, IPTABLES::Action::DENY, IPTABLES::Protocol::UDP,
164 "192.168.2.100", "192.168.2.200", "80", "90", ""};
165 IPTABLES::FirewallRuleParcel ruleParcel{rule};
166 ErrCode ret = plugin->OnRemovePolicy(ruleParcel);
167 ASSERT_TRUE(ret == ERR_OK);
168 }
169
170 /**
171 * @tc.name: TestOnRemovePolicyTestFail
172 * @tc.desc: Test FirewallRulePlugin::OnRemovePolicy fail.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(FirewallRulePluginTest, TestOnRemovePolicyTestFail, TestSize.Level1)
176 {
177 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
178 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::UDP,
179 "192.168.2.100", "192.168.2.200", "80", "90", ""};
180 IPTABLES::FirewallRuleParcel ruleParcel{rule};
181 ErrCode ret = plugin->OnRemovePolicy(ruleParcel);
182 ASSERT_TRUE(ret != ERR_OK);
183 }
184
185 /**
186 * @tc.name: TestOnGetPolicyTestSuccess
187 * @tc.desc: Test FirewallRulePlugin::OnGetPolicy success.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(FirewallRulePluginTest, TestOnGetPolicyTestSuccess, TestSize.Level1)
191 {
192 EXPECT_CALL(*executerUtilsMock, Execute).WillRepeatedly(DoAll(Invoke(PrintExecRule), Return(ERR_OK)));
193
194 std::shared_ptr<FirewallRulePlugin> plugin = std::make_shared<FirewallRulePlugin>();
195 std::string policyData;
196 MessageParcel data;
197 MessageParcel reply;
198 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, 0);
199 ASSERT_TRUE(ret == ERR_OK);
200 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
201 ASSERT_TRUE(blRes);
202 }
203 } // namespace TEST
204 } // namespace EDM
205 } // namespace OHOS