1 /*
2 * Copyright (c) 2022 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 "admin_manager_test.h"
18 #undef private
19 #include <vector>
20 #include "admin_manager.h"
21 #include "cmd_utils.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace EDM {
27 namespace TEST {
28 constexpr int32_t DEFAULT_USER_ID = 100;
29 constexpr int32_t TEST_USER_ID = 101;
30 constexpr int HUGE_ADMIN_SIZE = 100;
31 const std::string TEAR_DOWN_CMD = "rm /data/service/el1/public/edm/admin_policies.json";
32
SetUp()33 void AdminManagerTest::SetUp()
34 {
35 PermissionManager::GetInstance()->AddPermission("ohos.permission.EDM_TEST_PERMISSION");
36 PermissionManager::GetInstance()->AddPermission("ohos.permission.EDM_TEST_ENT_PERMISSION");
37 adminMgr_ = AdminManager::GetInstance();
38 adminMgr_->Init();
39 }
40
TearDown()41 void AdminManagerTest::TearDown()
42 {
43 std::vector<std::shared_ptr<Admin>> userAdmin;
44 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
45 for (const auto &admin : userAdmin) {
46 adminMgr_->DeleteAdmin(admin->adminInfo_.packageName_, DEFAULT_USER_ID);
47 }
48 adminMgr_->instance_.reset();
49 adminMgr_.reset();
50 PermissionManager::DestroyInstance();
51
52 CmdUtils::ExecCmdSync(TEAR_DOWN_CMD);
53 }
54
55 /**
56 * @tc.name: TestGetReqPermission
57 * @tc.desc: Test AdminManager::GetGrantedPermission function.
58 * @tc.type: FUNC
59 */
60 HWTEST_F(AdminManagerTest, TestGetReqPermission, TestSize.Level1)
61 {
62 std::vector<std::string> permissions;
63 std::vector<EdmPermission> reqPermission;
64 permissions = {
65 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION"
66 };
67 adminMgr_->GetReqPermission(permissions, reqPermission);
68 ASSERT_TRUE(reqPermission.size() == 1);
69
70 permissions = {
71 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION",
72 "ohos.permission.EDM_TEST_ENT_PERMISSION"
73 };
74 adminMgr_->GetReqPermission(permissions, reqPermission);
75 ASSERT_TRUE(reqPermission.size() == 2);
76 }
77
78 /**
79 * @tc.name: TestGetGrantedPermission
80 * @tc.desc: Test AdminManager::GetGrantedPermission function.
81 * @tc.type: FUNC
82 */
83 HWTEST_F(AdminManagerTest, TestGetGrantedPermission, TestSize.Level1)
84 {
85 ErrCode res;
86 std::vector<std::string> permissions;
87 AppExecFwk::ExtensionAbilityInfo abilityInfo;
88 abilityInfo.bundleName = "com.edm.test.demo";
89 abilityInfo.name = "testDemo";
90 EntInfo entInfo;
91 entInfo.enterpriseName = "company";
92 entInfo.description = "technology company in china";
93
94 permissions = {};
95 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::NORMAL);
96 ASSERT_TRUE(res == ERR_OK);
97
98 permissions = {
99 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION"
100 };
101 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::NORMAL);
102 ASSERT_TRUE(res == ERR_OK);
103 ASSERT_TRUE(permissions.size() == 1);
104
105 permissions = {
106 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION"
107 };
108 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::ENT);
109 ASSERT_TRUE(res == ERR_OK);
110 ASSERT_TRUE(permissions.size() == 1);
111
112 permissions = {
113 "ohos.permission.EDM_TEST_ENT_PERMISSION", "ohos.permission.EDM_TEST_PERMISSION"
114 };
115 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::NORMAL);
116 ASSERT_TRUE(res == ERR_OK);
117 ASSERT_TRUE(permissions.size() == 1);
118
119 permissions = {
120 "ohos.permission.EDM_TEST_ENT_PERMISSION", "ohos.permission.EDM_TEST_PERMISSION"
121 };
122 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::ENT);
123 ASSERT_TRUE(res == ERR_OK);
124 ASSERT_TRUE(permissions.size() == 2);
125 }
126
127 /**
128 * @tc.name: TestGetAdminByUserId
129 * @tc.desc: Test AdminManager::GetAdminByUserId function.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(AdminManagerTest, TestGetAdminByUserId, TestSize.Level1)
133 {
134 ErrCode res;
135 std::vector<std::shared_ptr<Admin>> userAdmin;
136 std::vector<std::string> permissions;
137 AppExecFwk::ExtensionAbilityInfo abilityInfo;
138 abilityInfo.bundleName = "com.edm.test.demo";
139 abilityInfo.name = "testDemo";
140 EntInfo entInfo;
141 entInfo.enterpriseName = "company";
142 entInfo.description = "technology company in wuhan";
143 permissions = {
144 "ohos.permission.EDM_TEST_PERMISSION"
145 };
146 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
147 ASSERT_TRUE(res == ERR_OK);
148 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
149 ASSERT_TRUE(userAdmin.size() == 1);
150
151 abilityInfo.bundleName = "com.edm.test.demo1";
152 permissions = {
153 "ohos.permission.EDM_TEST_PERMISSION", "ohos.permission.EDM_TEST_ENT_PERMISSION"
154 };
155 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
156 ASSERT_TRUE(res == ERR_OK);
157
158 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
159 ASSERT_TRUE(userAdmin.size() == 2);
160 }
161
162 /**
163 * @tc.name: TestGetAdminByPkgName
164 * @tc.desc: Test AdminManager::GetAdminByPkgName function.
165 * @tc.type: FUNC
166 */
167 HWTEST_F(AdminManagerTest, TestGetAdminByPkgName, TestSize.Level1)
168 {
169 ErrCode res;
170 std::vector<std::shared_ptr<Admin>> allAdmin;
171 std::vector<std::string> permissions;
172 AppExecFwk::ExtensionAbilityInfo abilityInfo;
173 abilityInfo.bundleName = "com.edm.test.demo";
174 abilityInfo.name = "testDemo";
175 EntInfo entInfo;
176 entInfo.enterpriseName = "company";
177 entInfo.description = "technology company in wuhan";
178 permissions = {
179 "ohos.permission.EDM_TEST_PERMISSION"
180 };
181 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
182 ASSERT_TRUE(res == ERR_OK);
183
184 abilityInfo.bundleName = "com.edm.test.demo1";
185 abilityInfo.name = "testDemo";
186 entInfo.enterpriseName = "company";
187 entInfo.description = "technology company in wuhan";
188
189 permissions = {
190 "ohos.permission.EDM_TEST_PERMISSION", "ohos.permission.EDM_TEST_ENT_PERMISSION"
191 };
192 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
193 ASSERT_TRUE(res == ERR_OK);
194
195 std::shared_ptr<Admin> admin;
196 admin = adminMgr_->GetAdminByPkgName("com.edm.test.demo", DEFAULT_USER_ID);
197 ASSERT_TRUE(admin != nullptr);
198
199 admin = adminMgr_->GetAdminByPkgName("com.edm.test.demo1", DEFAULT_USER_ID);
200 ASSERT_TRUE(admin != nullptr);
201 }
202
203 /**
204 * @tc.name: TestDeleteAdmin
205 * @tc.desc: Test AdminManager::DeleteAdmin function.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(AdminManagerTest, TestDeleteAdmin, TestSize.Level1)
209 {
210 ErrCode res;
211 std::vector<std::shared_ptr<Admin>> userAdmin;
212 std::vector<std::string> permissions;
213 AppExecFwk::ExtensionAbilityInfo abilityInfo;
214 abilityInfo.bundleName = "com.edm.test.demo";
215 abilityInfo.name = "testDemo";
216 EntInfo entInfo;
217 entInfo.enterpriseName = "company";
218 entInfo.description = "technology company in wuhan";
219 permissions = {
220 "ohos.permission.EDM_TEST_PERMISSION"
221 };
222 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
223 ASSERT_TRUE(res == ERR_OK);
224
225 abilityInfo.bundleName = "com.edm.test.demo1";
226 permissions = {
227 "ohos.permission.EDM_TEST_PERMISSION", "ohos.permission.EDM_TEST_ENT_PERMISSION"
228 };
229 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
230 ASSERT_TRUE(res == ERR_OK);
231
232 res = adminMgr_->DeleteAdmin("com.edm.test.demo", DEFAULT_USER_ID);
233 ASSERT_TRUE(res == ERR_OK);
234 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
235 ASSERT_TRUE(userAdmin.size() == 1);
236
237 res = adminMgr_->DeleteAdmin("com.edm.test.demo1", DEFAULT_USER_ID);
238 ASSERT_TRUE(res == ERR_OK);
239 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
240 ASSERT_TRUE(userAdmin.empty());
241 }
242
243 /**
244 * @tc.name: TestSetAdminValue
245 * @tc.desc: Test AdminManager::SetAdminValue function.
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AdminManagerTest, TestSetAdminValue, TestSize.Level1)
249 {
250 std::shared_ptr<Admin> admin;
251 std::string bundleName = "com.edm.test.demo";
252 ErrCode res;
253 AppExecFwk::ExtensionAbilityInfo abilityInfo;
254 abilityInfo.bundleName = bundleName;
255 abilityInfo.name = "testDemo";
256 EntInfo entInfo;
257 entInfo.enterpriseName = "company";
258 entInfo.description = "technology company in wuhan";
259 std::vector<std::string> permissions;
260
261 abilityInfo.bundleName = bundleName + "1";
262 permissions = {};
263 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
264 ASSERT_TRUE(res == ERR_OK);
265 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
266 ASSERT_TRUE(admin != nullptr);
267
268 abilityInfo.bundleName = bundleName + "2";
269 permissions = { "ohos.permission.EDM_TEST_ENT_PERMISSION" };
270 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
271 ASSERT_TRUE(res != ERR_OK);
272 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
273 ASSERT_TRUE(admin == nullptr);
274
275 abilityInfo.bundleName = bundleName + "3";
276 permissions = {
277 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION"
278 };
279 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
280 ASSERT_TRUE(res == ERR_OK);
281 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
282 ASSERT_TRUE(admin != nullptr);
283
284 abilityInfo.bundleName = bundleName + "4";
285 permissions = { "ohos.permission.EDM_TEST_PERMISSION" };
286 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
287 ASSERT_TRUE(res == ERR_OK);
288 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
289 ASSERT_TRUE(admin != nullptr);
290
291 abilityInfo.bundleName = bundleName + "5";
292 permissions = { "ohos.permission.EDM_TEST_ENT_PERMISSION", "ohos.permission.EDM_TEST_PERMISSION" };
293 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
294 ASSERT_TRUE(res == ERR_OK);
295 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
296 ASSERT_TRUE(admin != nullptr);
297 }
298
299 /**
300 * @tc.name: TestSetAdminValueHuge
301 * @tc.desc: Test AdminManager::SetAdminValue function.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(AdminManagerTest, TestSetAdminValueHuge, TestSize.Level1)
305 {
306 std::shared_ptr<Admin> admin;
307 std::string bundleName = "com.edm.test.demo";
308 ErrCode res;
309 AppExecFwk::ExtensionAbilityInfo abilityInfo;
310 abilityInfo.bundleName = bundleName;
311 abilityInfo.name = "testDemo";
312 EntInfo entInfo;
313 entInfo.enterpriseName = "company";
314 entInfo.description = "technology company in wuhan";
315 std::vector<std::string> permissions;
316
317 for (int i = 0; i < HUGE_ADMIN_SIZE; ++i) {
318 abilityInfo.bundleName = bundleName + std::to_string(i);
319 permissions = {
320 "ohos.permission.EDM_TEST_PERMISSION"
321 };
322 res = adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
323 ASSERT_TRUE(res == ERR_OK);
324 admin = adminMgr_->GetAdminByPkgName(abilityInfo.bundleName, DEFAULT_USER_ID);
325 ASSERT_TRUE(admin != nullptr);
326 }
327 std::vector<std::shared_ptr<Admin>> userAdmin;
328 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
329 ASSERT_TRUE(userAdmin.size() == HUGE_ADMIN_SIZE);
330 }
331
332 /**
333 * @tc.name: TestUpdateAdmin
334 * @tc.desc: Test AdminManager::UpdateAdmin function.
335 * @tc.type: FUNC
336 */
337 HWTEST_F(AdminManagerTest, TestUpdateAdmin, TestSize.Level1)
338 {
339 std::string bundleName = "com.edm.test.demo";
340
341 ErrCode res;
342 AppExecFwk::ExtensionAbilityInfo abilityInfo;
343 abilityInfo.bundleName = bundleName;
344 abilityInfo.name = "testDemo";
345 EntInfo entInfo;
346 entInfo.enterpriseName = "company";
347 entInfo.description = "technology company in wuhan";
348
349 std::vector<std::string> permissions = {
350 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_ENT_PERMISSION"
351 };
352 res = adminMgr_->GetGrantedPermission(abilityInfo, permissions, AdminType::ENT);
353 ASSERT_TRUE(res == ERR_OK);
354 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
355 std::vector<std::shared_ptr<Admin>> userAdmin;
356 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
357 ASSERT_TRUE(userAdmin.size() == 1);
358 ASSERT_TRUE(userAdmin.at(0)->adminInfo_.permission_.size() == 1);
359
360 permissions = {
361 "ohos.permission.EDM_TEST_PERMISSION_FAIL", "ohos.permission.EDM_TEST_PERMISSION",
362 "ohos.permission.EDM_TEST_ENT_PERMISSION"
363 };
364 res = adminMgr_->UpdateAdmin(abilityInfo, permissions, DEFAULT_USER_ID);
365 ASSERT_TRUE(res == ERR_OK);
366 adminMgr_->GetAdminByUserId(DEFAULT_USER_ID, userAdmin);
367 ASSERT_TRUE(userAdmin.size() == 1);
368 ASSERT_TRUE(userAdmin.at(0)->adminInfo_.permission_.size() == 2);
369 }
370
371 /**
372 * @tc.name: TestIsSuperAdmin
373 * @tc.desc: Test AdminManager::IsSuperAdmin function.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(AdminManagerTest, TestIsSuperAdmin, TestSize.Level1)
377 {
378 std::string bundleName = "com.edm.test.demo";
379 AppExecFwk::ExtensionAbilityInfo abilityInfo;
380 abilityInfo.bundleName = bundleName;
381 abilityInfo.name = "testDemo";
382 EntInfo entInfo;
383 entInfo.enterpriseName = "company";
384 entInfo.description = "technology company in wuhan";
385
386 std::vector<std::string> permissions = { "ohos.permission.EDM_TEST_ENT_PERMISSION" };
387 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
388 ASSERT_TRUE(adminMgr_->IsSuperAdmin(bundleName));
389 }
390
391 /**
392 * @tc.name: TestIsSuperAdminExist
393 * @tc.desc: Test AdminManager::IsSuperAdminExist function.
394 * @tc.type: FUNC
395 */
396 HWTEST_F(AdminManagerTest, TestIsSuperAdminExist, TestSize.Level1)
397 {
398 std::string bundleName = "com.edm.test.demo";
399 AppExecFwk::ExtensionAbilityInfo abilityInfo;
400 abilityInfo.bundleName = bundleName;
401 abilityInfo.name = "testDemo";
402 EntInfo entInfo;
403 entInfo.enterpriseName = "company";
404 entInfo.description = "technology company in wuhan";
405
406 std::vector<std::string> permissions = { "ohos.permission.EDM_TEST_ENT_PERMISSION" };
407 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::ENT, permissions, DEFAULT_USER_ID);
408 permissions = { "ohos.permission.EDM_TEST_PERMISSION" };
409 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
410 ASSERT_TRUE(!adminMgr_->IsSuperAdminExist());
411 }
412
413 /**
414 * @tc.name: TestGetAdminBySubscribeEvent
415 * @tc.desc: Test AdminManager::GetAdminBySubscribeEvent function.
416 * @tc.type: FUNC
417 */
418 HWTEST_F(AdminManagerTest, TestGetAdminBySubscribeEvent, TestSize.Level1)
419 {
420 AppExecFwk::ExtensionAbilityInfo abilityInfo;
421 abilityInfo.bundleName = "com.edm.test.demo";
422 abilityInfo.name = "testDemo";
423 EntInfo entInfo;
424 entInfo.enterpriseName = "company";
425 entInfo.description = "technology company in wuhan";
426 std::vector<std::string> permissions = { "ohos.permission.EDM_TEST_PERMISSION" };
427 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
428 abilityInfo.bundleName = "com.edm.test.demo1";
429 abilityInfo.name = "testDemo1";
430 entInfo.enterpriseName = "company1";
431 entInfo.description = "technology company in wuhan1";
432 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
433 abilityInfo.bundleName = "com.edm.test.demo2";
434 abilityInfo.name = "testDemo2";
435 entInfo.enterpriseName = "company2";
436 entInfo.description = "technology company in wuhan2";
437 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, TEST_USER_ID);
438
439 std::shared_ptr<Admin> adminItem = adminMgr_->GetAdminByPkgName("com.edm.test.demo", DEFAULT_USER_ID);
440 const std::vector<uint32_t> events = {0, 1};
441 adminMgr_->SaveSubscribeEvents(events, adminItem, DEFAULT_USER_ID);
442 const std::vector<uint32_t> events1 = {1};
443 std::shared_ptr<Admin> adminItem1 = adminMgr_->GetAdminByPkgName("com.edm.test.demo2", TEST_USER_ID);
444 adminMgr_->SaveSubscribeEvents(events1, adminItem1, TEST_USER_ID);
445
446 std::unordered_map<int32_t, std::vector<std::shared_ptr<Admin>>> subscribeAdmins;
447 adminMgr_->GetAdminBySubscribeEvent(ManagedEvent::BUNDLE_ADDED, subscribeAdmins);
448 ASSERT_TRUE(subscribeAdmins[DEFAULT_USER_ID].size() == 1);
449 ASSERT_TRUE(subscribeAdmins.find(TEST_USER_ID) == subscribeAdmins.end());
450 }
451
452 /**
453 * @tc.name: TestSaveSubscribeEvents
454 * @tc.desc: Test AdminManager::SaveSubscribeEvents function.
455 * @tc.type: FUNC
456 */
457 HWTEST_F(AdminManagerTest, TestSaveSubscribeEvents, TestSize.Level1)
458 {
459 std::shared_ptr<Admin> admin = std::make_shared<Admin>();
460 admin->adminInfo_.managedEvents_.push_back(ManagedEvent::BUNDLE_ADDED);
461 std::vector<uint32_t> events = {0};
462 AppExecFwk::ExtensionAbilityInfo abilityInfo;
463 abilityInfo.bundleName = "com.edm.test.demo";
464 abilityInfo.name = "testDemo";
465 EntInfo entInfo;
466 entInfo.enterpriseName = "company";
467 entInfo.description = "technology company in wuhan";
468 std::vector<std::string> permissions = { "ohos.permission.EDM_TEST_PERMISSION" };
469 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
470 adminMgr_->SaveSubscribeEvents(events, admin, DEFAULT_USER_ID);
471 ASSERT_TRUE(admin->adminInfo_.managedEvents_.size() == 1);
472 events.push_back(1);
473 adminMgr_->SaveSubscribeEvents(events, admin, DEFAULT_USER_ID);
474 ASSERT_TRUE(admin->adminInfo_.managedEvents_.size() > 1);
475 }
476
477 /**
478 * @tc.name: TestRemoveSubscribeEvents
479 * @tc.desc: Test AdminManager::RemoveSubscribeEvents function.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(AdminManagerTest, TestRemoveSubscribeEvents, TestSize.Level1)
483 {
484 std::shared_ptr<Admin> admin = std::make_shared<Admin>();
485 admin->adminInfo_.managedEvents_.push_back(ManagedEvent::BUNDLE_ADDED);
486 std::vector<uint32_t> events = {1};
487 AppExecFwk::ExtensionAbilityInfo abilityInfo;
488 abilityInfo.bundleName = "com.edm.test.demo";
489 abilityInfo.name = "testDemo";
490 EntInfo entInfo;
491 entInfo.enterpriseName = "company";
492 entInfo.description = "technology company in wuhan";
493 std::vector<std::string> permissions = { "ohos.permission.EDM_TEST_PERMISSION" };
494 adminMgr_->SetAdminValue(abilityInfo, entInfo, AdminType::NORMAL, permissions, DEFAULT_USER_ID);
495 adminMgr_->RemoveSubscribeEvents(events, admin, DEFAULT_USER_ID);
496 ASSERT_TRUE(admin->adminInfo_.managedEvents_.size() == 1);
497 events.push_back(0);
498 adminMgr_->RemoveSubscribeEvents(events, admin, DEFAULT_USER_ID);
499 ASSERT_TRUE(admin->adminInfo_.managedEvents_.empty());
500 }
501 } // namespace TEST
502 } // namespace EDM
503 } // namespace OHOS