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 <gtest/gtest.h>
17
18 #define protected public
19 #include "ipolicy_query.h"
20 #undef protected
21
22 #include "allowed_bluetooth_devices_query.h"
23 #include "allowed_usb_devices_query.h"
24 #include "cJSON.h"
25 #include "cjson_serializer.h"
26 #include "clipboard_info.h"
27 #include "clipboard_policy.h"
28 #include "clipboard_policy_query.h"
29 #include "clipboard_policy_serializer.h"
30 #include "disable_bluetooth_query.h"
31 #include "disable_camera_query.h"
32 #include "disable_hdc_query.h"
33 #include "disable_microphone_query.h"
34 #include "disable_printer_query.h"
35 #include "disable_mtp_client_query.h"
36 #include "disable_mtp_server_query.h"
37 #include "disable_usb_query.h"
38 #include "disallow_add_local_account_query.h"
39 #include "disallow_modify_datetime_query.h"
40 #include "disallowed_install_bundles_query.h"
41 #include "disallowed_running_bundles_query.h"
42 #include "disallowed_tethering_query.h"
43 #include "disallowed_uninstall_bundles_query.h"
44 #include "edm_constants.h"
45 #include "fingerprint_auth_query.h"
46 #include "get_device_encryption_status_query.h"
47 #include "get_display_version_query.h"
48 #include "get_security_patch_tag_query.h"
49 #include "inactive_user_freeze_query.h"
50 #include "location_policy_query.h"
51 #include "ntp_server_query.h"
52 #include "parameters.h"
53 #include "password_policy.h"
54 #include "password_policy_query.h"
55 #include "password_policy_serializer.h"
56 #include "set_browser_policies_query.h"
57 #include "set_wifi_disabled_query.h"
58 #include "snapshot_skip_query.h"
59 #include "usb_read_only_query.h"
60
61 using namespace testing::ext;
62 using namespace OHOS;
63 using namespace OHOS::EDM;
64
65 namespace OHOS {
66 namespace EDM {
67 namespace TEST {
68 class PluginPolicyQueryTest : public testing::Test {
69 protected:
70 void SetUp() override;
71
72 void TearDown() override;
73 };
74 const std::string POLICY_DATA = "[{\"tokenId\":1,\"userId\":100,\"bundleName\":\"com.ohos.test1\","
75 "\"clipboardPolicy\":1},{\"tokenId\":2,\"userId\":100,\"bundleName\":\"com.ohos.test2\",\"clipboardPolicy\":2}]";
76 const std::string TEST_VALUE_COMPLEXITYREG = "^(?=.*[a-zA-Z]).{1,9}$";
77 const int TEST_VALUE_VALIDITY_PERIOD = 2;
78 const std::string TEST_VALUE_ADDITIONAL_DESCRIPTION = "testDescription";
79 const std::string TEST_POLICY_DATA =
80 "{\"complexityReg\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2,"
81 "\"additionalDescription\": \"testDescription\"}";
82 const std::string PERSIST_BLUETOOTH_CONTROL = "persist.edm.prohibit_bluetooth";
SetUp()83 void PluginPolicyQueryTest::SetUp() {}
84
TearDown()85 void PluginPolicyQueryTest::TearDown() {}
86
87 /**
88 * @tc.name: TestAllowedBluetoothDevicesQuery
89 * @tc.desc: Test AllowedBluetoothDevicesQuery::QueryPolicy func.
90 * @tc.type: FUNC
91 */
92 HWTEST_F(PluginPolicyQueryTest, TestAllowedBluetoothDevicesQuery, TestSize.Level1)
93 {
94 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedBluetoothDevicesQuery>();
95 std::string policyValue{"GetBluetoothDevices"};
96 MessageParcel data;
97 MessageParcel reply;
98 ErrCode ret = queryObj->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
99 int32_t flag = ERR_INVALID_VALUE;
100 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
101 ASSERT_TRUE(ret == ERR_OK);
102 }
103
104 /**
105 * @tc.name: TestAllowedUsbDevicesQuery
106 * @tc.desc: Test EnterpriseAdminConnection::OnAbilityConnectDone func.
107 * @tc.type: FUNC
108 */
109 HWTEST_F(PluginPolicyQueryTest, TestAllowedUsbDevicesQuery, TestSize.Level1)
110 {
111 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<AllowedUsbDevicesQuery>();
112 std::string policyData{""};
113 MessageParcel data;
114 MessageParcel reply;
115 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
116 int32_t flag = ERR_INVALID_VALUE;
117 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
118 ASSERT_TRUE(ret == ERR_OK);
119 }
120
121 /**
122 * @tc.name: TestClipboardPolicyQuery
123 * @tc.desc: Test ClipboardPolicyQuery::QueryPolicy.
124 * @tc.type: FUNC
125 */
126 HWTEST_F(PluginPolicyQueryTest, TestClipboardPolicyQuery001, TestSize.Level1)
127 {
128 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<ClipboardPolicyQuery>();
129 MessageParcel data;
130 MessageParcel reply;
131 data.WriteInt32(5);
132 std::string policyData = POLICY_DATA;
133 queryObj->QueryPolicy(policyData, data, reply, 0);
134 int32_t ret = reply.ReadInt32();
135 std::string policy = reply.ReadString();
136 std::map<int32_t, ClipboardInfo> policyMap;
137 auto serializer = ClipboardSerializer::GetInstance();
138 serializer->Deserialize(policy, policyMap);
139 ASSERT_TRUE(ret == ERR_OK);
140 ASSERT_TRUE(policyMap.size() == 2);
141 }
142
143 /**
144 * @tc.name: TestClipboardPolicyQuery002
145 * @tc.desc: Test ClipboardPolicyPluginTest::QueryPolicy.
146 * @tc.type: FUNC
147 */
148 HWTEST_F(PluginPolicyQueryTest, TestClipboardPolicyQuery002, TestSize.Level1)
149 {
150 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<ClipboardPolicyQuery>();
151 MessageParcel data;
152 MessageParcel reply;
153 std::string policyData = POLICY_DATA;
154 data.WriteInt32(3);
155 data.WriteInt32(1);
156 queryObj->QueryPolicy(policyData, data, reply, 0);
157 int32_t ret = reply.ReadInt32();
158 std::string policy = reply.ReadString();
159 std::map<int32_t, ClipboardInfo> policyMap;
160 auto serializer = ClipboardSerializer::GetInstance();
161 serializer->Deserialize(policy, policyMap);
162 ASSERT_TRUE(ret == ERR_OK);
163 ASSERT_TRUE(policyMap[1].policy == ClipboardPolicy::IN_APP);
164 }
165
166 /**
167 * @tc.name: TestDisableBluetoothQuery001
168 * @tc.desc: Test DisableBluetoothQuery::QueryPolicy function.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery001, TestSize.Level1)
172 {
173 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBluetoothQuery>();
174 std::string policyData{"false"};
175 MessageParcel data;
176 MessageParcel reply;
177 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
178 ASSERT_TRUE(ret == ERR_OK);
179 int32_t flag = ERR_INVALID_VALUE;
180 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
181 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_BLUETOOTH_CONTROL, false),
182 reply.ReadBool());
183 }
184
185 /**
186 * @tc.name: TestDisableBluetoothQuery002
187 * @tc.desc: Test DisableBluetoothQuery::QueryPolicy function.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery002, TestSize.Level1)
191 {
192 std::shared_ptr<IPolicyQuery> queryObj = std::make_shared<DisableBluetoothQuery>();
193 std::string policyData{"false"};
194 MessageParcel data;
195 MessageParcel reply;
196 ErrCode ret = queryObj->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
197 int32_t flag = ERR_INVALID_VALUE;
198 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
199 bool result = false;
200 reply.ReadBool(result);
201 ASSERT_TRUE(ret == ERR_OK);
202 }
203
204 /**
205 * @tc.name: DisablePrinterQuery001
206 * @tc.desc: Test DisablePrinterPluginTest::QueryPolicy function.
207 * @tc.type: FUNC
208 */
209 HWTEST_F(PluginPolicyQueryTest, TestDisablePrinterQuery001, TestSize.Level1)
210 {
211 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisablePrinterQuery>();
212 std::string policyData{"false"};
213 MessageParcel data;
214 MessageParcel reply;
215 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
216 int32_t flag = ERR_INVALID_VALUE;
217 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
218 bool result = false;
219 reply.ReadBool(result);
220 ASSERT_TRUE(ret == ERR_OK);
221 ASSERT_FALSE(result);
222 }
223
224 /**
225 * @tc.name: DisableMtpClientQuery001
226 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpClientQuery001, TestSize.Level1)
230 {
231 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMtpClientQuery>();
232 std::string policyData{"false"};
233 MessageParcel data;
234 MessageParcel reply;
235 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
236 int32_t flag = ERR_INVALID_VALUE;
237 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
238 bool result = false;
239 reply.ReadBool(result);
240 ASSERT_TRUE(ret == ERR_OK);
241 ASSERT_FALSE(result);
242 }
243
244 /**
245 * @tc.name: DisableMtpServerQuery001
246 * @tc.desc: Test DisableMtpPluginTest::QueryPolicy function.
247 * @tc.type: FUNC
248 */
249 HWTEST_F(PluginPolicyQueryTest, TestDisableMtpServerQuery001, TestSize.Level1)
250 {
251 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableMtpServerQuery>();
252 std::string policyData{"false"};
253 MessageParcel data;
254 MessageParcel reply;
255 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
256 int32_t flag = ERR_INVALID_VALUE;
257 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
258 bool result = false;
259 reply.ReadBool(result);
260 ASSERT_TRUE(ret == ERR_OK);
261 ASSERT_FALSE(result);
262 }
263
264 /**
265 * @tc.name: TestDisableUsbQuery
266 * @tc.desc: Test DisableUsbQuery::QueryPolicy function.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(PluginPolicyQueryTest, TestDisableUsbQuery, TestSize.Level1)
270 {
271 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableUsbQuery>();
272 std::string policyData{"false"};
273 MessageParcel data;
274 MessageParcel reply;
275 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
276 int32_t flag = ERR_INVALID_VALUE;
277 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
278 bool result = false;
279 reply.ReadBool(result);
280 ASSERT_TRUE(ret == ERR_OK);
281 ASSERT_FALSE(result);
282 }
283
284 /**
285 * @tc.name: TestDisallowAddLocalAccountQuery
286 * @tc.desc: Test DisallowAddLocalAccountQuery::QueryPolicy function.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(PluginPolicyQueryTest, TestDisallowAddLocalAccountQuery, TestSize.Level1)
290 {
291 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisallowAddLocalAccountQuery>();
292 std::string policyData{"false"};
293 MessageParcel data;
294 MessageParcel reply;
295 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
296 int32_t flag = ERR_INVALID_VALUE;
297 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
298 bool result = false;
299 reply.ReadBool(result);
300 ASSERT_TRUE(ret == ERR_OK);
301 ASSERT_FALSE(result);
302 }
303
304 /**
305 * @tc.name: TestDisallowModifyDateTimeQuery
306 * @tc.desc: Test TestDisallowModifyDateTimeQuery::QueryPolicy function.
307 * @tc.type: FUNC
308 */
309 HWTEST_F(PluginPolicyQueryTest, TestDisallowModifyDateTimeQuery, TestSize.Level1)
310 {
311 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisallowModifyDateTimeQuery>();
312 // origin policy is disallow to modify date time.
313 std::string policyData{"true"};
314 MessageParcel data;
315 MessageParcel reply;
316 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
317 int32_t flag = ERR_INVALID_VALUE;
318 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
319 bool result = false;
320 reply.ReadBool(result);
321 ASSERT_TRUE(ret == ERR_OK);
322 // get policy is disallow to modify date time.
323 ASSERT_TRUE(result);
324 }
325
326 /**
327 * @tc.name: TestFingerprintAuthQuery001
328 * @tc.desc: Test FingerprintAuthQuery::QueryPolicy function.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(PluginPolicyQueryTest, TestFingerprintAuthQuery001, TestSize.Level1)
332 {
333 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<FingerprintAuthQuery>();
334 MessageParcel data;
335 data.WriteString(EdmConstants::FINGERPRINT_AUTH_TYPE);
336 MessageParcel reply;
337 std::string policyData = "true";
338 plugin->QueryPolicy(policyData, data, reply, 100);
339 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
340 ASSERT_TRUE(reply.ReadBool());
341 }
342
343 /**
344 * @tc.name: TestFingerprintAuthQuery002
345 * @tc.desc: Test FingerprintAuthQuery::QueryPolicy function.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(PluginPolicyQueryTest, TestFingerprintAuthQuery002, TestSize.Level1)
349 {
350 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<FingerprintAuthQuery>();
351 MessageParcel data;
352 data.WriteString(EdmConstants::DISALLOW_FOR_ACCOUNT_TYPE);
353 data.WriteInt32(100);
354 MessageParcel reply;
355 std::string policyData = "[100]";
356 plugin->QueryPolicy(policyData, data, reply, 100);
357 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
358 ASSERT_TRUE(reply.ReadBool());
359 }
360
361 /**
362 * @tc.name: TestGetDeviceEncryptionStatusQuery
363 * @tc.desc: Test get device encryption status function.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(PluginPolicyQueryTest, TestGetDeviceEncryptionStatusQuery, TestSize.Level1)
367 {
368 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<GetDeviceEncryptionStatusQuery>();
369 std::string policyValue{"GetDeviceEncryptionStatus"};
370 MessageParcel data;
371 MessageParcel reply;
372 plugin->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
373 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
374 ASSERT_TRUE(reply.ReadBool() == true);
375 }
376
377 /**
378 * @tc.name: TestGetSecurityPatchTagSuc
379 * @tc.desc: Test get security patch tag function.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(PluginPolicyQueryTest, TestGetSecurityPatchTagSuc, TestSize.Level1)
383 {
384 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<GetSecurityPatchTagQuery>();
385 std::string policyValue{"GetSecurityPatchTag"};
386 MessageParcel data;
387 MessageParcel reply;
388 plugin->QueryPolicy(policyValue, data, reply, DEFAULT_USER_ID);
389 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
390 ASSERT_TRUE(reply.ReadString() != "");
391 }
392
393 /**
394 * @tc.name: TestUsbReadOnlyQuery001
395 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is read only.
396 * @tc.type: FUNC
397 */
398 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery001, TestSize.Level1)
399 {
400 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
401 MessageParcel data;
402 MessageParcel reply;
403 std::string policyData{"1"};
404 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
405 ASSERT_TRUE(ret == ERR_OK);
406 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
407 ASSERT_TRUE(reply.ReadInt32() == 1);
408 }
409
410 /**
411 * @tc.name: TestUsbReadOnlyQuery002
412 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is disabled.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery002, TestSize.Level1)
416 {
417 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
418 MessageParcel data;
419 MessageParcel reply;
420 std::string policyData{"2"};
421 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
422 ASSERT_TRUE(ret == ERR_OK);
423 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
424 ASSERT_TRUE(reply.ReadInt32() == 2);
425 }
426
427 /**
428 * @tc.name: TestUsbReadOnlyQuery003
429 * @tc.desc: Test UsbReadOnlyQuery::QueryPolicy function when policy is empty.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(PluginPolicyQueryTest, TestUsbReadOnlyQuery003, TestSize.Level1)
433 {
434 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<UsbReadOnlyQuery>();
435 MessageParcel data;
436 MessageParcel reply;
437 std::string policyData{""};
438 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
439 ASSERT_TRUE(ret == ERR_OK);
440 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
441 ASSERT_TRUE(reply.ReadInt32() == 0);
442 }
443
444 /**
445 * @tc.name: TestSetWifiDisabledQuery
446 * @tc.desc: Test SetWifiDisabledQuery::QueryPolicy function.
447 * @tc.type: FUNC
448 */
449 HWTEST_F(PluginPolicyQueryTest, TestSetWifiDisabledQuery, TestSize.Level1)
450 {
451 const std::string KEY_DISABLE_WIFI = "persist.edm.wifi_enable";
452 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<SetWifiDisabledQuery>();
453 std::string policyData{"false"};
454 MessageParcel data;
455 MessageParcel reply;
456 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
457 int32_t flag = ERR_INVALID_VALUE;
458 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
459 bool result = false;
460 reply.ReadBool(result);
461 ASSERT_TRUE(ret == ERR_OK);
462 ASSERT_TRUE(result == system::GetBoolParameter(KEY_DISABLE_WIFI, false));
463 }
464
465 /**
466 * @tc.name: TestDisableBluetoothQuery
467 * @tc.desc: Test DisableBluetoothPluginTest::QueryPolicy function.
468 * @tc.type: FUNC
469 */
470 HWTEST_F(PluginPolicyQueryTest, TestDisableBluetoothQuery, TestSize.Level1)
471 {
472 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<DisableBluetoothQuery>();
473 std::string policyData{"false"};
474 MessageParcel data;
475 MessageParcel reply;
476 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
477 ASSERT_TRUE(ret == ERR_OK);
478 int32_t flag = ERR_INVALID_VALUE;
479 ASSERT_TRUE(reply.ReadInt32(flag) && (flag == ERR_OK));
480 ASSERT_EQ(OHOS::system::GetBoolParameter(PERSIST_BLUETOOTH_CONTROL, false),
481 reply.ReadBool());
482 }
483
484 /**
485 * @tc.name: TestPasswordPolicyQuery
486 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy when policyData is empty
487 * and policies is empty.
488 * @tc.type: FUNC
489 */
490 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery, TestSize.Level1)
491 {
492 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
493 MessageParcel data;
494 MessageParcel reply;
495 std::string policyData;
496 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
497 ASSERT_TRUE(ret == ERR_OK);
498 ASSERT_TRUE(policyData.empty());
499 }
500
501 /**
502 * @tc.name: TestPasswordPolicyQuery002
503 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy when policyData is err
504 * and policies is err.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery002, TestSize.Level1)
508 {
509 const std::string TEST_POLICY_ERR_DATA =
510 "{\"comple\":\"^(?=.*[a-zA-Z]).{1,9}$\", \"validityPeriod\": 2,"
511 "\"additionalDescription\": \"testDescription\"}";
512 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
513 MessageParcel data;
514 MessageParcel reply;
515 std::string policyData = TEST_POLICY_ERR_DATA;
516 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
517 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
518 }
519
520 /**
521 * @tc.name: TestPasswordPolicyQuery003
522 * @tc.desc: Test PasswordPolicyQuery::QueryPolicy
523 * and policies is empty.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(PluginPolicyQueryTest, TestPasswordPolicyQuery003, TestSize.Level1)
527 {
528 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<PasswordPolicyQuery>();
529 MessageParcel data;
530 MessageParcel reply;
531 std::string policyData = TEST_POLICY_DATA;
532 ErrCode ret = plugin->QueryPolicy(policyData, data, reply, 0);
533 ASSERT_TRUE(ret == ERR_OK);
534 auto serializer_ = PasswordSerializer::GetInstance();
535 PasswordPolicy policy;
536 serializer_->Deserialize(policyData, policy);
537 ASSERT_TRUE(policy.additionalDescription == TEST_VALUE_ADDITIONAL_DESCRIPTION);
538 ASSERT_TRUE(policy.validityPeriod == TEST_VALUE_VALIDITY_PERIOD);
539 ASSERT_TRUE(policy.complexityReg == TEST_VALUE_COMPLEXITYREG);
540 }
541
542 /**
543 * @tc.name: TestSetBrowserPoliciesQuery
544 * @tc.desc: Test SetBrowserPoliciesQuery::QueryPolicy.
545 * @tc.type: FUNC
546 */
547 HWTEST_F(PluginPolicyQueryTest, TestSetBrowserPoliciesQuery, TestSize.Level1)
548 {
549 const std::string TestAppId = "test_app_id";
550 const std::string TestPolicyData = "{\"test_app_id\": {\"test_policy_name\":\"test_policy_value\"}}";
551 std::shared_ptr<IPolicyQuery> plugin = std::make_shared<SetBrowserPoliciesQuery>();
552 MessageParcel data;
553 MessageParcel reply;
554 data.WriteString(TestAppId);
555 std::string policyData = TestPolicyData;
556 plugin->QueryPolicy(policyData, data, reply, DEFAULT_USER_ID);
557 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
558 auto serializer = CjsonSerializer::GetInstance();
559 cJSON* root = nullptr;
560 serializer->Deserialize(TestPolicyData, root);
561 cJSON* policy = cJSON_GetObjectItem(root, TestAppId.c_str());
562 std::string retString;
563 serializer->Serialize(policy, retString);
564 ASSERT_TRUE(reply.ReadString() == retString);
565 }
566
567 } // namespace TEST
568 } // namespace EDM
569 } // namespace OHOS
570