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