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