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) == "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 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveSupplierPlg::GetPlugin());
258 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveBiFunctionPlg::GetPlugin());
259
260 for (int policyCode : policyCodes) {
261 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
262 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
263
264 adminName = "com.edm.test.demo";
265 policyValue = "testValue";
266 g_visit = false;
267 plugin->OnAdminRemove(adminName, policyValue, DEFAULT_USER_ID);
268 ASSERT_TRUE(g_visit);
269 }
270 }
271
272 /**
273 * @tc.name: TestAdminRemove
274 * @tc.desc: Test PluginTemplate AdminRemoveDone func.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(PluginTemplateTest, TestAdminRemoveDone, TestSize.Level1)
278 {
279 std::vector<int> policyCodes = {28, 29};
280 MessageParcel data;
281 uint32_t funcCode;
282 std::shared_ptr<IPlugin> plugin;
283 std::string adminName;
284 std::string policyValue;
285 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveDoneRunnerPlg::GetPlugin());
286 PluginManager::GetInstance()->AddPlugin(PLUGIN::AdminRemoveDoneBiBiConsumerPlg::GetPlugin());
287
288 for (int policyCode : policyCodes) {
289 funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
290 plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
291
292 adminName = "com.edm.test.demo";
293 policyValue = "testValue";
294 g_visit = false;
295 plugin->OnAdminRemoveDone(adminName, policyValue, DEFAULT_USER_ID);
296 ASSERT_TRUE(g_visit);
297 }
298 }
299
300 /**
301 * @tc.name: TestOnGetPolicy
302 * @tc.desc: Test PluginTemplate OnGetPolicy func.
303 * @tc.type: FUNC
304 */
305 HWTEST_F(PluginTemplateTest, TestOnGetPolicy, TestSize.Level1)
306 {
307 int policyCode = 30;
308 MessageParcel reply;
309 MessageParcel data;
310 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin());
311 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, policyCode);
312 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
313 std::string policyData{"TestData"};
314 ErrCode ret = plugin->OnGetPolicy(policyData, data, reply, DEFAULT_USER_ID);
315 ASSERT_TRUE(ret == ERR_OK);
316 }
317
318 /**
319 * @tc.name: TestWritePolicyToParcel
320 * @tc.desc: Test PluginTemplate WritePolicyToParcel func.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(PluginTemplateTest, TestWritePolicyToParcel, TestSize.Level1)
324 {
325 int policyCode = 22;
326 MessageParcel reply;
327 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyFunctionPlg::GetPlugin());
328 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, policyCode);
329 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
330 std::string policyData = "testValue";
331 ErrCode ret = plugin->WritePolicyToParcel(policyData, reply);
332 ASSERT_TRUE(ret == ERR_OK);
333 std::string temp;
334 reply.ReadString(temp);
335 ASSERT_TRUE(temp == policyData);
336 }
337
338 /**
339 * @tc.name: TestHandlePolicyReplyFunctionPlg
340 * @tc.desc: Test PluginTemplate TestHandlePolicyReplyFunctionPlg func.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(PluginTemplateTest, TestHandlePolicyReplyFunctionPlg, TestSize.Level1)
344 {
345 int policyCode = 32;
346 PluginManager::GetInstance()->AddPlugin(PLUGIN::HandlePolicyReplyFunctionPlg::GetPlugin());
347 uint32_t funcCode = POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, policyCode);
348 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(funcCode);
349 ASSERT_TRUE(plugin != nullptr);
350 std::string setPolicyValue = "testValue";
351 HandlePolicyData handlePolicyData{"", false};
352 MessageParcel data;
353 data.WriteString(setPolicyValue);
354 MessageParcel reply;
355 ErrCode res = plugin->OnHandlePolicy(funcCode, data, reply, handlePolicyData, DEFAULT_USER_ID);
356 ASSERT_TRUE(res == ERR_OK);
357 ASSERT_TRUE(handlePolicyData.policyData == "testValue");
358 ASSERT_TRUE(handlePolicyData.isChanged);
359 }
360
361 /**
362 * @tc.name: TestDestroyPlugin
363 * @tc.desc: Test PluginTemplate DestroyPlugin func.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(PluginTemplateTest, TestDestroyPlugin, TestSize.Level1)
367 {
368 MessageParcel reply;
369 PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin();
370 ASSERT_TRUE(PLUGIN::HandlePolicyJsonBiFunctionPlg::pluginInstance_ != nullptr);
371 PLUGIN::HandlePolicyJsonBiFunctionPlg::DestroyPlugin();
372 ASSERT_TRUE(PLUGIN::HandlePolicyJsonBiFunctionPlg::pluginInstance_ == nullptr);
373 }
374
SetUp()375 void PluginTemplateTest::SetUp()
376 {
377 if (policyManager_ == nullptr) {
378 policyManager_ = std::make_shared<PolicyManager>();
379 }
380 IPolicyManager::policyManagerInstance_ = policyManager_.get();
381 }
382
TearDown()383 void PluginTemplateTest::TearDown()
384 {
385 PluginManager::GetInstance().reset();
386 }
387 } // namespace TEST
388 } // namespace EDM
389 } // namespace OHOS