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