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::JsonTestPlugin::GetPlugin());
37 PluginManager::GetInstance()->AddPlugin(PLUGIN::StringTestPlugin::GetPlugin());
38
39 std::vector<std::uint32_t> policyCodes = {10, 11, 12, 14, 15};
40 for (auto policyCode : policyCodes) {
41 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
42 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
43 ASSERT_TRUE(plugin != nullptr);
44 ASSERT_TRUE(plugin->GetCode() == policyCode);
45 }
46 }
47
48 /**
49 * @tc.name: TestInitAttribute
50 * @tc.desc: Test PluginTemplate InitAttribute func.
51 * @tc.type: FUNC
52 */
53 HWTEST_F(PluginTemplateTest, TestInitAttribute, TestSize.Level1)
54 {
55 int policyCode = 20;
56 PluginManager::GetInstance()->AddPlugin(PLUGIN::InitAttributePlg::GetPlugin());
57 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
58 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
59 ASSERT_TRUE(plugin != nullptr);
60 ASSERT_TRUE(plugin->GetPermission(FuncOperateType::GET, IPlugin::PermissionType::NORMAL_DEVICE_ADMIN)
61 == "ohos.permission.EDM_TEST_PERMISSION");
62 ASSERT_TRUE(plugin->GetPolicyName() == "InitAttributePlg");
63 ASSERT_TRUE(plugin->GetCode() == 20);
64 }
65
66 /**
67 * @tc.name: TestHandlePolicySupplier
68 * @tc.desc: Test PluginTemplate HandlePolicySupplier func.
69 * @tc.type: FUNC
70 */
71 HWTEST_F(PluginTemplateTest, TestHandlePolicySupplier, TestSize.Level1)
72 {
73 int policyCode = 21;
74 ErrCode res;
75 MessageParcel data;
76 MessageParcel reply;
77 uint32_t funcCode;
78 std::shared_ptr<IPlugin> plugin;
79 std::string setPolicyValue;
80 HandlePolicyData handlePolicyData{"", "", false};
81 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicySupplierPlg::GetPlugin());
82 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
83 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
84 ASSERT_TRUE(plugin != nullptr);
85
86 setPolicyValue = R"({"k1":"v1","k2":"v2","k3":3})";
87 data.WriteString(setPolicyValue);
88 g_visit = false;
89 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
90 ASSERT_TRUE(res != ERR_OK);
91 ASSERT_TRUE(handlePolicyData.policyData.empty());
92 ASSERT_TRUE(g_visit);
93
94 setPolicyValue = R"({"k1":"v1","k2":"v2","k3":3})";
95 handlePolicyData.policyData = "";
96 handlePolicyData.isChanged = false;
97 data.WriteString(setPolicyValue);
98 g_visit = false;
99 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
100 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
101 ASSERT_TRUE(res != ERR_OK);
102 ASSERT_TRUE(handlePolicyData.policyData.empty());
103 ASSERT_TRUE(g_visit);
104 }
105
106 /**
107 * @tc.name: TestHandlePolicyFunction
108 * @tc.desc: Test PluginTemplate HandlePolicyFunction func.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(PluginTemplateTest, TestHandlePolicyFunction, TestSize.Level1)
112 {
113 int policyCode = 22;
114 ErrCode res;
115 MessageParcel data;
116 MessageParcel reply;
117 uint32_t funcCode;
118 std::shared_ptr<IPlugin> plugin;
119 std::string setPolicyValue;
120 HandlePolicyData handlePolicyData{"", "", false};
121 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyFunctionPlg::GetPlugin());
122
123 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
124 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
125 ASSERT_TRUE(plugin != nullptr);
126 setPolicyValue = "testValue";
127 data.WriteString(setPolicyValue);
128 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
129 ASSERT_TRUE(res == ERR_OK);
130 ASSERT_TRUE(handlePolicyData.policyData == "newTestValue");
131 ASSERT_TRUE(handlePolicyData.isChanged);
132
133 setPolicyValue = "";
134 handlePolicyData.policyData = "";
135 handlePolicyData.isChanged = false;
136 data.WriteString(setPolicyValue);
137 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
138 ASSERT_TRUE(res == ERR_OK);
139 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
140 ASSERT_TRUE(handlePolicyData.isChanged);
141
142 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
143 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
144 ASSERT_TRUE(plugin != nullptr);
145 setPolicyValue = "";
146 handlePolicyData.policyData = "testValue";
147 handlePolicyData.isChanged = false;
148 data.WriteString(setPolicyValue);
149 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
150 ASSERT_TRUE(res == ERR_OK);
151 ASSERT_TRUE(handlePolicyData.policyData.empty());
152 ASSERT_TRUE(handlePolicyData.isChanged);
153 }
154
155 /**
156 * @tc.name: TestHandlePolicyBiFunction
157 * @tc.desc: Test PluginTemplate HandlePolicyBiFunction func.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(PluginTemplateTest, TestHandlePolicyBiFunction, TestSize.Level1)
161 {
162 int policyCode = 23;
163 ErrCode res;
164 MessageParcel data;
165 MessageParcel reply;
166 uint32_t funcCode;
167 std::shared_ptr<IPlugin> plugin;
168 std::string setPolicyValue;
169 HandlePolicyData handlePolicyData{"", "", false};
170 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin());
171
172 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
173 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
174 ASSERT_TRUE(plugin != nullptr);
175 setPolicyValue = "testValue";
176 data.WriteString(setPolicyValue);
177 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
178 ASSERT_TRUE(res == ERR_OK);
179 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
180 ASSERT_TRUE(handlePolicyData.isChanged);
181
182 setPolicyValue = "testValue";
183 handlePolicyData.policyData = "testValue";
184 handlePolicyData.isChanged = false;
185 data.WriteString(setPolicyValue);
186 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
187 ASSERT_TRUE(res == ERR_OK);
188 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
189 ASSERT_TRUE(!handlePolicyData.isChanged);
190
191 setPolicyValue = "";
192 handlePolicyData.policyData = "testValue";
193 handlePolicyData.isChanged = false;
194 data.WriteString(setPolicyValue);
195 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
196 ASSERT_TRUE(res == ERR_OK);
197 ASSERT_TRUE(handlePolicyData.policyData.empty());
198 ASSERT_TRUE(handlePolicyData.isChanged);
199
200 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
201 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
202 ASSERT_TRUE(plugin != nullptr);
203 setPolicyValue = "";
204 handlePolicyData.policyData = "testValue";
205 handlePolicyData.isChanged = false;
206 data.WriteString(setPolicyValue);
207 res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
208 ASSERT_TRUE(res == ERR_OK);
209 ASSERT_TRUE(handlePolicyData.policyData.empty());
210 ASSERT_TRUE(handlePolicyData.isChanged);
211 }
212
213 /**
214 * @tc.name: TestHandlePolicyDone
215 * @tc.desc: Test PluginTemplate HandlePolicyDone func.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(PluginTemplateTest, TestHandlePolicyDone, TestSize.Level1)
219 {
220 std::vector<int> policyCodes = {24, 25};
221 MessageParcel data;
222 uint32_t funcCode;
223 std::shared_ptr<IPlugin> plugin;
224 std::string adminName;
225 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandleDoneBoolConsumerPlg::GetPlugin());
226 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandleDoneBiBoolConsumerPlg::GetPlugin());
227
228 for (int policyCode : policyCodes) {
229 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
230 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
231 ASSERT_TRUE(plugin != nullptr);
232 adminName = "com.edm.test.demo";
233 g_visit = false;
234 plugin->OnHandlePolicyDone(funcCode, adminName, true, DEFAULT_USER_ID);
235 ASSERT_TRUE(g_visit);
236
237 g_visit = false;
238 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::REMOVE, policyCode);
239 plugin->OnHandlePolicyDone(funcCode, adminName, false, DEFAULT_USER_ID);
240 ASSERT_TRUE(g_visit);
241 }
242 }
243
244 /**
245 * @tc.name: TestAdminRemove
246 * @tc.desc: Test PluginTemplate AdminRemove func.
247 * @tc.type: FUNC
248 */
249 HWTEST_F(PluginTemplateTest, TestAdminRemove, TestSize.Level1)
250 {
251 std::vector<int> policyCodes = {26, 27};
252 MessageParcel data;
253 uint32_t funcCode;
254 std::shared_ptr<IPlugin> plugin;
255 std::string adminName;
256 std::string policyValue;
257 std::string mergeValue;
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, mergeValue, 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
376 /**
377 * @tc.name: TestOtherServiceStart
378 * @tc.desc: Test PluginTemplate OtherServiceStart func.
379 * @tc.type: FUNC
380 */
381 HWTEST_F(PluginTemplateTest, TestOtherServiceStart, TestSize.Level1)
382 {
383 int policyCode = 33;
384 uint32_t funcCode;
385 std::shared_ptr<IPlugin> plugin;
386 PluginManager::GetInstance()->AddPlugin(PLUGIN::OtherServiceStartRunnerPlg::GetPlugin());
387
388 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
389 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
390
391 g_visit = false;
392 plugin->OnOtherServiceStart(100);
393 ASSERT_TRUE(g_visit);
394 }
395
SetUp()396 void PluginTemplateTest::SetUp()
397 {
398 if (policyManager_ == nullptr) {
399 policyManager_ = std::make_shared<PolicyManager>();
400 }
401 IPolicyManager::policyManagerInstance_ = policyManager_.get();
402 }
403
TearDown()404 void PluginTemplateTest::TearDown()
405 {
406 PluginManager::GetInstance().reset();
407 }
408 } // namespace TEST
409 } // namespace EDM
410 } // namespace OHOS