1 /*
2 * Copyright (c) 2022-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 protected public
17 #include "iplugin_template_test.h"
18 #undef protected
19
20 #include "policy_manager.h"
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace EDM {
25 namespace TEST {
26 /**
27 * @tc.name: TestTemplate
28 * @tc.desc: Test PluginTemplate init.
29 * @tc.type: FUNC
30 */
31 HWTEST_F(PluginTemplateTest, TestTemplate, TestSize.Level1)
32 {
33 PluginManager::GetInstance()->AddPlugin(PLUGIN::ArrayTestPlugin::GetPlugin());
34 PluginManager::GetInstance()->AddPlugin(PLUGIN::BoolTestPlugin::GetPlugin());
35 PluginManager::GetInstance()->AddPlugin(PLUGIN::MapTestPlugin::GetPlugin());
36 PluginManager::GetInstance()->AddPlugin(PLUGIN::ArrayMapTestPlugin::GetPlugin());
37 PluginManager::GetInstance()->AddPlugin(PLUGIN::JsonTestPlugin::GetPlugin());
38 PluginManager::GetInstance()->AddPlugin(PLUGIN::StringTestPlugin::GetPlugin());
39
40 std::vector<std::uint32_t> policyCodes = {10, 11, 12, 13, 14, 15};
41 for (auto policyCode : policyCodes) {
42 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
43 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
44 ASSERT_TRUE(plugin != nullptr);
45 ASSERT_TRUE(plugin->GetCode() == policyCode);
46 }
47 }
48
49 /**
50 * @tc.name: TestInitAttribute
51 * @tc.desc: Test PluginTemplate InitAttribute func.
52 * @tc.type: FUNC
53 */
54 HWTEST_F(PluginTemplateTest, TestInitAttribute, TestSize.Level1)
55 {
56 int policyCode = 20;
57 PluginManager::GetInstance()->AddPlugin(PLUGIN::InitAttributePlg::GetPlugin());
58 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
59 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
60 ASSERT_TRUE(plugin != nullptr);
61 ASSERT_TRUE(plugin->GetPermission(FuncOperateType::GET, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN)
62 == "ohos.permission.EDM_TEST_PERMISSION");
63 ASSERT_TRUE(plugin->GetPolicyName() == "InitAttributePlg");
64 ASSERT_TRUE(plugin->GetCode() == 20);
65 }
66
67 /**
68 * @tc.name: TestHandlePolicySupplier
69 * @tc.desc: Test PluginTemplate HandlePolicySupplier func.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(PluginTemplateTest, TestHandlePolicySupplier, TestSize.Level1)
73 {
74 int policyCode = 21;
75 ErrCode res;
76 MessageParcel data;
77 MessageParcel reply;
78 uint32_t funcCode;
79 std::shared_ptr<IPlugin> plugin;
80 std::string setPolicyValue;
81 HandlePolicyData handlePolicyData{"", false};
82 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicySupplierPlg::GetPlugin());
83 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
84 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
85 ASSERT_TRUE(plugin != nullptr);
86
87 setPolicyValue = R"({"k1":"v1","k2":"v2","k3":3})";
88 data.WriteString(setPolicyValue);
89 g_visit = false;
90 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
91 ASSERT_TRUE(res != ERR_OK);
92 ASSERT_TRUE(handlePolicyData.policyData.empty());
93 ASSERT_TRUE(g_visit);
94
95 setPolicyValue = R"({"k1":"v1","k2":"v2","k3":3})";
96 handlePolicyData.policyData = "";
97 handlePolicyData.isChanged = false;
98 data.WriteString(setPolicyValue);
99 g_visit = false;
100 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
101 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
102 ASSERT_TRUE(res != ERR_OK);
103 ASSERT_TRUE(handlePolicyData.policyData.empty());
104 ASSERT_TRUE(g_visit);
105 }
106
107 /**
108 * @tc.name: TestHandlePolicyFunction
109 * @tc.desc: Test PluginTemplate HandlePolicyFunction func.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(PluginTemplateTest, TestHandlePolicyFunction, TestSize.Level1)
113 {
114 int policyCode = 22;
115 ErrCode res;
116 MessageParcel data;
117 MessageParcel reply;
118 uint32_t funcCode;
119 std::shared_ptr<IPlugin> plugin;
120 std::string setPolicyValue;
121 HandlePolicyData handlePolicyData{"", false};
122 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyFunctionPlg::GetPlugin());
123
124 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
125 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
126 ASSERT_TRUE(plugin != nullptr);
127 setPolicyValue = "testValue";
128 data.WriteString(setPolicyValue);
129 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
130 ASSERT_TRUE(res == ERR_OK);
131 ASSERT_TRUE(handlePolicyData.policyData == "newTestValue");
132 ASSERT_TRUE(handlePolicyData.isChanged);
133
134 setPolicyValue = "";
135 handlePolicyData.policyData = "";
136 handlePolicyData.isChanged = false;
137 data.WriteString(setPolicyValue);
138 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
139 ASSERT_TRUE(res == ERR_OK);
140 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
141 ASSERT_TRUE(handlePolicyData.isChanged);
142
143 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
144 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
145 ASSERT_TRUE(plugin != nullptr);
146 setPolicyValue = "";
147 handlePolicyData.policyData = "testValue";
148 handlePolicyData.isChanged = false;
149 data.WriteString(setPolicyValue);
150 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
151 ASSERT_TRUE(res == ERR_OK);
152 ASSERT_TRUE(handlePolicyData.policyData.empty());
153 ASSERT_TRUE(handlePolicyData.isChanged);
154 }
155
156 /**
157 * @tc.name: TestHandlePolicyBiFunction
158 * @tc.desc: Test PluginTemplate HandlePolicyBiFunction func.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(PluginTemplateTest, TestHandlePolicyBiFunction, TestSize.Level1)
162 {
163 int policyCode = 23;
164 ErrCode res;
165 MessageParcel data;
166 MessageParcel reply;
167 uint32_t funcCode;
168 std::shared_ptr<IPlugin> plugin;
169 std::string setPolicyValue;
170 HandlePolicyData handlePolicyData{"", false};
171 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin());
172
173 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
174 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
175 ASSERT_TRUE(plugin != nullptr);
176 setPolicyValue = "testValue";
177 data.WriteString(setPolicyValue);
178 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
179 ASSERT_TRUE(res == ERR_OK);
180 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
181 ASSERT_TRUE(handlePolicyData.isChanged);
182
183 setPolicyValue = "testValue";
184 handlePolicyData.policyData = "testValue";
185 handlePolicyData.isChanged = false;
186 data.WriteString(setPolicyValue);
187 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
188 ASSERT_TRUE(res == ERR_OK);
189 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
190 ASSERT_TRUE(!handlePolicyData.isChanged);
191
192 setPolicyValue = "";
193 handlePolicyData.policyData = "testValue";
194 handlePolicyData.isChanged = false;
195 data.WriteString(setPolicyValue);
196 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
197 ASSERT_TRUE(res == ERR_OK);
198 ASSERT_TRUE(handlePolicyData.policyData.empty());
199 ASSERT_TRUE(handlePolicyData.isChanged);
200
201 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
202 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
203 ASSERT_TRUE(plugin != nullptr);
204 setPolicyValue = "";
205 handlePolicyData.policyData = "testValue";
206 handlePolicyData.isChanged = false;
207 data.WriteString(setPolicyValue);
208 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
209 ASSERT_TRUE(res == ERR_OK);
210 ASSERT_TRUE(handlePolicyData.policyData.empty());
211 ASSERT_TRUE(handlePolicyData.isChanged);
212 }
213
214 /**
215 * @tc.name: TestHandlePolicyDone
216 * @tc.desc: Test PluginTemplate HandlePolicyDone func.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(PluginTemplateTest, TestHandlePolicyDone, TestSize.Level1)
220 {
221 std::vector<int> policyCodes = {24, 25};
222 MessageParcel data;
223 uint32_t funcCode;
224 std::shared_ptr<IPlugin> plugin;
225 std::string adminName;
226 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandleDoneBoolConsumerPlg::GetPlugin());
227 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandleDoneBiBoolConsumerPlg::GetPlugin());
228
229 for (int policyCode : policyCodes) {
230 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
231 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
232 ASSERT_TRUE(plugin != nullptr);
233 adminName = "com.edm.test.demo";
234 g_visit = false;
235 plugin->OnHandlePolicyDone(funcCode, adminName, true, DEFAULT_USER_ID);
236 ASSERT_TRUE(g_visit);
237
238 g_visit = false;
239 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
240 plugin->OnHandlePolicyDone(funcCode, adminName, false, DEFAULT_USER_ID);
241 ASSERT_TRUE(g_visit);
242 }
243 }
244
245 /**
246 * @tc.name: TestAdminRemove
247 * @tc.desc: Test PluginTemplate AdminRemove func.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(PluginTemplateTest, TestAdminRemove, TestSize.Level1)
251 {
252 std::vector<int> policyCodes = {26, 27};
253 MessageParcel data;
254 uint32_t funcCode;
255 std::shared_ptr<IPlugin> plugin;
256 std::string adminName;
257 std::string policyValue;
258 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveSupplierPlg::GetPlugin());
259 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveBiFunctionPlg::GetPlugin());
260
261 for (int policyCode : policyCodes) {
262 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
263 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
264
265 adminName = "com.edm.test.demo";
266 policyValue = "testValue";
267 g_visit = false;
268 plugin->OnAdminRemove(adminName, policyValue, DEFAULT_USER_ID);
269 ASSERT_TRUE(g_visit);
270 }
271 }
272
273 /**
274 * @tc.name: TestAdminRemove
275 * @tc.desc: Test PluginTemplate AdminRemoveDone func.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(PluginTemplateTest, TestAdminRemoveDone, TestSize.Level1)
279 {
280 std::vector<int> policyCodes = {28, 29};
281 MessageParcel data;
282 uint32_t funcCode;
283 std::shared_ptr<IPlugin> plugin;
284 std::string adminName;
285 std::string policyValue;
286 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveDoneRunnerPlg::GetPlugin());
287 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveDoneBiBiConsumerPlg::GetPlugin());
288
289 for (int policyCode : policyCodes) {
290 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
291 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
292
293 adminName = "com.edm.test.demo";
294 policyValue = "testValue";
295 g_visit = false;
296 plugin->OnAdminRemoveDone(adminName, policyValue, DEFAULT_USER_ID);
297 ASSERT_TRUE(g_visit);
298 }
299 }
300
301 /**
302 * @tc.name: TestOnGetPolicy
303 * @tc.desc: Test PluginTemplate OnGetPolicy func.
304 * @tc.type: FUNC
305 */
306 HWTEST_F(PluginTemplateTest, TestOnGetPolicy, TestSize.Level1)
307 {
308 int policyCode = 30;
309 MessageParcel reply;
310 MessageParcel data;
311 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin());
312 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, policyCode);
313 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
314 std::string policyData{"TestData"};
315 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
316 ASSERT_TRUE(ret == ERR_OK);
317 }
318
319 /**
320 * @tc.name: TestWritePolicyToParcel
321 * @tc.desc: Test PluginTemplate WritePolicyToParcel func.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(PluginTemplateTest, TestWritePolicyToParcel, TestSize.Level1)
325 {
326 int policyCode = 22;
327 MessageParcel reply;
328 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyFunctionPlg::GetPlugin());
329 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, policyCode);
330 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
331 std::string policyData = "testValue";
332 ErrCode ret = plugin->WritePolicyToParcel(policyData, reply);
333 ASSERT_TRUE(ret == ERR_OK);
334 std::string temp;
335 reply.ReadString(temp);
336 ASSERT_TRUE(temp == policyData);
337 }
338
339 /**
340 * @tc.name: TestHandlePolicyReplyFunctionPlg
341 * @tc.desc: Test PluginTemplate TestHandlePolicyReplyFunctionPlg func.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(PluginTemplateTest, TestHandlePolicyReplyFunctionPlg, TestSize.Level1)
345 {
346 int policyCode = 32;
347 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyReplyFunctionPlg::GetPlugin());
348 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
349 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
350 ASSERT_TRUE(plugin != nullptr);
351 std::string setPolicyValue = "testValue";
352 HandlePolicyData handlePolicyData{"", false};
353 MessageParcel data;
354 data.WriteString(setPolicyValue);
355 MessageParcel reply;
356 ErrCode res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
357 ASSERT_TRUE(res == ERR_OK);
358 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
359 ASSERT_TRUE(handlePolicyData.isChanged);
360 }
361
362 /**
363 * @tc.name: TestDestroyPlugin
364 * @tc.desc: Test PluginTemplate DestroyPlugin func.
365 * @tc.type: FUNC
366 */
367 HWTEST_F(PluginTemplateTest, TestDestroyPlugin, TestSize.Level1)
368 {
369 MessageParcel reply;
370 PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin();
371 ASSERT_TRUE(PLUGIN::HandlePolicyJsonBiFunctionPlg::pluginInstance_ != nullptr);
372 PLUGIN::HandlePolicyJsonBiFunctionPlg::DestroyPlugin();
373 ASSERT_TRUE(PLUGIN::HandlePolicyJsonBiFunctionPlg::pluginInstance_ == nullptr);
374 }
375
SetUp()376 void PluginTemplateTest::SetUp()
377 {
378 if (policyManager_ == nullptr) {
379 policyManager_ = std::make_shared<PolicyManager>();
380 }
381 IPolicyManager::policyManagerInstance_ = policyManager_.get();
382 }
383
TearDown()384 void PluginTemplateTest::TearDown()
385 {
386 PluginManager::GetInstance().reset();
387 }
388 } // namespace TEST
389 } // namespace EDM
390 } // namespace OHOS