1 /*
2 * Copyright (c) 2022-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 #define private public
17 #define protected public
18 #include "enterprise_device_mgr_ability.h"
19 #include "plugin_singleton.h"
20 #undef protected
21 #undef private
22
23 #include "enterprise_device_mgr_ability_test.h"
24
25 #include <fcntl.h>
26 #include <gtest/gtest.h>
27 #include <memory>
28 #include <string>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <vector>
32
33 #include "iplugin_template_test.h"
34 #include "plugin_manager_test.h"
35 #include "utils.h"
36 #include "edm_log.h"
37
38 using namespace testing;
39 using namespace testing::ext;
40
41 namespace OHOS {
42 namespace EDM {
43 namespace TEST {
44 constexpr int32_t TEST_USER_ID = 101;
45 constexpr int32_t WITHOUT_ADMIN_SUCCESS_POLICY_CODE = 1024;
46 constexpr int32_t MAP_TESTPLUGIN_POLICYCODE = 12;
47 constexpr int32_t HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE = 23;
48 constexpr int32_t HANDLE_POLICY_JSON_BIFUNCTIONPLG_POLICYCODE = 30;
49 constexpr int32_t HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE = 31;
50 constexpr int32_t BEGIN_POLICY_CODE = 10;
51 constexpr int32_t END_POLICY_CODE = 33;
52 constexpr int32_t INVALID_POLICYCODE = 123456;
53 constexpr int32_t ERROR_USER_ID = 0;
54 constexpr size_t COMMON_EVENT_FUNC_MAP_SIZE = 10;
55 constexpr uint32_t INVALID_MANAGED_EVENT_TEST = 20;
56 constexpr uint32_t BUNDLE_ADDED_EVENT = static_cast<uint32_t>(ManagedEvent::BUNDLE_ADDED);
57 constexpr uint32_t BUNDLE_REMOVED_EVENT = static_cast<uint32_t>(ManagedEvent::BUNDLE_REMOVED);
58 constexpr uint32_t APP_START_EVENT = static_cast<uint32_t>(ManagedEvent::APP_START);
59 constexpr uint32_t APP_STOP_EVENT = static_cast<uint32_t>(ManagedEvent::APP_STOP);
60 constexpr int32_t INDEX_TWO = 2;
61 constexpr int32_t INDEX_FOUR = 4;
62 constexpr int32_t TEST_SLEEP_TIME = 5;
63 const std::string PERMISSION_RUNNING_STATE_OBSERVER = "ohos.permission.RUNNING_STATE_OBSERVER";
64 const std::string ADMIN_PACKAGENAME = "com.edm.test";
65 const std::string ADMIN_PACKAGENAME_1 = "com.edm.test_1";
66 const std::string ADMIN_PACKAGENAME_ABILITY = "com.edm.test.MainAbility";
67 const std::string ADMIN_PACKAGENAME_ABILITY_1 = "com.edm.test.MainAbility_1";
68 const std::string ADMIN_PACKAGENAME_FAILED = "com.edm.test.demo.ipc.fail";
69 const std::string ADMIN_PACKAGENAME_NOT_ACTIVE = "com.edm.test.not.active";
70 const std::string EDM_MANAGE_DATETIME_PERMISSION = "ohos.permission.SET_TIME";
71 const std::string EDM_TEST_PERMISSION = "ohos.permission.EDM_TEST_PERMISSION";
72 const std::string EDM_TEST_ENT_PERMISSION = "ohos.permission.EDM_TEST_ENT_PERMISSION";
73 const std::string TEST_POLICY_VALUE = "test_policy_value";
74
initPolicies()75 void EnterpriseDeviceMgrAbilityTest::initPolicies()
76 {
77 permissionCheckerMock_->allowDelegatedPolicies_ = {
78 PolicyName::POLICY_DISALLOW_ADD_LOCAL_ACCOUNT, PolicyName::POLICY_DISALLOW_ADD_OS_ACCOUNT_BY_USER,
79 PolicyName::POLICY_DISALLOW_RUNNING_BUNDLES, PolicyName::POLICY_MANAGE_AUTO_START_APPS,
80 PolicyName::POLICY_ALLOWED_BLUETOOTH_DEVICES, PolicyName::POLICY_SET_BROWSER_POLICIES,
81 PolicyName::POLICY_ALLOWED_INSTALL_BUNDLES, PolicyName::POLICY_DISALLOWED_INSTALL_BUNDLES,
82 PolicyName::POLICY_DISALLOWED_UNINSTALL_BUNDLES, PolicyName::POLICY_SNAPSHOT_SKIP,
83 PolicyName::POLICY_LOCATION_POLICY, PolicyName::POLICY_DISABLED_NETWORK_INTERFACE,
84 PolicyName::POLICY_GLOBAL_PROXY, PolicyName::POLICY_DISABLED_BLUETOOTH,
85 PolicyName::POLICY_DISALLOW_MODIFY_DATETIME, PolicyName::POLICY_DISABLED_PRINTER,
86 PolicyName::POLICY_POLICY_SCREEN_SHOT, PolicyName::POLICY_DISABLED_HDC,
87 PolicyName::POLICY_DISABLE_MICROPHONE, PolicyName::POLICY_FINGERPRINT_AUTH,
88 PolicyName::POLICY_DISABLE_USB, PolicyName::POLICY_DISABLE_WIFI,
89 PolicyName::POLICY_DISALLOWED_TETHERING, PolicyName::POLICY_INACTIVE_USER_FREEZE,
90 PolicyName::POLICY_PASSWORD_POLICY, PolicyName::POLICY_CLIPBOARD_POLICY,
91 PolicyName::POLICY_NTP_SERVER, PolicyName::POLICY_SET_UPDATE_POLICY,
92 PolicyName::POLICY_NOTIFY_UPGRADE_PACKAGES, PolicyName::POLICY_ALLOWED_USB_DEVICES,
93 PolicyName::POLICY_USB_READ_ONLY, PolicyName::POLICY_DISALLOWED_USB_DEVICES,
94 PolicyName::POLICY_GET_DEVICE_INFO, PolicyName::POLICY_WATERMARK_IMAGE_POLICY,
95 PolicyName::POLICY_POLICY_SCREEN_RECORD, PolicyName::POLICY_INSTALLED_BUNDLE_INFO_LIST,
96 PolicyName::POLICY_ALLOW_ALL,
97 };
98 }
99
SetUp()100 void EnterpriseDeviceMgrAbilityTest::SetUp()
101 {
102 plugin_ = PLUGIN::MapTestPlugin::GetPlugin();
103 appMgrMock_ = std::make_shared<EdmAppManagerImplMock>();
104 bundleMgrMock_ = std::make_shared<EdmBundleManagerImplMock>();
105 osAccountMgrMock_ = std::make_shared<EdmOsAccountManagerImplMock>();
106 accessTokenMgrMock_ = std::make_shared<EdmAccessTokenManagerImplMock>();
107 factoryMock_ = std::make_shared<ExternalManagerFactoryMock>();
108 permissionCheckerMock_ = std::make_shared<PermissionCheckerMock>();
109 edmMgr_ = new (std::nothrow) EnterpriseDeviceMgrAbilityMock();
110 edmMgr_->adminMgr_ = AdminManager::GetInstance();
111 edmMgr_->policyMgr_ = std::make_shared<PolicyManager>();
112 EXPECT_CALL(*edmMgr_, GetExternalManagerFactory).WillRepeatedly(DoAll(Return(factoryMock_)));
113 EXPECT_CALL(*edmMgr_, GetPermissionChecker).WillRepeatedly(DoAll(Return(permissionCheckerMock_)));
114 EXPECT_CALL(*permissionCheckerMock_, GetExternalManagerFactory).WillRepeatedly(DoAll(Return(factoryMock_)));
115 EXPECT_CALL(*factoryMock_, CreateBundleManager).WillRepeatedly(DoAll(Return(bundleMgrMock_)));
116 EXPECT_CALL(*factoryMock_, CreateAppManager).WillRepeatedly(DoAll(Return(appMgrMock_)));
117 EXPECT_CALL(*factoryMock_, CreateOsAccountManager).WillRepeatedly(DoAll(Return(osAccountMgrMock_)));
118 EXPECT_CALL(*factoryMock_, CreateAccessTokenManager).WillRepeatedly(DoAll(Return(accessTokenMgrMock_)));
119 }
120
TearDown()121 void EnterpriseDeviceMgrAbilityTest::TearDown()
122 {
123 edmMgr_->adminMgr_->ClearAdmins();
124 edmMgr_->policyMgr_.reset();
125 edmMgr_->instance_.clear();
126 edmMgr_.clear();
127 }
128
SetUpTestSuite()129 void EnterpriseDeviceMgrAbilityTest::SetUpTestSuite()
130 {
131 for (int32_t i = BEGIN_POLICY_CODE; i <= END_POLICY_CODE; i++) {
132 PluginManager::deviceCoreSoCodes_.push_back(i);
133 }
134 }
135
TearDownTestSuite()136 void EnterpriseDeviceMgrAbilityTest::TearDownTestSuite()
137 {
138 PluginManager::GetInstance()->NotifyUnloadAllPlugin();
139 std::this_thread::sleep_for(std::chrono::seconds(TEST_SLEEP_TIME));
140 }
141
TestDump()142 int32_t EnterpriseDeviceMgrAbilityTest::TestDump()
143 {
144 int32_t fd = open("/data/edmDumpTest.txt",
145 O_RDWR | O_APPEND | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO);
146 if (fd < 0) {
147 GTEST_LOG_(INFO) << "mock EnterpriseDeviceMgrAbilityTest open fail!";
148 return -1;
149 }
150 std::vector<std::u16string> args;
151 int32_t res = edmMgr_->Dump(fd, args);
152 close(fd);
153 return res;
154 }
155
156 // Give testAdmin and plugin_ Initial value
PrepareBeforeHandleDevicePolicy()157 void EnterpriseDeviceMgrAbilityTest::PrepareBeforeHandleDevicePolicy()
158 {
159 Admin testAdmin;
160 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
161 testAdmin.adminInfo_.permission_ = {EDM_MANAGE_DATETIME_PERMISSION};
162 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
163
164 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME_FAILED;
165 adminVec.push_back(std::make_shared<Admin>(testAdmin));
166 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
167 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
168 EDM_MANAGE_DATETIME_PERMISSION;
169 PluginManager::GetInstance()->AddPlugin(plugin_);
170 }
171
GetPolicySuccess(int32_t userId,const std::string & adminName,const std::string & policyName)172 void EnterpriseDeviceMgrAbilityTest::GetPolicySuccess(int32_t userId, const std::string& adminName,
173 const std::string& policyName)
174 {
175 std::string policyValue;
176 EXPECT_TRUE(SUCCEEDED(edmMgr_->policyMgr_->GetPolicy(adminName, policyName, policyValue, userId)));
177 EXPECT_EQ(policyValue, TEST_POLICY_VALUE);
178 policyValue.clear();
179 EXPECT_TRUE(SUCCEEDED(edmMgr_->policyMgr_->GetPolicy("", policyName, policyValue, userId)));
180 EXPECT_EQ(policyValue, TEST_POLICY_VALUE);
181 }
182
GetPolicyFailed(int32_t userId,const std::string & adminName,const std::string & policyName)183 void EnterpriseDeviceMgrAbilityTest::GetPolicyFailed(int32_t userId, const std::string& adminName,
184 const std::string& policyName)
185 {
186 std::string policyValue;
187 EXPECT_TRUE(FAILED(edmMgr_->policyMgr_->GetPolicy(adminName, policyName, policyValue, userId)));
188 EXPECT_TRUE(FAILED(edmMgr_->policyMgr_->GetPolicy("", policyName, policyValue, userId)));
189 }
190
SetPolicy(const std::string & adminName,const std::string & policyName)191 void EnterpriseDeviceMgrAbilityTest::SetPolicy(const std::string& adminName, const std::string& policyName)
192 {
193 edmMgr_->policyMgr_->SetPolicy(adminName, policyName, TEST_POLICY_VALUE, TEST_POLICY_VALUE, DEFAULT_USER_ID);
194 edmMgr_->policyMgr_->SetPolicy(adminName, policyName, TEST_POLICY_VALUE, TEST_POLICY_VALUE, TEST_USER_ID);
195 }
196
EnableAdminSuc(AppExecFwk::ElementName & admin,AdminType adminType,int userId,bool isDebug)197 void EnterpriseDeviceMgrAbilityTest::EnableAdminSuc(AppExecFwk::ElementName &admin, AdminType adminType, int userId,
198 bool isDebug)
199 {
200 EntInfo entInfo("test", "this is test");
201 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(isDebug)));
202 if (!isDebug) {
203 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
204 .Times(testing::AtLeast(1))
205 .WillRepeatedly(DoAll(Return(true)));
206 }
207 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
208 GetBundleInfoMock(true, EDM_TEST_PERMISSION);
209 EXPECT_TRUE(SUCCEEDED(edmMgr_->EnableAdmin(admin, entInfo, adminType, userId)));
210 }
211
DisableAdminSuc(AppExecFwk::ElementName & admin,int32_t userId)212 void EnterpriseDeviceMgrAbilityTest::DisableAdminSuc(AppExecFwk::ElementName &admin, int32_t userId)
213 {
214 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
215 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
216 EXPECT_TRUE(SUCCEEDED(edmMgr_->DisableAdmin(admin, userId)));
217 }
218
DisableSuperAdminSuc(const std::string & bundleName)219 void EnterpriseDeviceMgrAbilityTest::DisableSuperAdminSuc(const std::string &bundleName)
220 {
221 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
222 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
223 EXPECT_TRUE(SUCCEEDED(edmMgr_->DisableSuperAdmin(bundleName)));
224 }
225
AuthorizeAdminSuc(const AppExecFwk::ElementName & admin,const std::string & subSuperAdminBundleName)226 void EnterpriseDeviceMgrAbilityTest::AuthorizeAdminSuc(const AppExecFwk::ElementName &admin,
227 const std::string &subSuperAdminBundleName)
228 {
229 GetBundleInfoMock(true, EDM_TEST_PERMISSION);
230 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
231 EXPECT_TRUE(SUCCEEDED(edmMgr_->AuthorizeAdmin(admin, subSuperAdminBundleName)));
232 }
233
QueryExtensionAbilityInfosMock(bool ret,const std::string & bundleName,bool isExtensionInfoEmpty)234 void EnterpriseDeviceMgrAbilityTest::QueryExtensionAbilityInfosMock(bool ret, const std::string& bundleName,
235 bool isExtensionInfoEmpty)
236 {
237 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
238 if (!isExtensionInfoEmpty) {
239 AppExecFwk::ExtensionAbilityInfo extensionAbilityInfo;
240 extensionAbilityInfo.bundleName = bundleName;
241 extensionAbilityInfo.name = ADMIN_PACKAGENAME_ABILITY;
242 extensionInfos.emplace_back(extensionAbilityInfo);
243 }
244 EXPECT_CALL(*bundleMgrMock_, QueryExtensionAbilityInfos)
245 .Times(testing::AtLeast(1))
246 .WillRepeatedly(DoAll(SetArgReferee<INDEX_FOUR>(extensionInfos), Return(ret)));
247 }
248
GetBundleInfoMock(bool ret,const std::string & permission)249 void EnterpriseDeviceMgrAbilityTest::GetBundleInfoMock(bool ret, const std::string &permission)
250 {
251 AppExecFwk::BundleInfo bundleInfo;
252 if (!permission.empty()) {
253 bundleInfo.reqPermissions.emplace_back(permission);
254 }
255 EXPECT_CALL(*bundleMgrMock_, GetBundleInfo)
256 .Times(testing::AtLeast(1))
257 .WillRepeatedly(DoAll(SetArgReferee<INDEX_TWO>(bundleInfo), Return(ret)));
258 }
259
260 /**
261 * @tc.name: TestHandleDevicePolicyWithUserNotExsist
262 * @tc.desc: Test HandleDevicePolicy function with userId is not exist.
263 * @tc.type: FUNC
264 */
265 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyWithUserNotExsist, TestSize.Level1)
266 {
267 PrepareBeforeHandleDevicePolicy();
268
269 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(false), Return(ERR_OK)));
270
271 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
272 AppExecFwk::ElementName elementName;
273 elementName.SetBundleName(ADMIN_PACKAGENAME_FAILED);
274 MessageParcel data;
275 MessageParcel reply;
276 data.WriteString("");
277 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
278 ASSERT_TRUE(res == EdmReturnErrCode::PARAM_ERROR);
279 }
280
281 /**
282 * @tc.name: TestHandleDevicePolicyWithoutAdmin
283 * @tc.desc: Test HandleDevicePolicy with none admmin.
284 * @tc.type: FUNC
285 */
286 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyWithoutAdmin, TestSize.Level1)
287 {
288 PrepareBeforeHandleDevicePolicy();
289
290 std::vector<int32_t> ids = {DEFAULT_USER_ID};
291 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
292 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillOnce(DoAll(SetArgReferee<0>(ids), Return(ERR_OK)));
293
294 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
295 AppExecFwk::ElementName elementName;
296 elementName.SetBundleName(ADMIN_PACKAGENAME_NOT_ACTIVE);
297 MessageParcel data;
298 MessageParcel reply;
299 data.WriteString("");
300 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
301 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
302 }
303
304 /**
305 * @tc.name: TestHandleDevicePolicyCheckCallingUidFailed
306 * @tc.desc: Test HandleDevicePolicy function with check callingUid failed.
307 * @tc.type: FUNC
308 */
309 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyCheckCallingUidFailed, TestSize.Level1)
310 {
311 PrepareBeforeHandleDevicePolicy();
312
313 std::vector<int32_t> ids = {DEFAULT_USER_ID};
314 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
315 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
316 Return(ERR_OK)));
317 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(Return(1)));
318
319 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
320 AppExecFwk::ElementName elementName;
321 elementName.SetBundleName(ADMIN_PACKAGENAME);
322 MessageParcel data;
323 MessageParcel reply;
324 data.WriteString("");
325 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
326 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
327 }
328
329 /**
330 * @tc.name: TestHandleDevicePolicyWithInvalidPlugin
331 * @tc.desc: Test HandleDevicePolicy function with invalid policy code.
332 * @tc.type: FUNC
333 */
334 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyWithInvalidPlugin, TestSize.Level1)
335 {
336 PrepareBeforeHandleDevicePolicy();
337
338 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
339 AppExecFwk::ElementName elementName;
340 elementName.SetBundleName(ADMIN_PACKAGENAME);
341 MessageParcel data;
342 MessageParcel reply;
343 data.WriteString("");
344 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
345 ASSERT_TRUE(res == EdmReturnErrCode::INTERFACE_UNSUPPORTED);
346 }
347
348 /**
349 * @tc.name: TestHandleDevicePolicyCheckPermissionFailed
350 * @tc.desc: Test HandleDevicePolicy function with check plugin permission failed.
351 * @tc.type: FUNC
352 */
353 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyCheckPermissionFailed, TestSize.Level1)
354 {
355 PrepareBeforeHandleDevicePolicy();
356 Admin testAdmin;
357 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
358 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
359 edmMgr_->adminMgr_->ClearAdmins();
360 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
361
362 std::vector<int32_t> ids = {DEFAULT_USER_ID};
363 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
364 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
365 Return(ERR_OK)));
366 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
367 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
368 GetBundleInfoMock(true, "");
369
370 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
371 AppExecFwk::ElementName elementName;
372 elementName.SetBundleName(ADMIN_PACKAGENAME);
373 MessageParcel data;
374 MessageParcel reply;
375 data.WriteString("");
376 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
377 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
378 }
379
380 /**
381 * @tc.name: TestHandleDevicePolicyGetAdminByPkgNameFailed
382 * @tc.desc: Test HandleDevicePolicy function with get admin by pkgName failed.
383 * @tc.type: FUNC
384 */
385 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyGetAdminByPkgNameFailed, TestSize.Level1)
386 {
387 PrepareBeforeHandleDevicePolicy();
388 Admin testAdmin;
389 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
390 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
391 edmMgr_->adminMgr_->ClearAdmins();
392 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
393
394 std::vector<int32_t> ids = {DEFAULT_USER_ID};
395 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
396 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
397 Return(ERR_OK)));
398
399 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
400 AppExecFwk::ElementName elementName;
401 elementName.SetBundleName(ADMIN_PACKAGENAME_1);
402 MessageParcel data;
403 MessageParcel reply;
404 data.WriteString("");
405 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
406 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
407 }
408
409 /**
410 * @tc.name: TestHandleDevicePolicyVerifyCallingPermissionFailed
411 * @tc.desc: Test HandleDevicePolicy function with check calling permission failed.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyVerifyCallingPermissionFailed, TestSize.Level1)
415 {
416 PrepareBeforeHandleDevicePolicy();
417 Admin testAdmin;
418 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
419 testAdmin.adminInfo_.permission_ = {EDM_TEST_PERMISSION};
420 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
421 edmMgr_->adminMgr_->ClearAdmins();
422 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
423 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
424 EDM_TEST_PERMISSION;
425 PluginManager::GetInstance()->pluginsCode_.clear();
426 PluginManager::GetInstance()->pluginsName_.clear();
427 PluginManager::GetInstance()->AddPlugin(plugin_);
428
429 std::vector<int32_t> ids = {DEFAULT_USER_ID};
430 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
431 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
432 Return(ERR_OK)));
433 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
434 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
435 GetBundleInfoMock(true, "");
436
437 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
438 AppExecFwk::ElementName elementName;
439 elementName.SetBundleName(ADMIN_PACKAGENAME);
440 MessageParcel data;
441 MessageParcel reply;
442 data.WriteString("");
443 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
444 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
445 }
446
447 /**
448 * @tc.name: TestHandleDevicePolicySuc
449 * @tc.desc: Test HandleDevicePolicy function success.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicySuc, TestSize.Level1)
453 {
454 PrepareBeforeHandleDevicePolicy();
455
456 std::vector<int32_t> ids = {DEFAULT_USER_ID};
457 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
458 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
459 Return(ERR_OK)));
460 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
461 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
462
463 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
464 AppExecFwk::ElementName elementName;
465 elementName.SetBundleName(ADMIN_PACKAGENAME);
466 MessageParcel data;
467 MessageParcel reply;
468 data.WriteString("");
469 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
470 ASSERT_TRUE(res == ERR_OK);
471 }
472
473
474 /**
475 * @tc.name: HandleDevicePolicyFuncTest006
476 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
477 * @tc.desc: plugin->OnHandlePolicy(code, data, reply, policyValue, isChanged)
478 * @tc.desc: Test the result of plugin->OnHandlePolicy is not OK
479 * @tc.type: FUNC
480 * @tc.require: issueI5PBT1
481 */
482 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest006, TestSize.Level1)
483 {
484 PrepareBeforeHandleDevicePolicy();
485
486 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
487 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
488 EDM_MANAGE_DATETIME_PERMISSION;
489 PluginManager::GetInstance()->pluginsCode_.clear();
490 PluginManager::GetInstance()->pluginsName_.clear();
491 PluginManager::GetInstance()->AddPlugin(plugin_);
492
493 std::vector<int32_t> ids = {DEFAULT_USER_ID};
494 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
495 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
496 Return(ERR_OK)));
497 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
498 Return(ERR_OK)));
499 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
500
501 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
502 AppExecFwk::ElementName elementName;
503 elementName.SetBundleName(ADMIN_PACKAGENAME);
504 MessageParcel data;
505 MessageParcel reply;
506 data.WriteString("");
507 data.WriteString("ErrorData");
508 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
509 ASSERT_TRUE(res == ERR_EDM_OPERATE_JSON);
510 }
511
512 /**
513 * @tc.name: HandleDevicePolicyFuncTest007
514 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.(if (plugin->NeedSavePolicy() && isChanged))
515 * @tc.desc: Test run into the branch if (plugin ->NeedSavePolicy() && isChanged)
516 * @tc.type: FUNC
517 * @tc.require: issueI5PBT1
518 */
519 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest007, TestSize.Level1)
520 {
521 PrepareBeforeHandleDevicePolicy();
522 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
523 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
524 EDM_MANAGE_DATETIME_PERMISSION;
525 PluginManager::GetInstance()->pluginsCode_.clear();
526 PluginManager::GetInstance()->pluginsName_.clear();
527 PluginManager::GetInstance()->AddPlugin(plugin_);
528
529 std::vector<int32_t> ids = {DEFAULT_USER_ID};
530 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
531 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
532 Return(ERR_OK)));
533 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
534 Return(ERR_OK)));
535 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
536
537 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
538 AppExecFwk::ElementName elementName;
539 elementName.SetBundleName(ADMIN_PACKAGENAME);
540 MessageParcel data;
541 MessageParcel reply;
542 data.WriteString("");
543 data.WriteString("testValue");
544 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
545 ASSERT_TRUE(res == ERR_OK);
546 res = edmMgr_->policyMgr_->SetPolicy(ADMIN_PACKAGENAME, plugin_->GetPolicyName(), "", "");
547 ASSERT_TRUE(res == ERR_OK);
548
549 plugin_ = PLUGIN::HandlePolicyBiFunctionUnsavePlg::GetPlugin();
550 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
551 EDM_MANAGE_DATETIME_PERMISSION;
552 PluginManager::GetInstance()->pluginsCode_.clear();
553 PluginManager::GetInstance()->pluginsName_.clear();
554 PluginManager::GetInstance()->AddPlugin(plugin_);
555 code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE);
556 data.WriteString("");
557 data.WriteString("{\"name\" : \"testValue\"}");
558 res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
559 ASSERT_TRUE(res == ERR_OK);
560 }
561
562 /**
563 * @tc.name: HandleDevicePolicyFuncTest008
564 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
565 * @tc.desc: run into plugin->MergePolicyData(admin.GetBundleName(), mergedPolicy)
566 * @tc.desc: Test the MergePolicyData processing result is not OK
567 * @tc.type: FUNC
568 * @tc.require: issueI5PBT1
569 */
570 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest008, TestSize.Level1)
571 {
572 PrepareBeforeHandleDevicePolicy();
573 plugin_ = PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin();
574 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
575 EDM_MANAGE_DATETIME_PERMISSION;
576 PluginManager::GetInstance()->pluginsCode_.clear();
577 PluginManager::GetInstance()->pluginsName_.clear();
578 PluginManager::GetInstance()->AddPlugin(plugin_);
579
580 std::vector<int32_t> ids = {DEFAULT_USER_ID};
581 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
582 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
583 Return(ERR_OK)));
584 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
585 Return(ERR_OK)));
586 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
587
588 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_JSON_BIFUNCTIONPLG_POLICYCODE);
589 AppExecFwk::ElementName elementName;
590 elementName.SetBundleName(ADMIN_PACKAGENAME);
591 MessageParcel data;
592 MessageParcel reply;
593 data.WriteString("");
594 data.WriteString("{\"name\" : \"testValue\"}");
595 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data, reply, DEFAULT_USER_ID);
596 ASSERT_TRUE(res == ERR_OK);
597 res = edmMgr_->policyMgr_->SetPolicy(ADMIN_PACKAGENAME, plugin_->GetPolicyName(), "", "", DEFAULT_USER_ID);
598 ASSERT_TRUE(res == ERR_OK);
599 }
600
601 /**
602 * @tc.name: TestGetDevicePolicyWithUserNotExsist
603 * @tc.desc: Test GetDevicePolicy function with userId is not exist.
604 * @tc.type: FUNC
605 */
606 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithUserNotExsist, TestSize.Level1)
607 {
608 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(false), Return(ERR_OK)));
609
610 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
611 MessageParcel data;
612 MessageParcel reply;
613 data.WriteInt32(1);
614 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
615 ASSERT_TRUE(res == EdmReturnErrCode::PARAM_ERROR);
616 }
617
618 /**
619 * @tc.name: TestGetDevicePolicyWithNotExistPlugin
620 * @tc.desc: Test GetDevicePolicy function with not exist plugin.
621 * @tc.type: FUNC
622 */
623 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithNotExistPlugin, TestSize.Level1)
624 {
625 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
626
627 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
628 MessageParcel data;
629 MessageParcel reply;
630 data.WriteInt32(1);
631 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
632 ASSERT_TRUE(res == EdmReturnErrCode::INTERFACE_UNSUPPORTED);
633 }
634
635 /**
636 * @tc.name: TestGetDevicePolicyWithAdminInactive
637 * @tc.desc: Test GetDevicePolicy function with admin inactive.
638 * @tc.type: FUNC
639 */
640 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithAdminInactive, TestSize.Level1)
641 {
642 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
643
644 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
645 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
646 EDM_MANAGE_DATETIME_PERMISSION;
647 PluginManager::GetInstance()->AddPlugin(plugin_);
648 AppExecFwk::ElementName admin;
649 admin.SetBundleName(ADMIN_PACKAGENAME_NOT_ACTIVE);
650 MessageParcel data;
651 MessageParcel reply;
652 data.WriteString("");
653 data.WriteInt32(0);
654 data.WriteParcelable(&admin);
655 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
656 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
657 }
658
659 /**
660 * @tc.name: TestGetDevicePolicyWithCheckCallingUidFailed
661 * @tc.desc: Test GetDevicePolicy function with check calling uid failed.
662 * @tc.type: FUNC
663 */
664 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithCheckCallingUidFailed, TestSize.Level1)
665 {
666 Admin testAdmin;
667 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
668 testAdmin.adminInfo_.permission_ = {EDM_TEST_PERMISSION};
669 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
670 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
671 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
672 PluginManager::GetInstance()->AddPlugin(plugin_);
673
674 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
675 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(1)));
676 std::vector<int32_t> ids = {DEFAULT_USER_ID};
677 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
678 Return(ERR_OK)));
679
680 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
681 AppExecFwk::ElementName admin;
682 admin.SetBundleName(ADMIN_PACKAGENAME);
683 MessageParcel data;
684 MessageParcel reply;
685 data.WriteString("");
686 data.WriteInt32(0);
687 data.WriteParcelable(&admin);
688 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
689 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
690 }
691
692 /**
693 * @tc.name: TestGetDevicePolicyWithCheckEdmPermissionFailed
694 * @tc.desc: Test GetDevicePolicy function with check edm permission failed.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithCheckEdmPermissionFailed, TestSize.Level1)
698 {
699 PrepareBeforeHandleDevicePolicy();
700 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
701 PluginManager::GetInstance()->AddPlugin(plugin_);
702
703 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
704 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
705 std::vector<int32_t> ids = {DEFAULT_USER_ID};
706 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
707 Return(ERR_OK)));
708 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
709 GetBundleInfoMock(true, "");
710
711 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
712 AppExecFwk::ElementName admin;
713 admin.SetBundleName(ADMIN_PACKAGENAME);
714 MessageParcel data;
715 MessageParcel reply;
716 data.WriteString("");
717 data.WriteInt32(0);
718 data.WriteParcelable(&admin);
719 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
720 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
721 }
722
723 /**
724 * @tc.name: TestGetDevicePolicyWithGetAdminByPkgNameFailed
725 * @tc.desc: Test GetDevicePolicy function with get admin by pkgName failed.
726 * @tc.type: FUNC
727 */
728 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithGetAdminByPkgNameFailed, TestSize.Level1)
729 {
730 PrepareBeforeHandleDevicePolicy();
731 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
732 PluginManager::GetInstance()->AddPlugin(plugin_);
733
734 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
735 std::vector<int32_t> ids = {DEFAULT_USER_ID};
736 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
737 Return(ERR_OK)));
738
739 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
740 AppExecFwk::ElementName admin;
741 admin.SetBundleName(ADMIN_PACKAGENAME_1);
742 MessageParcel data;
743 MessageParcel reply;
744 data.WriteString("");
745 data.WriteInt32(0);
746 data.WriteParcelable(&admin);
747 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
748 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
749 }
750
751 /**
752 * @tc.name: TestGetDevicePolicySuc
753 * @tc.desc: Test GetDevicePolicy function success.
754 * @tc.type: FUNC
755 */
756 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicySuc, TestSize.Level1)
757 {
758 PrepareBeforeHandleDevicePolicy();
759
760 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
761 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
762 std::vector<int32_t> ids = {DEFAULT_USER_ID};
763 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
764 Return(ERR_OK)));
765 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
766
767 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
768 AppExecFwk::ElementName admin;
769 admin.SetBundleName(ADMIN_PACKAGENAME);
770 MessageParcel data;
771 MessageParcel reply;
772 data.WriteString("");
773 data.WriteInt32(0);
774 data.WriteParcelable(&admin);
775 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
776 ASSERT_TRUE(res == ERR_OK);
777 }
778 /**
779 * @tc.name: TestGetDevicePolicyWithoutAdminSuc
780 * @tc.desc: Test GetDevicePolicy function success without admin.
781 * @tc.type: FUNC
782 */
783 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyWithoutAdminSuc, TestSize.Level1)
784 {
785 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
786
787 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, WITHOUT_ADMIN_SUCCESS_POLICY_CODE);
788 MessageParcel data;
789 MessageParcel reply;
790 data.WriteInt32(1);
791 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
792 EDM_MANAGE_DATETIME_PERMISSION;
793 PluginManager::GetInstance()->AddPlugin(plugin_);
794 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
795 ASSERT_TRUE(res == ERR_OK);
796 }
797
798 /**
799 * @tc.name: GetDevicePolicyFuncTest006
800 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicy function.
801 * @tc.desc: Test if (plugin->NeedSavePolicy())
802 * @tc.type: FUNC
803 * @tc.require: issueI5PBT1
804 */
805 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyFuncTest006, TestSize.Level1)
806 {
807 PrepareBeforeHandleDevicePolicy();
808 plugin_ = PLUGIN::HandlePolicyBiFunctionUnsavePlg::GetPlugin();
809 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
810 EDM_MANAGE_DATETIME_PERMISSION;
811 PluginManager::GetInstance()->pluginsCode_.clear();
812 PluginManager::GetInstance()->pluginsName_.clear();
813 PluginManager::GetInstance()->AddPlugin(plugin_);
814
815 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
816 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
817 std::vector<int32_t> ids = {DEFAULT_USER_ID};
818 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
819 Return(ERR_OK)));
820 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
821
822 uint32_t code =
823 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE);
824 AppExecFwk::ElementName admin;
825 admin.SetBundleName(ADMIN_PACKAGENAME);
826 MessageParcel data;
827 MessageParcel reply;
828 data.WriteString("");
829 data.WriteInt32(0);
830 data.WriteParcelable(&admin);
831 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
832 ASSERT_TRUE(res == ERR_OK);
833 }
834
835 /**
836 * @tc.name: GetDevicePolicyFuncTest007
837 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicy function.
838 * @tc.desc: Test if admin != nullptr && (deviceAdmin->CheckPermission fail)
839 * @tc.type: FUNC
840 * @tc.require: issueI5PBT1
841 */
842 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyFuncTest007, TestSize.Level1)
843 {
844 PrepareBeforeHandleDevicePolicy();
845 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
846 PluginManager::GetInstance()->AddPlugin(plugin_);
847
848 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
849 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
850 std::vector<int32_t> ids = {DEFAULT_USER_ID};
851 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
852 Return(ERR_OK)));
853
854 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
855 AppExecFwk::ElementName admin;
856 admin.SetBundleName(ADMIN_PACKAGENAME_FAILED);
857 MessageParcel data;
858 MessageParcel reply;
859 data.WriteString("");
860 data.WriteInt32(0);
861 data.WriteParcelable(&admin);
862 ErrCode res = edmMgr_->GetDevicePolicy(code, data, reply, DEFAULT_USER_ID);
863 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
864 }
865
866 /**
867 * @tc.name: TestOnCommonEventPackageRemovedNormal
868 * @tc.desc: Test OnCommonEventPackageRemoved noraml admin func.
869 * @tc.type: FUNC
870 */
871 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageRemovedNormal, TestSize.Level1)
872 {
873 // enable normal admin with userId = 100 and 101
874 AppExecFwk::ElementName admin;
875 admin.SetBundleName(ADMIN_PACKAGENAME);
876 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
877 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
878 EnableAdminSuc(admin, AdminType::NORMAL, TEST_USER_ID);
879 // remove normal admin under userId = 101
880 EventFwk::CommonEventData data;
881 AAFwk::Want want;
882 want.SetElementName(admin.GetBundleName(), admin.GetAbilityName());
883 want.SetParam(AppExecFwk::Constants::USER_ID, TEST_USER_ID);
884 data.SetWant(want);
885 edmMgr_->OnCommonEventPackageRemoved(data);
886 // get naormal admin under userId = 100 and 101
887 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID) != nullptr);
888 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), TEST_USER_ID) == nullptr);
889 // remove normal admin under userId = 100
890 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
891 data.SetWant(want);
892 edmMgr_->OnCommonEventPackageRemoved(data);
893 // get naormal admin under userId = 100 and 101
894 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID) == nullptr);
895 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), TEST_USER_ID) == nullptr);
896 }
897
898 /**
899 * @tc.name: TestOnCommonEventPackageRemovedSub
900 * @tc.desc: Test OnCommonEventPackageRemoved sub super admin func.
901 * @tc.type: FUNC
902 */
903 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageRemovedSub, TestSize.Level1)
904 {
905 // enable super admin
906 AppExecFwk::ElementName superAdmin;
907 superAdmin.SetBundleName(ADMIN_PACKAGENAME);
908 superAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
909 EnableAdminSuc(superAdmin, AdminType::ENT, DEFAULT_USER_ID);
910 // authorize sub-super admin
911 std::string subSuperAdmin = ADMIN_PACKAGENAME_1;
912 AuthorizeAdminSuc(superAdmin, subSuperAdmin);
913 // sub-super admin set policy with userId = 100 and 101
914 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
915 PluginManager::GetInstance()->AddPlugin(plugin);
916 SetPolicy(subSuperAdmin, plugin->GetPolicyName());
917
918 // remove sub-super admin under userId = 101
919 EventFwk::CommonEventData data;
920 AAFwk::Want want;
921 want.SetBundle(subSuperAdmin);
922 want.SetParam(AppExecFwk::Constants::USER_ID, TEST_USER_ID);
923 data.SetWant(want);
924 edmMgr_->OnCommonEventPackageRemoved(data);
925 // get sub-super admin
926 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(subSuperAdmin, DEFAULT_USER_ID) != nullptr);
927 // get sub-super admin policy of sub-super admin with userId = 101
928 GetPolicySuccess(TEST_USER_ID, subSuperAdmin, plugin->GetPolicyName());
929 // get sub-super admin policy of sub-super admin with userId = 100
930 GetPolicySuccess(DEFAULT_USER_ID, subSuperAdmin, plugin->GetPolicyName());
931
932 // remove sub-super admin under userId = 100
933 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
934 data.SetWant(want);
935 edmMgr_->OnCommonEventPackageRemoved(data);
936 // get sub-super admin
937 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(subSuperAdmin, DEFAULT_USER_ID) == nullptr);
938 // get sub-super admin policy of sub-super admin with userId = 101
939 GetPolicyFailed(TEST_USER_ID, subSuperAdmin, plugin->GetPolicyName());
940 // get sub-super admin policy of sub-super admin with userId = 100
941 GetPolicyFailed(DEFAULT_USER_ID, subSuperAdmin, plugin->GetPolicyName());
942 // disable super admin
943 DisableSuperAdminSuc(superAdmin.GetBundleName());
944 }
945
946 /**
947 * @tc.name: TestOnCommonEventPackageRemovedEnt
948 * @tc.desc: Test OnCommonEventPackageRemoved super admin func.
949 * @tc.type: FUNC
950 */
951 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageRemovedEnt, TestSize.Level1)
952 {
953 // enable super admin
954 AppExecFwk::ElementName superAdmin;
955 superAdmin.SetBundleName(ADMIN_PACKAGENAME);
956 superAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
957 EnableAdminSuc(superAdmin, AdminType::ENT, DEFAULT_USER_ID);
958 // authorize sub-super admin
959 std::string subSuperAdmin = ADMIN_PACKAGENAME_1;
960 AuthorizeAdminSuc(superAdmin, subSuperAdmin);
961 // set policy with userId = 100 and 101
962 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
963 PluginManager::GetInstance()->AddPlugin(plugin);
964 SetPolicy(superAdmin.GetBundleName(), plugin->GetPolicyName());
965 SetPolicy(subSuperAdmin, plugin->GetPolicyName());
966
967 // remove super admin under userId = 101
968 EventFwk::CommonEventData data;
969 AAFwk::Want want;
970 want.SetElementName(superAdmin.GetBundleName(), superAdmin.GetAbilityName());
971 want.SetParam(AppExecFwk::Constants::USER_ID, TEST_USER_ID);
972 data.SetWant(want);
973 edmMgr_->OnCommonEventPackageRemoved(data);
974 // get sub-super admin and super admin
975 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(superAdmin.GetBundleName(), DEFAULT_USER_ID) != nullptr);
976 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(subSuperAdmin, DEFAULT_USER_ID) != nullptr);
977 // get policy of super and sub-super admin with userId = 101
978 GetPolicySuccess(TEST_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
979 GetPolicySuccess(TEST_USER_ID, subSuperAdmin, plugin->GetPolicyName());
980 // get policy of super and sub-super admin with userId = 100
981 GetPolicySuccess(DEFAULT_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
982 GetPolicySuccess(DEFAULT_USER_ID, subSuperAdmin, plugin->GetPolicyName());
983
984 // remove super under userId = 100
985 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
986 data.SetWant(want);
987 edmMgr_->OnCommonEventPackageRemoved(data);
988 // get sub-super admin and super admin
989 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(superAdmin.GetBundleName(), DEFAULT_USER_ID) == nullptr);
990 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(subSuperAdmin, DEFAULT_USER_ID) == nullptr);
991 // get policy of super and sub-super admin with userId = 100
992 GetPolicyFailed(DEFAULT_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
993 GetPolicyFailed(DEFAULT_USER_ID, subSuperAdmin, plugin->GetPolicyName());
994 // get policy of super and sub-super admin with userId = 101
995 GetPolicyFailed(TEST_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
996 GetPolicyFailed(TEST_USER_ID, subSuperAdmin, plugin->GetPolicyName());
997 }
998
999 /**
1000 * @tc.name: TestOnCommonEventPackageChangedWithoutAdmin
1001 * @tc.desc: Test OnCommonEventPackageChanged without admin func.
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageChangedWithoutAdmin, TestSize.Level1)
1005 {
1006 AppExecFwk::ElementName admin;
1007 admin.SetBundleName(ADMIN_PACKAGENAME);
1008 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1009
1010 EventFwk::CommonEventData data;
1011 AAFwk::Want want;
1012 want.SetElementName(admin.GetBundleName(), admin.GetAbilityName());
1013 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
1014 data.SetWant(want);
1015 edmMgr_->OnCommonEventPackageChanged(data);
1016 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID) == nullptr);
1017 }
1018
1019 /**
1020 * @tc.name: TestOnCommonEventPackageChangedWithNormalAdmin
1021 * @tc.desc: Test OnCommonEventPackageChanged with normal admin func.
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageChangedWithNormalAdmin, TestSize.Level1)
1025 {
1026 AppExecFwk::ElementName admin;
1027 admin.SetBundleName(ADMIN_PACKAGENAME);
1028 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1029 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
1030
1031 EventFwk::CommonEventData data;
1032 AAFwk::Want want;
1033 want.SetElementName(admin.GetBundleName(), admin.GetAbilityName());
1034 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
1035 data.SetWant(want);
1036 edmMgr_->OnCommonEventPackageChanged(data);
1037 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID) != nullptr);
1038
1039 DisableAdminSuc(admin, DEFAULT_USER_ID);
1040 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1041 EXPECT_TRUE(normalAdmin == nullptr);
1042 }
1043
1044 /**
1045 * @tc.name: TestOnCommonEventPackageChangedWithSuperAdmin
1046 * @tc.desc: Test OnCommonEventPackageChanged with super admin func.
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageChangedWithSuperAdmin, TestSize.Level1)
1050 {
1051 AppExecFwk::ElementName admin;
1052 admin.SetBundleName(ADMIN_PACKAGENAME);
1053 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1054 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1055
1056 EventFwk::CommonEventData data;
1057 AAFwk::Want want;
1058 want.SetElementName(admin.GetBundleName(), admin.GetAbilityName());
1059 want.SetParam(AppExecFwk::Constants::USER_ID, DEFAULT_USER_ID);
1060 data.SetWant(want);
1061 edmMgr_->OnCommonEventPackageChanged(data);
1062 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID) != nullptr);
1063
1064 DisableSuperAdminSuc(admin.GetBundleName());
1065 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1066 EXPECT_TRUE(superAdmin == nullptr);
1067 }
1068
1069 /**
1070 * @tc.name: TestdisableSuperAdminWithPolicy
1071 * @tc.desc: Test disableSuperAdmin super admin func.
1072 * @tc.type: FUNC
1073 */
1074 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestdisableSuperAdminWithPolicy, TestSize.Level1)
1075 {
1076 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1077 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1078 // enable super admin
1079 AppExecFwk::ElementName superAdmin;
1080 superAdmin.SetBundleName(ADMIN_PACKAGENAME);
1081 superAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1082 EnableAdminSuc(superAdmin, AdminType::ENT, DEFAULT_USER_ID);
1083 // authorize sub-super admin
1084 std::string subSuperAdmin = ADMIN_PACKAGENAME_1;
1085 AuthorizeAdminSuc(superAdmin, subSuperAdmin);
1086 // set policy with userId = 100 and 101
1087 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
1088 PluginManager::GetInstance()->AddPlugin(plugin);
1089 SetPolicy(superAdmin.GetBundleName(), plugin->GetPolicyName());
1090 SetPolicy(subSuperAdmin, plugin->GetPolicyName());
1091 // disable super admin
1092 DisableSuperAdminSuc(superAdmin.GetBundleName());
1093 // get sub-super admin and super admin
1094 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(superAdmin.GetBundleName(), DEFAULT_USER_ID) == nullptr);
1095 ASSERT_TRUE(edmMgr_->adminMgr_->GetAdminByPkgName(subSuperAdmin, DEFAULT_USER_ID) == nullptr);
1096 // get policy of sub-super admin with userId = 101
1097 GetPolicyFailed(TEST_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
1098 GetPolicyFailed(TEST_USER_ID, subSuperAdmin, plugin->GetPolicyName());
1099 // get policy of sub-super admin with userId = 100
1100 GetPolicyFailed(DEFAULT_USER_ID, superAdmin.GetBundleName(), plugin->GetPolicyName());
1101 GetPolicyFailed(DEFAULT_USER_ID, subSuperAdmin, plugin->GetPolicyName());
1102 }
1103
1104 /**
1105 * @tc.name: TestAuthorizeAdminWithoutPermisson
1106 * @tc.desc: Test TestAuthorizeAdmin without permission func.
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminWithoutPermisson, TestSize.Level1)
1110 {
1111 AppExecFwk::ElementName admin;
1112 admin.SetBundleName(ADMIN_PACKAGENAME);
1113 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1114 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1115
1116 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
1117 ErrCode ret = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
1118
1119 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
1120 DisableSuperAdminSuc(admin.GetBundleName());
1121 }
1122
1123 /**
1124 * @tc.name: TestAuthorizeAdminWithoutAdmin
1125 * @tc.desc: Test TestAuthorizeAdmin without administrator.
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminWithoutAdmin, TestSize.Level1)
1129 {
1130 AppExecFwk::ElementName admin;
1131 admin.SetBundleName(ADMIN_PACKAGENAME);
1132 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1133
1134 ErrCode ret = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
1135 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
1136 }
1137
1138 /**
1139 * @tc.name: TestAuthorizeAdminWithoutSDA
1140 * @tc.desc: Test TestAuthorizeAdmin without administrator.
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminWithoutSDA, TestSize.Level1)
1144 {
1145 AppExecFwk::ElementName admin;
1146 admin.SetBundleName(ADMIN_PACKAGENAME);
1147 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1148 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
1149
1150 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1151 std::vector<int32_t> ids = {DEFAULT_USER_ID};
1152 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
1153 Return(ERR_OK)));
1154
1155 ErrCode ret = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
1156 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
1157
1158 DisableAdminSuc(admin, DEFAULT_USER_ID);
1159 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1160 EXPECT_TRUE(normalAdmin == nullptr);
1161 }
1162
1163 /**
1164 * @tc.name: TestAuthorizeAdminIpcFail
1165 * @tc.desc: Test AuthorizeAdmin ipc fail func.
1166 * @tc.type: FUNC
1167 */
1168 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminIpcFail, TestSize.Level1)
1169 {
1170 AppExecFwk::ElementName admin;
1171 admin.SetBundleName(ADMIN_PACKAGENAME);
1172 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1173 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1174
1175 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1176 std::vector<int32_t> ids = {DEFAULT_USER_ID};
1177 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
1178 Return(ERR_OK)));
1179 ErrCode res = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
1180 EXPECT_TRUE(res == ERR_OK);
1181
1182 DisableSuperAdminSuc(admin.GetBundleName());
1183 std::shared_ptr<Admin> superAdmin;
1184 EXPECT_TRUE(FAILED(edmMgr_->adminMgr_->GetSubOrSuperOrByodAdminByPkgName(admin.GetBundleName(), superAdmin)));
1185 }
1186
1187 /**
1188 * @tc.name: TestAuthorizeAdminWithoutReq
1189 * @tc.desc: Test AuthorizeAdmin without request permission.
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminWithoutReq, TestSize.Level1)
1193 {
1194 AppExecFwk::ElementName admin;
1195 admin.SetBundleName(ADMIN_PACKAGENAME);
1196 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1197 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1198
1199 std::vector<int32_t> ids = {DEFAULT_USER_ID};
1200 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1201 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
1202 Return(ERR_OK)));
1203 GetBundleInfoMock(false, "");
1204 ErrCode ret = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
1205 EXPECT_TRUE(ret == EdmReturnErrCode::AUTHORIZE_PERMISSION_FAILED);
1206
1207 DisableSuperAdminSuc(admin.GetBundleName());
1208 std::shared_ptr<Admin> superAdmin;
1209 EXPECT_TRUE(FAILED(edmMgr_->adminMgr_->GetSubOrSuperOrByodAdminByPkgName(admin.GetBundleName(), superAdmin)));
1210 }
1211
1212 /**
1213 * @tc.name: TestAuthorizeAdminSuc
1214 * @tc.desc: Test AuthorizeAdmin success.
1215 * @tc.type: FUNC
1216 */
1217 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAuthorizeAdminSuc, TestSize.Level1)
1218 {
1219 AppExecFwk::ElementName admin;
1220 admin.SetBundleName(ADMIN_PACKAGENAME);
1221 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1222 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1223
1224 AuthorizeAdminSuc(admin, ADMIN_PACKAGENAME_1);
1225
1226 DisableSuperAdminSuc(admin.GetBundleName());
1227 std::shared_ptr<Admin> subOrSuperAdmin;
1228 EXPECT_TRUE(FAILED(edmMgr_->adminMgr_->GetSubOrSuperOrByodAdminByPkgName(ADMIN_PACKAGENAME_1, subOrSuperAdmin)));
1229 EXPECT_TRUE(FAILED(edmMgr_->adminMgr_->GetSubOrSuperOrByodAdminByPkgName(admin.GetAbilityName(), subOrSuperAdmin)));
1230 }
1231
1232 /**
1233 * @tc.name: TestRemoveAdminAndAdminPolicy
1234 * @tc.desc: Test RemoveAdminAndAdminPolicy success.
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveAdminAndAdminPolicy, TestSize.Level1)
1238 {
1239 AppExecFwk::ElementName admin;
1240 admin.SetBundleName(ADMIN_PACKAGENAME);
1241 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1242 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1243 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveAdminAndAdminPolicy(admin.GetBundleName(), DEFAULT_USER_ID)));
1244 std::shared_ptr<Admin> superAdmin;
1245 EXPECT_TRUE(FAILED(edmMgr_->adminMgr_->GetSubOrSuperOrByodAdminByPkgName(admin.GetBundleName(), superAdmin)));
1246
1247 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
1248 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveAdminAndAdminPolicy(admin.GetBundleName(), DEFAULT_USER_ID)));
1249 auto normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1250 EXPECT_TRUE(normalAdmin == nullptr);
1251 }
1252
1253 /**
1254 * @tc.name: TestRemoveAdminPolicy
1255 * @tc.desc: Test RemoveAdminPolicy success.
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveAdminPolicy, TestSize.Level1)
1259 {
1260 AppExecFwk::ElementName admin;
1261 admin.SetBundleName(ADMIN_PACKAGENAME);
1262 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1263 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1264
1265 // set policy with userId = 100 and 101
1266 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
1267 PluginManager::GetInstance()->AddPlugin(plugin);
1268 SetPolicy(admin.GetBundleName(), plugin->GetPolicyName());
1269
1270 // remove policy with userId = 101
1271 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveAdminPolicy(admin.GetBundleName(), TEST_USER_ID)));
1272 GetPolicyFailed(TEST_USER_ID, admin.GetBundleName(), plugin->GetPolicyName());
1273 GetPolicySuccess(DEFAULT_USER_ID, admin.GetBundleName(), plugin->GetPolicyName());
1274 }
1275
1276 /**
1277 * @tc.name: TestRemoveSubSuperAdminAndAdminPolicy
1278 * @tc.desc: Test RemoveSubSuperAdminAndAdminPolicy success.
1279 * @tc.type: FUNC
1280 */
1281 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveSubSuperAdminAndAdminPolicy, TestSize.Level1)
1282 {
1283 AppExecFwk::ElementName admin;
1284 admin.SetBundleName(ADMIN_PACKAGENAME);
1285 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1286 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1287
1288 string subSuperBundleName = ADMIN_PACKAGENAME_1;
1289 AuthorizeAdminSuc(admin, subSuperBundleName);
1290 // set policy with userId = 100 and 101
1291 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
1292 PluginManager::GetInstance()->AddPlugin(plugin);
1293 SetPolicy(subSuperBundleName, plugin->GetPolicyName());
1294
1295 // remove policy with userId = 100
1296 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveSubSuperAdminAndAdminPolicy(subSuperBundleName)));
1297
1298 auto superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(subSuperBundleName, DEFAULT_USER_ID);
1299 EXPECT_TRUE(superAdmin == nullptr);
1300 superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(subSuperBundleName, TEST_USER_ID);
1301 EXPECT_TRUE(superAdmin == nullptr);
1302 EXPECT_FALSE(edmMgr_->adminMgr_->IsSuperOrSubSuperAdmin(subSuperBundleName));
1303 }
1304
1305 /**
1306 * @tc.name: TestRemoveSuperAdminAndAdminPolicy
1307 * @tc.desc: Test RemoveSuperAdminAndAdminPolicy success.
1308 * @tc.type: FUNC
1309 */
1310 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveSuperAdminAndAdminPolicy, TestSize.Level1)
1311 {
1312 AppExecFwk::ElementName admin;
1313 admin.SetBundleName(ADMIN_PACKAGENAME);
1314 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1315 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1316
1317 // set policy with userId = 100 and 101
1318 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
1319 PluginManager::GetInstance()->AddPlugin(plugin);
1320 SetPolicy(admin.GetBundleName(), plugin->GetPolicyName());
1321
1322 // remove policy with userId = 100
1323 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveSubSuperAdminAndAdminPolicy(admin.GetBundleName())));
1324
1325 auto superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1326 EXPECT_TRUE(superAdmin == nullptr);
1327 superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), TEST_USER_ID);
1328 EXPECT_TRUE(superAdmin == nullptr);
1329 bool isSuper = true;
1330 edmMgr_->IsSuperAdmin(admin.GetBundleName(), isSuper);
1331 EXPECT_FALSE(isSuper);
1332 }
1333
1334 /**
1335 * @tc.name: TestRemoveSubOrSuperAdminAndAdminPolicy
1336 * @tc.desc: Test RemoveSubOrSuperAdminAndAdminPolicy success.
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveSubOrSuperAdminAndAdminPolicy, TestSize.Level1)
1340 {
1341 AppExecFwk::ElementName admin;
1342 admin.SetBundleName(ADMIN_PACKAGENAME);
1343 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1344 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1345
1346 // set policy with userId = 100 and 101
1347 auto plugin = PLUGIN::StringTestPlugin::GetPlugin();
1348 PluginManager::GetInstance()->AddPlugin(plugin);
1349 SetPolicy(admin.GetBundleName(), plugin->GetPolicyName());
1350
1351 std::vector<int32_t> userIds{TEST_USER_ID};
1352 // remove policy with userId = 100
1353 EXPECT_TRUE(SUCCEEDED(edmMgr_->RemoveSubOrSuperAdminAndAdminPolicy(admin.GetBundleName(), userIds)));
1354
1355 auto superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
1356 EXPECT_TRUE(superAdmin == nullptr);
1357 superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), TEST_USER_ID);
1358 EXPECT_TRUE(superAdmin == nullptr);
1359 EXPECT_FALSE(edmMgr_->adminMgr_->IsSuperAdmin(admin.GetBundleName()));
1360 }
1361
1362 /**
1363 * @tc.name: TestEnableAmdinCallingPermissionFailed
1364 * @tc.desc: Test EnabldeAdmin func with verify calling permission failed.
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAmdinCallingPermissionFailed, TestSize.Level1)
1368 {
1369 AppExecFwk::ElementName admin;
1370 admin.SetBundleName(ADMIN_PACKAGENAME);
1371 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1372 EntInfo entInfo("test", "this is test");
1373
1374 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1375 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
1376
1377 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, 0);
1378 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
1379 }
1380
1381 /**
1382 * @tc.name: TestEnabaleAdminQueryExtensionAbilityInfosFailed
1383 * @tc.desc: Test EnabledAdmin func with query extension abilityInfos failed.
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleAdminQueryExtensionAbilityInfosFailed, TestSize.Level1)
1387 {
1388 AppExecFwk::ElementName admin;
1389 admin.SetBundleName(ADMIN_PACKAGENAME);
1390 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1391 EntInfo entInfo("test", "this is test");
1392
1393 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1394 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1395 QueryExtensionAbilityInfosMock(false, "");
1396
1397 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, 1);
1398 EXPECT_TRUE(res == EdmReturnErrCode::COMPONENT_INVALID);
1399 }
1400
1401 /**
1402 * @tc.name: TestEnabaleAdminQueryExtensionAbilityInfosEmpty
1403 * @tc.desc: Test EnabledAdmin func with query extension abilityInfos empty.
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleAdminQueryExtensionAbilityInfosEmpty, TestSize.Level1)
1407 {
1408 AppExecFwk::ElementName admin;
1409 admin.SetBundleName(ADMIN_PACKAGENAME);
1410 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1411 EntInfo entInfo("test", "this is test");
1412
1413 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1414 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1415 QueryExtensionAbilityInfosMock(true, "", true);
1416
1417 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, 1);
1418 EXPECT_TRUE(res == EdmReturnErrCode::COMPONENT_INVALID);
1419 }
1420
1421 /**
1422 * @tc.name: TestEnabaleSuperWithErrorUserId
1423 * @tc.desc: Test enabled super admin with userId = 101.
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleSuperWithErrorUserId, TestSize.Level1)
1427 {
1428 AppExecFwk::ElementName admin;
1429 admin.SetBundleName(ADMIN_PACKAGENAME);
1430 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1431 EntInfo entInfo("test", "this is test");
1432
1433 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1434 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1435 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1436
1437 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, TEST_USER_ID);
1438 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1439 }
1440
1441 /**
1442 * @tc.name: TestEnabaleSuperAdminToNormalAdmin
1443 * @tc.desc: Test enabled super admin to normal admin.
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleSuperAdminToNormalAdmin, TestSize.Level1)
1447 {
1448 AppExecFwk::ElementName admin;
1449 admin.SetBundleName(ADMIN_PACKAGENAME);
1450 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1451 EntInfo entInfo("test", "this is test");
1452 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1453
1454 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1455 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1456 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1457
1458 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
1459 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1460
1461 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
1462 }
1463
1464 /**
1465 * @tc.name: TestEnabaleSuperAdminToOtherUserId
1466 * @tc.desc: Test enabled super admin to other user id.
1467 * @tc.type: FUNC
1468 */
1469 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleSuperAdminToOtherUserId, TestSize.Level1)
1470 {
1471 AppExecFwk::ElementName admin;
1472 admin.SetBundleName(ADMIN_PACKAGENAME);
1473 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1474 EntInfo entInfo("test", "this is test");
1475 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1476
1477 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1478 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1479 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1480
1481 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, TEST_USER_ID);
1482 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1483
1484 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
1485 }
1486
1487 /**
1488 * @tc.name: TestEnabaleSuperAdminWithOtherEntInfo
1489 * @tc.desc: Test enabled super admin with other entInfo.
1490 * @tc.type: FUNC
1491 */
1492 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleSuperAdminWithOtherEntInfo, TestSize.Level1)
1493 {
1494 AppExecFwk::ElementName admin;
1495 admin.SetBundleName(ADMIN_PACKAGENAME);
1496 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1497 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1498
1499 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1500 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1501 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1502 GetBundleInfoMock(true, "");
1503
1504 EntInfo entInfo("test1", "this is test1");
1505 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1506 EXPECT_TRUE(res == ERR_OK);
1507
1508 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
1509 }
1510
1511 /**
1512 * @tc.name: TestEnabaleMultipleSuperAdmin
1513 * @tc.desc: Test enabled two super admin.
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleMultipleSuperAdmin, TestSize.Level1)
1517 {
1518 AppExecFwk::ElementName admin;
1519 admin.SetBundleName(ADMIN_PACKAGENAME);
1520 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1521 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1522
1523 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1524 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1525 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1526
1527 admin.SetBundleName(ADMIN_PACKAGENAME_1);
1528 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
1529 EntInfo entInfo("test", "this is test");
1530 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1531 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1532
1533 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
1534 }
1535
1536 /**
1537 * @tc.name: TestEnabaleSuperAdminWithOtherAbility
1538 * @tc.desc: Test enabled super admin with other ability.
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnabaleSuperAdminWithOtherAbility, TestSize.Level1)
1542 {
1543 AppExecFwk::ElementName admin;
1544 admin.SetBundleName(ADMIN_PACKAGENAME);
1545 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1546 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1547
1548 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1549 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1550 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1551 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
1552 EntInfo entInfo("test", "this is test");
1553 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1554 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1555
1556 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
1557 }
1558
1559 /**
1560 * @tc.name: TestGetAllPermissionsByAdminFail
1561 * @tc.desc: Test GetAllPermissionsByAdminFail func.
1562 * @tc.type: FUNC
1563 */
1564 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetAllPermissionsByAdminFail, TestSize.Level1)
1565 {
1566 AppExecFwk::ElementName admin;
1567 admin.SetBundleName(ADMIN_PACKAGENAME);
1568 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1569 EntInfo entInfo("test", "this is test");
1570
1571 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1572 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1573 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1574 GetBundleInfoMock(false, "");
1575
1576 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, 0);
1577 EXPECT_TRUE(res == EdmReturnErrCode::COMPONENT_INVALID);
1578 }
1579
1580 /**
1581 * @tc.name: TestEnableAdminWithQueryExtensionAdbilityInfosEmptyBundleName
1582 * @tc.desc: Test EnableAdmin with QueryExtensionAdbilityInfos return empty bundleName.
1583 * @tc.type: FUNC
1584 */
1585 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithQueryExtensionAdbilityInfosEmptyBundleName, TestSize.Level1)
1586 {
1587 AppExecFwk::ElementName admin;
1588 admin.SetBundleName(ADMIN_PACKAGENAME);
1589 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1590 EntInfo entInfo("test", "this is test");
1591
1592 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1593 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1594 QueryExtensionAbilityInfosMock(true, "");
1595 GetBundleInfoMock(true, "");
1596
1597 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
1598 EXPECT_TRUE(res == ERR_OK);
1599
1600 bool isEnable;
1601 edmMgr_->IsAdminEnabled(admin, DEFAULT_USER_ID, isEnable);
1602 EXPECT_TRUE(!isEnable);
1603
1604 res = edmMgr_->DisableAdmin(admin, DEFAULT_USER_ID);
1605 EXPECT_TRUE(res != ERR_OK);
1606
1607 AppExecFwk::ElementName admin1;
1608 admin1.SetBundleName("");
1609 admin1.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1610 res = edmMgr_->DisableAdmin(admin1, DEFAULT_USER_ID);
1611 EXPECT_TRUE(res == ERR_OK);
1612 }
1613
1614 /**
1615 * @tc.name: TestEnableNormalAdminWithDefaultUserId
1616 * @tc.desc: Test enable normal admin with userId = 100.
1617 * @tc.type: FUNC
1618 */
1619 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableNormalAdminWithDefaultUserId, TestSize.Level1)
1620 {
1621 AppExecFwk::ElementName admin;
1622 admin.SetBundleName(ADMIN_PACKAGENAME);
1623 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1624 EntInfo entInfo("test", "this is test");
1625
1626 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1627 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1628 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1629 GetBundleInfoMock(true, EDM_TEST_PERMISSION);
1630
1631 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
1632 EXPECT_TRUE(res == ERR_OK);
1633
1634 bool isEnable;
1635 edmMgr_->IsAdminEnabled(admin, DEFAULT_USER_ID, isEnable);
1636 EXPECT_TRUE(isEnable);
1637
1638 res = edmMgr_->DisableAdmin(admin, DEFAULT_USER_ID);
1639 EXPECT_TRUE(res == ERR_OK);
1640 }
1641
1642 /**
1643 * @tc.name: TestEnableAdminWithPermissionEmpty
1644 * @tc.desc: Test EnableAdmin permission empty func.
1645 * @tc.type: FUNC
1646 */
1647 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithPermissionEmpty, TestSize.Level1)
1648 {
1649 AppExecFwk::ElementName admin;
1650 admin.SetBundleName(ADMIN_PACKAGENAME);
1651 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1652 EntInfo entInfo("test", "this is test");
1653
1654 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1655 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1656 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1657 GetBundleInfoMock(true, "");
1658 std::vector<int32_t> ids = {DEFAULT_USER_ID};
1659 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
1660 Return(ERR_OK)));
1661
1662 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
1663 EXPECT_TRUE(res == ERR_OK);
1664
1665 std::vector<std::string> enabledAdminList;
1666 edmMgr_->GetEnabledAdmin(AdminType::NORMAL, enabledAdminList); // normal admin not empty
1667 EXPECT_FALSE(enabledAdminList.empty());
1668
1669 bool isEnable;
1670 edmMgr_->IsAdminEnabled(admin, DEFAULT_USER_ID, isEnable);
1671 EXPECT_TRUE(isEnable);
1672
1673 edmMgr_->IsSuperAdmin(admin.GetBundleName(), isEnable);
1674 EXPECT_TRUE(!isEnable);
1675
1676 res = edmMgr_->DisableAdmin(admin, DEFAULT_USER_ID);
1677 EXPECT_TRUE(res == ERR_OK);
1678
1679 res = edmMgr_->DisableSuperAdmin(admin.GetBundleName());
1680 EXPECT_TRUE(res != ERR_OK);
1681 }
1682
1683 /**
1684 * @tc.name: TestDisableSuperAdminTwoAdmin
1685 * @tc.desc: Test DisableSuperAdmin Two Admin func.
1686 * @tc.type: FUNC
1687 */
1688 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestDisableSuperAdminTwoAdmin, TestSize.Level1)
1689 {
1690 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1691 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1692
1693 std::vector<std::u16string> args;
1694 ErrCode res = edmMgr_->Dump(-1, args);
1695 EXPECT_TRUE(res != ERR_OK);
1696 res = TestDump(); // empty
1697 EXPECT_TRUE(res == ERR_OK);
1698
1699 AppExecFwk::ElementName admin;
1700 admin.SetBundleName(ADMIN_PACKAGENAME);
1701 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1702 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1703
1704 bool isSuper;
1705 edmMgr_->IsSuperAdmin(admin.GetBundleName(), isSuper);
1706 EXPECT_TRUE(isSuper);
1707
1708 res = TestDump(); // not empty
1709 EXPECT_TRUE(res == ERR_OK);
1710 Utils::ExecCmdSync("rm -f /data/edmDumpTest.txt");
1711
1712 // other admin
1713 AppExecFwk::ElementName admin1;
1714 admin1.SetBundleName(ADMIN_PACKAGENAME_1);
1715 admin1.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
1716 EnableAdminSuc(admin1, AdminType::NORMAL, DEFAULT_USER_ID);
1717
1718 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1719 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1720 res = edmMgr_->DisableSuperAdmin(admin1.GetBundleName());
1721 EXPECT_TRUE(res == EdmReturnErrCode::DISABLE_ADMIN_FAILED);
1722
1723 DisableAdminSuc(admin1, DEFAULT_USER_ID);
1724
1725 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
1726 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1727 res = edmMgr_->DisableAdmin(admin, DEFAULT_USER_ID); // admintype is super
1728 EXPECT_TRUE(res == ERR_OK);
1729 }
1730
1731 /**
1732 * @tc.name: TestDisableSuperAdminIpcSuc
1733 * @tc.desc: Test DisableSuperAdmin Ipc Suc func.
1734 * @tc.type: FUNC
1735 */
1736 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestDisableSuperAdminIpcSuc, TestSize.Level1)
1737 {
1738 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillRepeatedly(DoAll(Return(false)));
1739 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
1740
1741 AppExecFwk::ElementName admin;
1742 admin.SetBundleName(ADMIN_PACKAGENAME);
1743 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1744 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1745 bool isSuper = false;
1746 edmMgr_->IsSuperAdmin(admin.GetBundleName(), isSuper);
1747 EXPECT_TRUE(isSuper);
1748 DisableSuperAdminSuc(admin.GetBundleName());
1749 }
1750
1751 /**
1752 * @tc.name: TestEnableNormalAdminToDebug
1753 * @tc.desc: Test hdc enable normal admin to debug.
1754 * @tc.type: FUNC
1755 */
1756 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableNormalAdminToDebug, TestSize.Level1)
1757 {
1758 // enable normal admin
1759 AppExecFwk::ElementName admin;
1760 admin.SetBundleName(ADMIN_PACKAGENAME);
1761 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1762 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
1763 // shell enable debug admin
1764 EntInfo entInfo("test", "this is test");
1765 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1766 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(true)));
1767 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1768 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1769 // disable normal admin
1770 DisableAdminSuc(admin, DEFAULT_USER_ID);
1771 }
1772
1773 /**
1774 * @tc.name: TestEnableSuperAdminToDebug
1775 * @tc.desc: Test hdc enable super admin to debug.
1776 * @tc.type: FUNC
1777 */
1778 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableSuperAdminToDebug, TestSize.Level1)
1779 {
1780 // enable super admin
1781 AppExecFwk::ElementName admin;
1782 admin.SetBundleName(ADMIN_PACKAGENAME);
1783 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1784 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1785 // shell enable debug admin
1786 EntInfo entInfo("test", "this is test");
1787 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
1788 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(true)));
1789 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1790 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1791 // disable normal admin
1792 DisableSuperAdminSuc(admin.GetBundleName());
1793 }
1794
1795 /**
1796 * @tc.name: TestEnableDebugSuperAdmin
1797 * @tc.desc: Test enable debug super admin.
1798 * @tc.type: FUNC
1799 */
1800 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableDebugSuperAdmin, TestSize.Level1)
1801 {
1802 // enable super admin except success
1803 AppExecFwk::ElementName admin;
1804 admin.SetBundleName(ADMIN_PACKAGENAME);
1805 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1806 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1807 // hdc enable debug super admin1 except fail
1808 AppExecFwk::ElementName admin1;
1809 admin1.SetBundleName(ADMIN_PACKAGENAME_1);
1810 admin1.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
1811 QueryExtensionAbilityInfosMock(true, admin1.GetBundleName());
1812 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(true)));
1813 EntInfo entInfo("test", "this is test");
1814 ErrCode res = edmMgr_->EnableAdmin(admin1, entInfo, AdminType::ENT, DEFAULT_USER_ID);
1815 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
1816 // disable super admin
1817 DisableSuperAdminSuc(admin.GetBundleName());
1818 }
1819
1820 /**
1821 * @tc.name: TestHdcDisableNormalAdmin
1822 * @tc.desc: Test hdc disable normal admin.
1823 * @tc.type: FUNC
1824 */
1825 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHdcDisableNormalAdmin, TestSize.Level1)
1826 {
1827 // enable normal admin
1828 AppExecFwk::ElementName admin;
1829 admin.SetBundleName(ADMIN_PACKAGENAME);
1830 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1831 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
1832 // hdc disable normal admin
1833 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(true)));
1834 ErrCode res = edmMgr_->DisableSuperAdmin(admin.GetBundleName());
1835 EXPECT_TRUE(res == EdmReturnErrCode::DISABLE_ADMIN_FAILED);
1836 // disable normal admin
1837 DisableAdminSuc(admin, DEFAULT_USER_ID);
1838 }
1839
1840 /**
1841 * @tc.name: TestHdcDisableSuperAdmin
1842 * @tc.desc: Test hdc disable super admin.
1843 * @tc.type: FUNC
1844 */
1845 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHdcDisableSuperAdmin, TestSize.Level1)
1846 {
1847 // enable super admin
1848 AppExecFwk::ElementName admin;
1849 admin.SetBundleName(ADMIN_PACKAGENAME);
1850 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1851 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1852 // hdc disable super admin
1853 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(true)));
1854 ErrCode res = edmMgr_->DisableSuperAdmin(admin.GetBundleName());
1855 EXPECT_TRUE(res == EdmReturnErrCode::DISABLE_ADMIN_FAILED);
1856 // disable super admin
1857 DisableSuperAdminSuc(admin.GetBundleName());
1858 }
1859
1860 /**
1861 * @tc.name: TestDisableDebugSuperAdmin
1862 * @tc.desc: Test disable debug super admin with debug = false.
1863 * @tc.type: FUNC
1864 */
1865 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestDisableDebugSuperAdmin, TestSize.Level1)
1866 {
1867 // hdc enbale debug super admin
1868 AppExecFwk::ElementName admin;
1869 admin.SetBundleName(ADMIN_PACKAGENAME);
1870 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1871 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID, true);
1872 // disable debug super admin
1873 DisableSuperAdminSuc(admin.GetBundleName());
1874 }
1875
1876 /**
1877 * @tc.name: TestSetEnterpriseInfoWithoutPermission
1878 * @tc.desc: Test SetEnterpriseInfo func.
1879 * @tc.type: FUNC
1880 */
1881 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetEnterpriseInfoWithoutPermission, TestSize.Level1)
1882 {
1883 AppExecFwk::ElementName admin;
1884 admin.SetBundleName(ADMIN_PACKAGENAME);
1885 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1886
1887 EntInfo entInfoResult;
1888 ErrCode res = edmMgr_->GetEnterpriseInfo(admin, entInfoResult);
1889 EXPECT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
1890
1891 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1892 EntInfo entInfo("test", "this is test");
1893 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
1894 res = edmMgr_->SetEnterpriseInfo(admin, entInfo);
1895 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
1896 DisableSuperAdminSuc(admin.GetBundleName());
1897 }
1898
1899 /**
1900 * @tc.name: TestSetEnterpriseInfoWithoutActiveAdmin
1901 * @tc.desc: Test SetEnterpriseInfo func.
1902 * @tc.type: FUNC
1903 */
1904 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetEnterpriseInfoWithoutActiveAdmin, TestSize.Level1)
1905 {
1906 AppExecFwk::ElementName admin;
1907 admin.SetBundleName(ADMIN_PACKAGENAME);
1908 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1909
1910 EntInfo entInfoResult;
1911 ErrCode res = edmMgr_->GetEnterpriseInfo(admin, entInfoResult);
1912 EXPECT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
1913
1914 EntInfo entInfo("test", "this is test");
1915 res = edmMgr_->SetEnterpriseInfo(admin, entInfo);
1916 EXPECT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
1917 }
1918
1919 /**
1920 * @tc.name: TestSetEnterpriseInfoCheckCallingUidFailed
1921 * @tc.desc: Test SetEnterpriseInfo func.
1922 * @tc.type: FUNC
1923 */
1924 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetEnterpriseInfoCheckCallingUidFailed, TestSize.Level1)
1925 {
1926 AppExecFwk::ElementName admin;
1927 admin.SetBundleName(ADMIN_PACKAGENAME);
1928 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1929
1930 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1931
1932 EntInfo entInfoResult;
1933 ErrCode res = edmMgr_->GetEnterpriseInfo(admin, entInfoResult);
1934 EXPECT_TRUE(res == ERR_OK);
1935
1936 EntInfo entInfo("test", "this is test");
1937 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1938 res = edmMgr_->SetEnterpriseInfo(admin, entInfo);
1939 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
1940
1941 DisableSuperAdminSuc(admin.GetBundleName());
1942 }
1943
1944 /**
1945 * @tc.name: TestSetEnterpriseInfoSuc
1946 * @tc.desc: Test SetEnterpriseInfo func.
1947 * @tc.type: FUNC
1948 */
1949 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetEnterpriseInfoSuc, TestSize.Level1)
1950 {
1951 AppExecFwk::ElementName admin;
1952 admin.SetBundleName(ADMIN_PACKAGENAME);
1953 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
1954 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
1955
1956 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
1957 Return(ERR_OK)));
1958 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
1959
1960 EntInfo entInfo("test", "this is test");
1961 ErrCode res = edmMgr_->SetEnterpriseInfo(admin, entInfo);
1962 EXPECT_TRUE(res == ERR_OK);
1963
1964 EntInfo entInfoResult;
1965 res = edmMgr_->GetEnterpriseInfo(admin, entInfoResult);
1966 EXPECT_TRUE(res == ERR_OK);
1967
1968 DisableSuperAdminSuc(admin.GetBundleName());
1969 }
1970
1971 /**
1972 * @tc.name: TestOnReceiveEvent
1973 * @tc.desc: Test OnReceiveEvent func.
1974 * @tc.type: FUNC
1975 */
1976 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnReceiveEvent, TestSize.Level1)
1977 {
1978 EnterpriseDeviceMgrAbility listener;
1979 edmMgr_->CreateEnterpriseDeviceEventSubscriber(listener);
1980 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
1981 EventFwk::CommonEventSubscribeInfo info(skill);
1982 std::shared_ptr<EnterpriseDeviceEventSubscriber> edmEventSubscriber =
1983 std::make_shared<EnterpriseDeviceEventSubscriber>(info, *edmMgr_);
1984 size_t mapSize = edmMgr_->commonEventFuncMap_.size();
1985 EXPECT_TRUE(mapSize == COMMON_EVENT_FUNC_MAP_SIZE);
1986
1987 EventFwk::CommonEventData data;
1988 std::string action = "usual.event.ERROR_EVENT";
1989 AAFwk::Want want;
1990 want.SetAction(action);
1991 data.SetWant(want);
1992 edmEventSubscriber->OnReceiveEvent(data);
1993 auto func = edmMgr_->commonEventFuncMap_.find(action);
1994 EXPECT_TRUE(func == edmMgr_->commonEventFuncMap_.end());
1995
1996 edmMgr_->commonEventFuncMap_[action] = nullptr;
1997 edmEventSubscriber->OnReceiveEvent(data);
1998 func = edmMgr_->commonEventFuncMap_.find(action);
1999 EXPECT_TRUE(func != edmMgr_->commonEventFuncMap_.end());
2000 }
2001
2002 /**
2003 * @tc.name: TestOnCommonEventUserAdded
2004 * @tc.desc: Test OnCommonEventUserAdded func.
2005 * @tc.type: FUNC
2006 */
2007 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventUserAdded, TestSize.Level1)
2008 {
2009 EnterpriseDeviceMgrAbility listener;
2010 edmMgr_->CreateEnterpriseDeviceEventSubscriber(listener);
2011 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
2012 EventFwk::CommonEventSubscribeInfo info(skill);
2013 std::shared_ptr<EnterpriseDeviceEventSubscriber> edmEventSubscriber =
2014 std::make_shared<EnterpriseDeviceEventSubscriber>(info, *edmMgr_);
2015 AppExecFwk::ExtensionAbilityInfo abilityInfo;
2016 abilityInfo.bundleName = ADMIN_PACKAGENAME;
2017 abilityInfo.name = ADMIN_PACKAGENAME_ABILITY;
2018 EntInfo entInfo;
2019 entInfo.enterpriseName = "company";
2020 entInfo.description = "technology company in wuhan";
2021 std::vector<std::string> permissions = {EDM_TEST_PERMISSION};
2022 Admin edmAdmin(abilityInfo, AdminType::NORMAL, entInfo, permissions, false);
2023 edmMgr_->adminMgr_->SetAdminValue(DEFAULT_USER_ID, edmAdmin);
2024 edmAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME_1;
2025 edmAdmin.adminInfo_.className_ = ADMIN_PACKAGENAME_ABILITY_1;
2026 edmAdmin.adminInfo_.entInfo_.enterpriseName = "company1";
2027 edmAdmin.adminInfo_.entInfo_.description = "technology company in wuhan";
2028 edmMgr_->adminMgr_->SetAdminValue(ERROR_USER_ID, edmAdmin);
2029
2030 EventFwk::CommonEventData data;
2031 std::string action = "usual.event.USER_ADDED";
2032 AAFwk::Want want;
2033 want.SetAction(action);
2034 data.SetWant(want);
2035 data.SetCode(ERROR_USER_ID);
2036 edmEventSubscriber->OnReceiveEvent(data);
2037 std::vector<std::shared_ptr<Admin>> userAdmin;
2038 bool isExist = edmMgr_->adminMgr_->GetAdminByUserId(ERROR_USER_ID, userAdmin);
2039 EXPECT_TRUE(isExist);
2040 }
2041
2042 /**
2043 * @tc.name: TestOnCommonEventUserSwitched
2044 * @tc.desc: Test OnCommonEventUserSwitched func.
2045 * @tc.type: FUNC
2046 */
2047 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventUserSwitched, TestSize.Level1)
2048 {
2049 EnterpriseDeviceMgrAbility listener;
2050 edmMgr_->CreateEnterpriseDeviceEventSubscriber(listener);
2051 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
2052 EventFwk::CommonEventSubscribeInfo info(skill);
2053 std::shared_ptr<EnterpriseDeviceEventSubscriber> edmEventSubscriber =
2054 std::make_shared<EnterpriseDeviceEventSubscriber>(info, *edmMgr_);
2055 AppExecFwk::ExtensionAbilityInfo abilityInfo;
2056 abilityInfo.bundleName = ADMIN_PACKAGENAME;
2057 abilityInfo.name = ADMIN_PACKAGENAME_ABILITY;
2058 EntInfo entInfo;
2059 entInfo.enterpriseName = "company";
2060 entInfo.description = "technology company in wuhan";
2061 std::vector<std::string> permissions = {EDM_TEST_PERMISSION};
2062 Admin edmAdmin(abilityInfo, AdminType::NORMAL, entInfo, permissions, false);
2063 edmMgr_->adminMgr_->SetAdminValue(DEFAULT_USER_ID, edmAdmin);
2064 edmAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME_1;
2065 edmAdmin.adminInfo_.className_ = ADMIN_PACKAGENAME_ABILITY_1;
2066 edmAdmin.adminInfo_.entInfo_.enterpriseName = "company1";
2067 edmAdmin.adminInfo_.entInfo_.description = "technology company in wuhan";
2068 edmMgr_->adminMgr_->SetAdminValue(ERROR_USER_ID, edmAdmin);
2069
2070 EventFwk::CommonEventData data;
2071 std::string action = "usual.event.USER_SWITCHED";
2072 AAFwk::Want want;
2073 want.SetAction(action);
2074 data.SetWant(want);
2075 data.SetCode(ERROR_USER_ID);
2076 edmEventSubscriber->OnReceiveEvent(data);
2077 std::vector<std::shared_ptr<Admin>> userAdmin;
2078 bool isExist = edmMgr_->adminMgr_->GetAdminByUserId(ERROR_USER_ID, userAdmin);
2079 EXPECT_TRUE(isExist);
2080 }
2081
2082 /**
2083 * @tc.name: TestOnCommonEventUserRemoved
2084 * @tc.desc: Test OnCommonEventUserRemoved func.
2085 * @tc.type: FUNC
2086 */
2087 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventUserRemoved, TestSize.Level1)
2088 {
2089 EnterpriseDeviceMgrAbility listener;
2090 edmMgr_->CreateEnterpriseDeviceEventSubscriber(listener);
2091 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
2092 EventFwk::CommonEventSubscribeInfo info(skill);
2093 std::shared_ptr<EnterpriseDeviceEventSubscriber> edmEventSubscriber =
2094 std::make_shared<EnterpriseDeviceEventSubscriber>(info, *edmMgr_);
2095 AppExecFwk::ExtensionAbilityInfo abilityInfo;
2096 abilityInfo.bundleName = ADMIN_PACKAGENAME;
2097 abilityInfo.name = ADMIN_PACKAGENAME_ABILITY;
2098 EntInfo entInfo;
2099 entInfo.enterpriseName = "company";
2100 entInfo.description = "technology company in wuhan";
2101 std::vector<std::string> permissions = {EDM_TEST_PERMISSION};
2102 Admin edmAdmin(abilityInfo, AdminType::NORMAL, entInfo, permissions, false);
2103 edmMgr_->adminMgr_->SetAdminValue(DEFAULT_USER_ID, edmAdmin);
2104 edmAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME_1;
2105 edmAdmin.adminInfo_.className_ = ADMIN_PACKAGENAME_ABILITY_1;
2106 edmAdmin.adminInfo_.entInfo_.enterpriseName = "company1";
2107 edmAdmin.adminInfo_.entInfo_.description = "technology company in wuhan";
2108 edmMgr_->adminMgr_->SetAdminValue(ERROR_USER_ID, edmAdmin);
2109
2110 EventFwk::CommonEventData data;
2111 std::string action = "usual.event.USER_REMOVED";
2112 AAFwk::Want want;
2113 want.SetAction(action);
2114 data.SetWant(want);
2115 data.SetCode(ERROR_USER_ID);
2116 edmEventSubscriber->OnReceiveEvent(data);
2117 std::vector<std::shared_ptr<Admin>> userAdmin;
2118 bool isExist = edmMgr_->adminMgr_->GetAdminByUserId(ERROR_USER_ID, userAdmin);
2119 EXPECT_TRUE(!isExist);
2120 }
2121
2122 /**
2123 * @tc.name: TestOnCommonEventPackageAdded
2124 * @tc.desc: Test OnCommonEventPackageAdded and OnCommonEventPackageRemoved func.
2125 * @tc.type: FUNC
2126 */
2127 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventPackageAdded, TestSize.Level1)
2128 {
2129 EnterpriseDeviceMgrAbility listener;
2130 edmMgr_->CreateEnterpriseDeviceEventSubscriber(listener);
2131 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
2132 EventFwk::CommonEventSubscribeInfo info(skill);
2133 std::shared_ptr<EnterpriseDeviceEventSubscriber> edmEventSubscriber =
2134 std::make_shared<EnterpriseDeviceEventSubscriber>(info, *edmMgr_);
2135
2136 EventFwk::CommonEventData data;
2137 AAFwk::Want want;
2138 want.SetElementName(ADMIN_PACKAGENAME, ADMIN_PACKAGENAME_ABILITY);
2139 want.SetAction("usual.event.PACKAGE_ADDED");
2140 data.SetWant(want);
2141 edmEventSubscriber->OnReceiveEvent(data);
2142
2143 want.SetAction("usual.event.PACKAGE_REMOVED");
2144 data.SetWant(want);
2145 edmEventSubscriber->OnReceiveEvent(data);
2146
2147 AppExecFwk::ExtensionAbilityInfo abilityInfo;
2148 abilityInfo.bundleName = ADMIN_PACKAGENAME;
2149 abilityInfo.name = ADMIN_PACKAGENAME_ABILITY;
2150 EntInfo entInfo;
2151 entInfo.enterpriseName = "company";
2152 entInfo.description = "technology company in wuhan";
2153 std::vector<std::string> permissions = {EDM_TEST_PERMISSION};
2154 Admin edmAdmin(abilityInfo, AdminType::NORMAL, entInfo, permissions, false);
2155 edmMgr_->adminMgr_->SetAdminValue(DEFAULT_USER_ID, edmAdmin);
2156
2157 edmAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME_1;
2158 edmAdmin.adminInfo_.className_ = ADMIN_PACKAGENAME_ABILITY_1;
2159 edmAdmin.adminInfo_.entInfo_.enterpriseName = "company1";
2160 edmAdmin.adminInfo_.entInfo_.description = "technology company in wuhan1";
2161 edmMgr_->adminMgr_->SetAdminValue(DEFAULT_USER_ID, edmAdmin);
2162 const std::vector<uint32_t> events = {BUNDLE_ADDED_EVENT, BUNDLE_REMOVED_EVENT};
2163 edmMgr_->adminMgr_->SaveSubscribeEvents(events, abilityInfo.bundleName, DEFAULT_USER_ID);
2164
2165 std::string action = "usual.event.PACKAGE_ADDED";
2166 want.SetAction(action);
2167 want.SetElementName("com.edm.test.added", "com.edm.test.demo.MainAbility");
2168 data.SetWant(want);
2169 edmEventSubscriber->OnReceiveEvent(data);
2170 auto func = edmMgr_->commonEventFuncMap_.find(action);
2171 EXPECT_TRUE(func != edmMgr_->commonEventFuncMap_.end());
2172
2173 action = "usual.event.PACKAGE_REMOVED";
2174 want.SetAction(action);
2175 want.SetElementName("com.edm.test.removed", "com.edm.test.demo.MainAbility");
2176 data.SetWant(want);
2177 edmEventSubscriber->OnReceiveEvent(data);
2178 func = edmMgr_->commonEventFuncMap_.find(action);
2179 EXPECT_TRUE(func != edmMgr_->commonEventFuncMap_.end());
2180
2181 EXPECT_EQ(edmMgr_->adminMgr_->DeleteAdmin(abilityInfo.bundleName, DEFAULT_USER_ID), ERR_OK);
2182 EXPECT_EQ(edmMgr_->adminMgr_->DeleteAdmin(ADMIN_PACKAGENAME_1, DEFAULT_USER_ID), ERR_OK);
2183 }
2184
2185 /**
2186 * @tc.name: TestSubscribeManagedEventWithoutPermission
2187 * @tc.desc: Test SubscribeManagedEvent func.
2188 * @tc.type: FUNC
2189 */
2190 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEventWithoutPermission, TestSize.Level1)
2191 {
2192 AppExecFwk::ElementName admin;
2193 admin.SetBundleName(ADMIN_PACKAGENAME);
2194 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2195 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2196 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(false)));
2197
2198 std::vector<uint32_t> event;
2199 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, event);
2200 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
2201
2202 res = edmMgr_->UnsubscribeManagedEvent(admin, event);
2203 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
2204 DisableSuperAdminSuc(admin.GetBundleName());
2205 }
2206
2207 /**
2208 * @tc.name: TestSubscribeManagedEventWithoutActiveAdmin
2209 * @tc.desc: Test SubscribeManagedEvent func.
2210 * @tc.type: FUNC
2211 */
2212 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEventWithoutActiveAdmin, TestSize.Level1)
2213 {
2214 AppExecFwk::ElementName admin;
2215 admin.SetBundleName(ADMIN_PACKAGENAME);
2216 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2217 std::vector<uint32_t> event;
2218
2219 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
2220 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, event);
2221 EXPECT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
2222 }
2223
2224 /**
2225 * @tc.name: TestSubscribeManagedEventCheckCallingUidFailed
2226 * @tc.desc: Test SubscribeManagedEvent func.
2227 * @tc.type: FUNC
2228 */
2229 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEventCheckCallingUidFailed, TestSize.Level1)
2230 {
2231 AppExecFwk::ElementName admin;
2232 admin.SetBundleName(ADMIN_PACKAGENAME);
2233 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2234 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
2235
2236 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
2237 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2238 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2239 Return(ERR_OK)));
2240 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(Return(1)));
2241 std::vector<uint32_t> event;
2242 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, event);
2243 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
2244
2245 DisableAdminSuc(admin, DEFAULT_USER_ID);
2246 }
2247
2248 /**
2249 * @tc.name: TestSubscribeManagedEventWithEmptyEvents
2250 * @tc.desc: Test SubscribeManagedEvent func.
2251 * @tc.type: FUNC
2252 */
2253 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEventWithEmptyEvents, TestSize.Level1)
2254 {
2255 AppExecFwk::ElementName admin;
2256 admin.SetBundleName(ADMIN_PACKAGENAME);
2257 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2258 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2259
2260 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
2261 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2262 Return(ERR_OK)));
2263 std::vector<uint32_t> event;
2264 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, event);
2265 EXPECT_TRUE(res == EdmReturnErrCode::MANAGED_EVENTS_INVALID);
2266
2267 DisableSuperAdminSuc(admin.GetBundleName());
2268 }
2269
2270 /**
2271 * @tc.name: TestSubscribeManagedEventWithInvalidEvents
2272 * @tc.desc: Test SubscribeManagedEvent func.
2273 * @tc.type: FUNC
2274 */
2275 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEventWithInvalidEvents, TestSize.Level1)
2276 {
2277 AppExecFwk::ElementName admin;
2278 admin.SetBundleName(ADMIN_PACKAGENAME);
2279 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2280 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2281
2282 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
2283 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2284 Return(ERR_OK)));
2285 std::vector<uint32_t> event = {INVALID_MANAGED_EVENT_TEST};
2286 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, event);
2287 EXPECT_TRUE(res == EdmReturnErrCode::MANAGED_EVENTS_INVALID);
2288
2289 DisableSuperAdminSuc(admin.GetBundleName());
2290 }
2291
2292 /**
2293 * @tc.name: TestSubscribeManagedEvent
2294 * @tc.desc: Test TestSubscribeManagedEvent func.
2295 * @tc.type: FUNC
2296 */
2297 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSubscribeManagedEvent, TestSize.Level1)
2298 {
2299 AppExecFwk::ElementName admin;
2300 admin.SetBundleName(ADMIN_PACKAGENAME);
2301 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2302 EntInfo entInfo("test", "this is test");
2303 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2304
2305 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2306 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2307 Return(ERR_OK)));
2308 std::vector<uint32_t> events = {BUNDLE_ADDED_EVENT, BUNDLE_REMOVED_EVENT};
2309 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, events);
2310 EXPECT_TRUE(res == ERR_OK);
2311
2312 DisableSuperAdminSuc(admin.GetBundleName());
2313 }
2314
2315 /**
2316 * @tc.name: SubscribeAppStartStopEvent
2317 * @tc.desc: Test SubscribeAppStartStopEvent func.
2318 * @tc.type: FUNC
2319 */
2320 HWTEST_F(EnterpriseDeviceMgrAbilityTest, SubscribeAppStartStopEvent, TestSize.Level1)
2321 {
2322 AppExecFwk::ElementName admin;
2323 admin.SetBundleName(ADMIN_PACKAGENAME);
2324 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2325 EntInfo entInfo("test", "this is test");
2326 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
2327
2328 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2329 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2330 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2331 Return(ERR_OK)));
2332 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2333 Return(ERR_OK)));
2334 std::vector<uint32_t> events = {APP_START_EVENT, APP_STOP_EVENT};
2335 ErrCode res = edmMgr_->SubscribeManagedEvent(admin, events);
2336 EXPECT_TRUE(res == ERR_OK);
2337 DisableAdminSuc(admin, DEFAULT_USER_ID);
2338 }
2339
2340 /**
2341 * @tc.name: TestUnsubscribeManagedEvent
2342 * @tc.desc: Test UnsubscribeManagedEvent func.
2343 * @tc.type: FUNC
2344 */
2345 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestUnsubscribeManagedEvent, TestSize.Level1)
2346 {
2347 AppExecFwk::ElementName admin;
2348 admin.SetBundleName(ADMIN_PACKAGENAME);
2349 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2350 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2351
2352 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2353 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2354 Return(ERR_OK)));
2355 std::vector<uint32_t> events = {BUNDLE_ADDED_EVENT, BUNDLE_REMOVED_EVENT};
2356 ErrCode res = edmMgr_->UnsubscribeManagedEvent(admin, events);
2357 EXPECT_TRUE(res == ERR_OK);
2358
2359 DisableSuperAdminSuc(admin.GetBundleName());
2360 }
2361
2362 /**
2363 * @tc.name: UnsubscribeAppStartStopEvent
2364 * @tc.desc: Test UnsubscribeAppStartStopEvent func.
2365 * @tc.type: FUNC
2366 */
2367 HWTEST_F(EnterpriseDeviceMgrAbilityTest, UnsubscribeAppStartStopEvent, TestSize.Level1)
2368 {
2369 AppExecFwk::ElementName admin;
2370 admin.SetBundleName(ADMIN_PACKAGENAME);
2371 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2372 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
2373
2374 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2375 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2376 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2377 Return(ERR_OK)));
2378 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2379 Return(ERR_OK)));
2380 std::vector<uint32_t> events = {APP_START_EVENT, APP_STOP_EVENT};
2381 ErrCode res = edmMgr_->UnsubscribeManagedEvent(admin, events);
2382 EXPECT_TRUE(res == ERR_OK);
2383
2384 DisableAdminSuc(admin, DEFAULT_USER_ID);
2385 }
2386
2387 /**
2388 * @tc.name: TestGetSuperAdmin
2389 * @tc.desc: Test GetSuperAdmin func.
2390 * @tc.type: FUNC
2391 */
2392 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetSuperAdmin, TestSize.Level1)
2393 {
2394 std::string bundleName;
2395 std::string abilityName;
2396 ErrCode res = edmMgr_->GetSuperAdmin(bundleName, abilityName);
2397 EXPECT_TRUE(bundleName.empty());
2398 EXPECT_TRUE(abilityName.empty());
2399 EXPECT_TRUE(res == ERR_OK);
2400 }
2401
2402 /**
2403 * @tc.name: TestGetExternalManagerFactory
2404 * @tc.desc: Test GetExternalManagerFactory func.
2405 * @tc.type: FUNC
2406 */
2407 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetExternalManagerFactory, TestSize.Level1)
2408 {
2409 EXPECT_TRUE(edmMgr_->GetExternalManagerFactory() != nullptr);
2410 }
2411
2412 /**
2413 * @tc.name: TestEnableAdminCallingPermissionFailed
2414 * @tc.desc: Test EnableAdmin func with verify calling permission failed.
2415 * @tc.type: FUNC
2416 */
2417 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminCallingPermissionFailed, TestSize.Level1)
2418 {
2419 AppExecFwk::ElementName admin;
2420 EntInfo entInfo("test", "this is test");
2421 admin.SetBundleName(ADMIN_PACKAGENAME);
2422 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2423
2424 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2425 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
2426
2427 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
2428 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
2429 }
2430
2431 /**
2432 * @tc.name: TestEnableAdminQueryExtensionAbilityInfosFailed
2433 * @tc.desc: Test EnableAdmin func with query extension abilityInfos failed.
2434 * @tc.type: FUNC
2435 */
2436 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminQueryExtensionAbilityInfosFailed, TestSize.Level1)
2437 {
2438 AppExecFwk::ElementName admin;
2439 EntInfo entInfo("test", "this is test");
2440 admin.SetBundleName(ADMIN_PACKAGENAME);
2441 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2442
2443 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2444 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2445 QueryExtensionAbilityInfosMock(false, "");
2446
2447 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
2448 EXPECT_TRUE(res == EdmReturnErrCode::COMPONENT_INVALID);
2449 }
2450
2451 /**
2452 * @tc.name: TestEnableAdminQueryExtensionAbilityInfosEmpty
2453 * @tc.desc: Test EnableAdmin func with query extension abilityInfos empty.
2454 * @tc.type: FUNC
2455 */
2456 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminQueryExtensionAbilityInfosEmpty, TestSize.Level1)
2457 {
2458 AppExecFwk::ElementName admin;
2459 EntInfo entInfo("test", "this is test");
2460 admin.SetBundleName(ADMIN_PACKAGENAME);
2461 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2462
2463 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2464 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2465 QueryExtensionAbilityInfosMock(true, "", true);
2466
2467 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
2468 EXPECT_TRUE(res == EdmReturnErrCode::COMPONENT_INVALID);
2469 }
2470
2471 /**
2472 * @tc.name: TestEnableAdminVerifyConditionFailed
2473 * @tc.desc: Test EnableAdmin func with invalid admin type.
2474 * @tc.type: FUNC
2475 */
2476 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminVerifyConditionFailed, TestSize.Level1)
2477 {
2478 AppExecFwk::ElementName admin;
2479 EntInfo entInfo("test", "this is test");
2480 admin.SetBundleName(ADMIN_PACKAGENAME);
2481 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2482
2483 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::UNKNOWN, DEFAULT_USER_ID);
2484 EXPECT_TRUE(res == EdmReturnErrCode::PARAM_ERROR);
2485 }
2486
2487 /**
2488 * @tc.name: TestEnableAdminWithErrorUserId
2489 * @tc.desc: Test enabled super admin with userId = 101.
2490 * @tc.type: FUNC
2491 */
2492 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithErrorUserId, TestSize.Level1)
2493 {
2494 AppExecFwk::ElementName admin;
2495 EntInfo entInfo("test", "this is test");
2496 admin.SetBundleName(ADMIN_PACKAGENAME);
2497 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2498
2499 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2500 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2501 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2502
2503 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, TEST_USER_ID);
2504 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
2505 }
2506
2507 /**
2508 * @tc.name: TestEnableAdminToNormalAdmin
2509 * @tc.desc: Test enabled super admin to normal admin.
2510 * @tc.type: FUNC
2511 */
2512 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminToNormalAdmin, TestSize.Level1)
2513 {
2514 AppExecFwk::ElementName admin;
2515 EntInfo entInfo("test", "this is test");
2516 admin.SetBundleName(ADMIN_PACKAGENAME);
2517 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2518
2519 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2520
2521 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2522 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2523 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2524
2525 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USER_ID);
2526 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
2527
2528 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
2529 }
2530
2531 /**
2532 * @tc.name: TestEnableAdminToOtherUserId
2533 * @tc.desc: Test enabled super admin to other user id.
2534 * @tc.type: FUNC
2535 */
2536 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminToOtherUserId, TestSize.Level1)
2537 {
2538 AppExecFwk::ElementName admin;
2539 EntInfo entInfo("test", "this is test");
2540 admin.SetBundleName(ADMIN_PACKAGENAME);
2541 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2542
2543 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2544
2545 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2546 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2547 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2548
2549 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, TEST_USER_ID);
2550 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
2551
2552 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
2553 }
2554
2555 /**
2556 * @tc.name: TestEnableAdminWithOtherEntInfo
2557 * @tc.desc: Test enabled super admin with other entInfo.
2558 * @tc.type: FUNC
2559 */
2560 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithOtherEntInfo, TestSize.Level1)
2561 {
2562 AppExecFwk::ElementName admin;
2563 EntInfo entInfo("test1", "this is test1");
2564 admin.SetBundleName(ADMIN_PACKAGENAME);
2565 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2566
2567 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2568
2569 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2570 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2571 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2572 GetBundleInfoMock(true, "");
2573
2574 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
2575 EXPECT_TRUE(res == ERR_OK);
2576
2577 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
2578 }
2579
2580 /**
2581 * @tc.name: TestEnableAdminWithMultipleSuperAdmin
2582 * @tc.desc: Test enabled two super admin.
2583 * @tc.type: FUNC
2584 */
2585 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithMultipleSuperAdmin, TestSize.Level1)
2586 {
2587 AppExecFwk::ElementName admin;
2588 EntInfo entInfo("test", "this is test");
2589 admin.SetBundleName(ADMIN_PACKAGENAME);
2590 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2591 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2592
2593 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2594 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2595 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2596
2597 admin.SetBundleName(ADMIN_PACKAGENAME_1);
2598 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
2599
2600 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
2601 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
2602
2603 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
2604 }
2605
2606 /**
2607 * @tc.name: TestEnableAdminWithOtherAbility
2608 * @tc.desc: Test enabled super admin with other ability.
2609 * @tc.type: FUNC
2610 */
2611 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAdminWithOtherAbility, TestSize.Level1)
2612 {
2613 MessageParcel data;
2614 MessageParcel reply;
2615 AppExecFwk::ElementName admin;
2616 EntInfo entInfo("test", "this is test");
2617 admin.SetBundleName(ADMIN_PACKAGENAME);
2618 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2619 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2620
2621 EXPECT_CALL(*accessTokenMgrMock_, IsDebug).WillOnce(DoAll(Return(false)));
2622 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2623 QueryExtensionAbilityInfosMock(true, admin.GetBundleName());
2624
2625 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
2626
2627 ErrCode res = edmMgr_->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USER_ID);
2628 EXPECT_TRUE(res == EdmReturnErrCode::ENABLE_ADMIN_FAILED);
2629
2630 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
2631 }
2632
2633 /**
2634 * @tc.name: TesAuthorizeAdminWithoutPermisson
2635 * @tc.desc: Test AuthorizeAdmin without permission func.
2636 * @tc.type: FUNC
2637 */
2638 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TesAuthorizeAdminWithoutPermisson, TestSize.Level1)
2639 {
2640 AppExecFwk::ElementName admin;
2641 admin.SetBundleName(ADMIN_PACKAGENAME);
2642 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2643
2644 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2645 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
2646 ErrCode res = edmMgr_->AuthorizeAdmin(admin, ADMIN_PACKAGENAME_1);
2647
2648 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
2649 DisableSuperAdminSuc(admin.GetBundleName());
2650 }
2651
2652 /**
2653 * @tc.name: TestUnsubscribeManagedEvent02
2654 * @tc.desc: Test UnsubscribeManagedEvent func.
2655 * @tc.type: FUNC
2656 */
2657 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestUnsubscribeManagedEvent02, TestSize.Level1)
2658 {
2659 AppExecFwk::ElementName admin;
2660 std::vector<uint32_t> events = {APP_START_EVENT, APP_STOP_EVENT};
2661 admin.SetBundleName(ADMIN_PACKAGENAME);
2662 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2663 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
2664
2665 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2666 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2667 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2668 Return(ERR_OK)));
2669 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(admin.GetBundleName()),
2670 Return(ERR_OK)));
2671
2672 ErrCode res = edmMgr_->UnsubscribeManagedEvent(admin, events);
2673 EXPECT_TRUE(res == ERR_OK);
2674
2675 DisableAdminSuc(admin, DEFAULT_USER_ID);
2676 }
2677
2678 /**
2679 * @tc.name: TestConnectAbilityOnSystemUpdate
2680 * @tc.desc: Test ConnectAbilityOnSystemUpdate func.
2681 * @tc.type: FUNC
2682 */
2683 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestConnectAbilityOnSystemUpdate, TestSize.Level1)
2684 {
2685 UpdateInfo updateInfo;
2686 edmMgr_->ConnectAbilityOnSystemUpdate(updateInfo);
2687 EXPECT_TRUE(true);
2688 }
2689
2690 /**
2691 * @tc.name: TestOnCommonEventSystemUpdate
2692 * @tc.desc: Test OnCommonEventSystemUpdate func.
2693 * @tc.type: FUNC
2694 */
2695 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventSystemUpdate, TestSize.Level1)
2696 {
2697 EventFwk::CommonEventData data;
2698 edmMgr_->OnCommonEventSystemUpdate(data);
2699 EXPECT_TRUE(true);
2700 }
2701
2702 /**
2703 * @tc.name: TestOnCommonEventKioskModeOn
2704 * @tc.desc: Test OnCommonEventKioskModeOn func.
2705 * @tc.type: FUNC
2706 */
2707 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventKioskModeOn, TestSize.Level1)
2708 {
2709 AppExecFwk::ElementName admin;
2710 admin.SetBundleName(ADMIN_PACKAGENAME);
2711 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2712 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2713
2714 EventFwk::CommonEventData data;
2715 edmMgr_->OnCommonEventKioskMode(data, true);
2716
2717 std::vector<std::shared_ptr<Admin>> admins;
2718 edmMgr_->adminMgr_->GetAdmins(admins, EdmConstants::DEFAULT_USER_ID);
2719 ASSERT_TRUE(!admins.empty());
2720 DisableSuperAdminSuc(admin.GetBundleName());
2721 }
2722
2723 /**
2724 * @tc.name: TestOnCommonEventKioskModeOff
2725 * @tc.desc: Test OnCommonEventKioskModeOff func.
2726 * @tc.type: FUNC
2727 */
2728 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestOnCommonEventKioskModeOff, TestSize.Level1)
2729 {
2730 AppExecFwk::ElementName admin;
2731 admin.SetBundleName(ADMIN_PACKAGENAME);
2732 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
2733 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
2734
2735 EventFwk::CommonEventData data;
2736 edmMgr_->OnCommonEventKioskMode(data, false);
2737
2738 std::vector<std::shared_ptr<Admin>> admins;
2739 edmMgr_->adminMgr_->GetAdmins(admins, EdmConstants::DEFAULT_USER_ID);
2740 ASSERT_TRUE(!admins.empty());
2741 DisableSuperAdminSuc(admin.GetBundleName());
2742 }
2743
2744 /**
2745 * @tc.name: TestAddOnAddSystemAbilityFuncMap
2746 * @tc.desc: Test AddOnAddSystemAbilityFuncMap func.
2747 * @tc.type: FUNC
2748 */
2749 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAddOnAddSystemAbilityFuncMap, TestSize.Level1)
2750 {
2751 edmMgr_->AddOnAddSystemAbilityFuncMap();
2752 EXPECT_TRUE(edmMgr_->addSystemAbilityFuncMap_.size() >= 3);
2753 }
2754
2755 /**
2756 * @tc.name: TestInitAllPolicies
2757 * @tc.desc: Test InitAllPolicies func.
2758 * @tc.type: FUNC
2759 */
2760 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestInitAllPolicies, TestSize.Level1)
2761 {
2762 edmMgr_->InitAllPolices();
2763 EXPECT_TRUE(true);
2764 }
2765
2766 /**
2767 * @tc.name: TestRemoveAllDebugAdmin
2768 * @tc.desc: Test RemoveAllDebugAdmin func.
2769 * @tc.type: FUNC
2770 */
2771 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestRemoveAllDebugAdmin, TestSize.Level1)
2772 {
2773 edmMgr_->RemoveAllDebugAdmin();
2774 EXPECT_TRUE(true);
2775 }
2776
2777 /**
2778 * @tc.name: TestAddSystemAbilityListeners
2779 * @tc.desc: Test AddSystemAbilityListeners func.
2780 * @tc.type: FUNC
2781 */
2782 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestAddSystemAbilityListeners, TestSize.Level1)
2783 {
2784 edmMgr_->AddSystemAbilityListeners();
2785 EXPECT_TRUE(true);
2786 }
2787
2788 /**
2789 * @tc.name: TestHandleDevicePolicyInnerWithUserNotExsist
2790 * @tc.desc: Test HandleDevicePolicyInner function with userId is not exist.
2791 * @tc.type: FUNC
2792 */
2793 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerWithUserNotExsist, TestSize.Level1)
2794 {
2795 PrepareBeforeHandleDevicePolicy();
2796
2797 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(false), Return(ERR_OK)));
2798
2799 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2800 MessageParcel data;
2801 MessageParcel reply;
2802 AppExecFwk::ElementName admin;
2803 admin.SetBundleName(ADMIN_PACKAGENAME_FAILED);
2804 data.WriteParcelable(&admin);
2805 data.WriteString("");
2806 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2807 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PARAM_ERROR);
2808 }
2809
2810 /**
2811 * @tc.name: TestHandleDevicePolicyInnerWithoutAdmin
2812 * @tc.desc: Test HandleDevicePolicyInner with none admmin.
2813 * @tc.type: FUNC
2814 */
2815 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerWithoutAdmin, TestSize.Level1)
2816 {
2817 PrepareBeforeHandleDevicePolicy();
2818
2819 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2820 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2821 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillOnce(DoAll(SetArgReferee<0>(ids), Return(ERR_OK)));
2822
2823 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2824 MessageParcel data;
2825 MessageParcel reply;
2826 AppExecFwk::ElementName admin;
2827 admin.SetBundleName(ADMIN_PACKAGENAME_NOT_ACTIVE);
2828 data.WriteParcelable(&admin);
2829 data.WriteString("");
2830 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2831 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::ADMIN_INACTIVE);
2832 }
2833
2834 /**
2835 * @tc.name: TestHandleDevicePolicyInnerCheckCallingUidFailed
2836 * @tc.desc: Test HandleDevicePolicyInner function with check callingUid failed.
2837 * @tc.type: FUNC
2838 */
2839 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerCheckCallingUidFailed, TestSize.Level1)
2840 {
2841 PrepareBeforeHandleDevicePolicy();
2842
2843 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2844 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2845 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2846 Return(ERR_OK)));
2847 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(Return(1)));
2848
2849 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2850 MessageParcel data;
2851 MessageParcel reply;
2852 AppExecFwk::ElementName admin;
2853 admin.SetBundleName(ADMIN_PACKAGENAME);
2854 data.WriteParcelable(&admin);
2855 data.WriteString("");
2856 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2857 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PERMISSION_DENIED);
2858 }
2859
2860 /**
2861 * @tc.name: TestHandleDevicePolicyInnerWithInvalidPlugin
2862 * @tc.desc: Test HandleDevicePolicyInner function with invalid policy code.
2863 * @tc.type: FUNC
2864 */
2865 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerWithInvalidPlugin, TestSize.Level1)
2866 {
2867 PrepareBeforeHandleDevicePolicy();
2868
2869 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
2870 MessageParcel data;
2871 MessageParcel reply;
2872 AppExecFwk::ElementName admin;
2873 admin.SetBundleName(ADMIN_PACKAGENAME);
2874 data.WriteParcelable(&admin);
2875 data.WriteString("");
2876 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2877 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::INTERFACE_UNSUPPORTED);
2878 }
2879
2880 /**
2881 * @tc.name: TestHandleDevicePolicyInnerCheckPermissionFailed
2882 * @tc.desc: Test HandleDevicePolicyInner function with check plugin permission failed.
2883 * @tc.type: FUNC
2884 */
2885 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerCheckPermissionFailed, TestSize.Level1)
2886 {
2887 PrepareBeforeHandleDevicePolicy();
2888 Admin testAdmin;
2889 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
2890 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
2891 edmMgr_->adminMgr_->ClearAdmins();
2892 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
2893
2894 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2895 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2896 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2897 Return(ERR_OK)));
2898 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
2899 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2900 GetBundleInfoMock(true, "");
2901
2902 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2903 MessageParcel data;
2904 MessageParcel reply;
2905 AppExecFwk::ElementName admin;
2906 admin.SetBundleName(ADMIN_PACKAGENAME);
2907 data.WriteParcelable(&admin);
2908 data.WriteString("");
2909 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2910 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
2911 }
2912
2913 /**
2914 * @tc.name: TestHandleDevicePolicyInnerVerifyCallingPermissionFailed
2915 * @tc.desc: Test HandleDevicePolicyInner function with check calling permission failed.
2916 * @tc.type: FUNC
2917 */
2918 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerVerifyCallingPermissionFailed, TestSize.Level1)
2919 {
2920 PrepareBeforeHandleDevicePolicy();
2921 Admin testAdmin;
2922 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
2923 testAdmin.adminInfo_.permission_ = {EDM_TEST_PERMISSION};
2924 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
2925 edmMgr_->adminMgr_->ClearAdmins();
2926 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
2927 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
2928 PluginManager::GetInstance()->pluginsCode_.clear();
2929 PluginManager::GetInstance()->pluginsName_.clear();
2930 PluginManager::GetInstance()->AddPlugin(plugin_);
2931
2932 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2933 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2934 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2935 Return(ERR_OK)));
2936 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
2937 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
2938 GetBundleInfoMock(true, "");
2939
2940 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2941 MessageParcel data;
2942 MessageParcel reply;
2943 AppExecFwk::ElementName admin;
2944 admin.SetBundleName(ADMIN_PACKAGENAME);
2945 data.WriteParcelable(&admin);
2946 data.WriteString("");
2947 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2948 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PERMISSION_DENIED);
2949 }
2950
2951 /**
2952 * @tc.name: TestHandleDevicePolicyInnerSuc
2953 * @tc.desc: Test HandleDevicePolicyInner function success.
2954 * @tc.type: FUNC
2955 */
2956 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerSuc, TestSize.Level1)
2957 {
2958 PrepareBeforeHandleDevicePolicy();
2959
2960 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2961 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2962 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
2963 Return(ERR_OK)));
2964 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
2965 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
2966
2967 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
2968 MessageParcel data;
2969 MessageParcel reply;
2970 AppExecFwk::ElementName admin;
2971 admin.SetBundleName(ADMIN_PACKAGENAME);
2972 data.WriteParcelable(&admin);
2973 data.WriteString("");
2974 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
2975 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
2976 }
2977
2978 /**
2979 * @tc.name: TestHandleDevicePolicyInnerWithJSONError
2980 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicyInner function.
2981 * @tc.desc: plugin->OnHandlePolicy(code, data, reply, policyValue, isChanged)
2982 * @tc.desc: Test the result of plugin->OnHandlePolicy is not OK
2983 * @tc.type: FUNC
2984 * @tc.require: issueI5PBT1
2985 */
2986 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerWithJSONError, TestSize.Level1)
2987 {
2988 PrepareBeforeHandleDevicePolicy();
2989
2990 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
2991 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
2992 EDM_MANAGE_DATETIME_PERMISSION;
2993 PluginManager::GetInstance()->pluginsCode_.clear();
2994 PluginManager::GetInstance()->pluginsName_.clear();
2995 PluginManager::GetInstance()->AddPlugin(plugin_);
2996
2997 std::vector<int32_t> ids = {DEFAULT_USER_ID};
2998 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
2999 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3000 Return(ERR_OK)));
3001 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
3002 Return(ERR_OK)));
3003 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3004
3005 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
3006 MessageParcel data;
3007 MessageParcel reply;
3008 AppExecFwk::ElementName admin;
3009 admin.SetBundleName(ADMIN_PACKAGENAME);
3010 data.WriteParcelable(&admin);
3011 data.WriteString("");
3012 data.WriteString("ErrorData");
3013 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3014 ASSERT_TRUE(reply.ReadInt32() == ERR_EDM_OPERATE_JSON);
3015 }
3016
3017 /**
3018 * @tc.name: TestHandleDevicePolicyInnerSuc02
3019 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicyInner function.
3020 * @tc.desc: Test run into the branch if (plugin ->NeedSavePolicy() && isChanged)
3021 * @tc.type: FUNC
3022 * @tc.require: issueI5PBT1
3023 */
3024 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerSuc02, TestSize.Level1)
3025 {
3026 PrepareBeforeHandleDevicePolicy();
3027 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
3028 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3029 EDM_MANAGE_DATETIME_PERMISSION;
3030 PluginManager::GetInstance()->pluginsCode_.clear();
3031 PluginManager::GetInstance()->pluginsName_.clear();
3032 PluginManager::GetInstance()->AddPlugin(plugin_);
3033
3034 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3035 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3036 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3037 Return(ERR_OK)));
3038 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
3039 Return(ERR_OK)));
3040 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3041
3042 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
3043 MessageParcel data;
3044 MessageParcel reply;
3045 AppExecFwk::ElementName admin;
3046 admin.SetBundleName(ADMIN_PACKAGENAME);
3047 data.WriteParcelable(&admin);
3048 data.WriteString("");
3049 data.WriteString("testValue");
3050 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3051 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3052 ErrCode res = edmMgr_->policyMgr_->SetPolicy(ADMIN_PACKAGENAME, plugin_->GetPolicyName(), "", "");
3053 ASSERT_TRUE(res == ERR_OK);
3054
3055 plugin_ = PLUGIN::HandlePolicyBiFunctionUnsavePlg::GetPlugin();
3056 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3057 EDM_MANAGE_DATETIME_PERMISSION;
3058 PluginManager::GetInstance()->pluginsCode_.clear();
3059 PluginManager::GetInstance()->pluginsName_.clear();
3060 PluginManager::GetInstance()->AddPlugin(plugin_);
3061 code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE);
3062 MessageParcel data2;
3063 data2.WriteParcelable(&admin);
3064 data2.WriteString("");
3065 data2.WriteString("{\"name\" : \"testValue\"}");
3066 edmMgr_->HandleDevicePolicyInner(code, data2, reply, DEFAULT_USER_ID);
3067 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3068 }
3069
3070 /**
3071 * @tc.name: TestHandleDevicePolicyInnerWithMergePolicyDataFail
3072 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicyInner function.
3073 * @tc.desc: run into plugin->MergePolicyData(admin.GetBundleName(), mergedPolicy)
3074 * @tc.desc: Test the MergePolicyData processing result is not OK
3075 * @tc.type: FUNC
3076 * @tc.require: issueI5PBT1
3077 */
3078 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestHandleDevicePolicyInnerWithMergePolicyDataFail, TestSize.Level1)
3079 {
3080 PrepareBeforeHandleDevicePolicy();
3081 plugin_ = PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin();
3082 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3083 EDM_MANAGE_DATETIME_PERMISSION;
3084 PluginManager::GetInstance()->pluginsCode_.clear();
3085 PluginManager::GetInstance()->pluginsName_.clear();
3086 PluginManager::GetInstance()->AddPlugin(plugin_);
3087
3088 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3089 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillRepeatedly(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3090 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3091 Return(ERR_OK)));
3092 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
3093 Return(ERR_OK)));
3094 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3095
3096 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_JSON_BIFUNCTIONPLG_POLICYCODE);
3097 MessageParcel data;
3098 MessageParcel reply;
3099 AppExecFwk::ElementName admin;
3100 admin.SetBundleName(ADMIN_PACKAGENAME);
3101 data.WriteParcelable(&admin);
3102 data.WriteString("");
3103 data.WriteString("{\"name\" : \"testValue\"}");
3104 edmMgr_->HandleDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3105 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3106 ErrCode res = edmMgr_->policyMgr_->SetPolicy(ADMIN_PACKAGENAME, plugin_->GetPolicyName(), "", "", DEFAULT_USER_ID);
3107 ASSERT_TRUE(res == ERR_OK);
3108 }
3109
3110 /**
3111 * @tc.name: TestGetDevicePolicyInnerWithUserNotExsist
3112 * @tc.desc: Test GetDevicePolicyInner function with userId is not exist.
3113 * @tc.type: FUNC
3114 */
3115 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithUserNotExsist, TestSize.Level1)
3116 {
3117 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(false), Return(ERR_OK)));
3118
3119 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
3120 MessageParcel data;
3121 MessageParcel reply;
3122 data.WriteInt32(1);
3123 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3124 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PARAM_ERROR);
3125 }
3126
3127 /**
3128 * @tc.name: TestGetDevicePolicyInnerWithNotExistPlugin
3129 * @tc.desc: Test GetDevicePolicyInner function with not exist plugin.
3130 * @tc.type: FUNC
3131 */
3132 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithNotExistPlugin, TestSize.Level1)
3133 {
3134 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3135
3136 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
3137 MessageParcel data;
3138 MessageParcel reply;
3139 data.WriteInt32(1);
3140 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3141 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::INTERFACE_UNSUPPORTED);
3142 }
3143
3144 /**
3145 * @tc.name: TestGetDevicePolicyInnerWithAdminInactive
3146 * @tc.desc: Test GetDevicePolicyInner function with admin inactive.
3147 * @tc.type: FUNC
3148 */
3149 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithAdminInactive, TestSize.Level1)
3150 {
3151 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3152
3153 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
3154 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3155 EDM_MANAGE_DATETIME_PERMISSION;
3156 PluginManager::GetInstance()->AddPlugin(plugin_);
3157 AppExecFwk::ElementName admin;
3158 admin.SetBundleName(ADMIN_PACKAGENAME_NOT_ACTIVE);
3159 MessageParcel data;
3160 MessageParcel reply;
3161 data.WriteString("");
3162 data.WriteInt32(0);
3163 data.WriteParcelable(&admin);
3164 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3165 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::ADMIN_INACTIVE);
3166 }
3167
3168 /**
3169 * @tc.name: TestGetDevicePolicyInnerWithCheckCallingUidFailed
3170 * @tc.desc: Test GetDevicePolicyInner function with check calling uid failed.
3171 * @tc.type: FUNC
3172 */
3173 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithCheckCallingUidFailed, TestSize.Level1)
3174 {
3175 Admin testAdmin;
3176 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
3177 testAdmin.adminInfo_.permission_ = {EDM_TEST_PERMISSION};
3178 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
3179 edmMgr_->adminMgr_->InsertAdmins(DEFAULT_USER_ID, adminVec);
3180 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3181 PluginManager::GetInstance()->AddPlugin(plugin_);
3182
3183 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3184 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(1)));
3185 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3186 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3187 Return(ERR_OK)));
3188
3189 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
3190 AppExecFwk::ElementName admin;
3191 admin.SetBundleName(ADMIN_PACKAGENAME);
3192 MessageParcel data;
3193 MessageParcel reply;
3194 data.WriteString("");
3195 data.WriteInt32(0);
3196 data.WriteParcelable(&admin);
3197 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3198 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PERMISSION_DENIED);
3199 }
3200
3201 /**
3202 * @tc.name: TestGetDevicePolicyInnerWithCheckEdmPermissionFailed
3203 * @tc.desc: Test GetDevicePolicyInner function with check edm permission failed.
3204 * @tc.type: FUNC
3205 */
3206 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithCheckEdmPermissionFailed, TestSize.Level1)
3207 {
3208 PrepareBeforeHandleDevicePolicy();
3209 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3210 PluginManager::GetInstance()->AddPlugin(plugin_);
3211
3212 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3213 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3214 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3215 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3216 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3217 Return(ERR_OK)));
3218 GetBundleInfoMock(true, "");
3219
3220 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
3221 AppExecFwk::ElementName admin;
3222 admin.SetBundleName(ADMIN_PACKAGENAME);
3223 MessageParcel data;
3224 MessageParcel reply;
3225 data.WriteString("");
3226 data.WriteInt32(0);
3227 data.WriteParcelable(&admin);
3228 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3229 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
3230 }
3231
3232 /**
3233 * @tc.name: TestGetDevicePolicyInnerSuc
3234 * @tc.desc: Test GetDevicePolicyInner function success.
3235 * @tc.type: FUNC
3236 */
3237 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerSuc, TestSize.Level1)
3238 {
3239 PrepareBeforeHandleDevicePolicy();
3240
3241 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3242 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3243 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3244 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3245 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3246 Return(ERR_OK)));
3247
3248 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
3249 AppExecFwk::ElementName admin;
3250 admin.SetBundleName(ADMIN_PACKAGENAME);
3251 MessageParcel data;
3252 MessageParcel reply;
3253 data.WriteString("");
3254 data.WriteInt32(0);
3255 data.WriteParcelable(&admin);
3256 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3257 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3258 }
3259 /**
3260 * @tc.name: TestGetDevicePolicyInnerWithoutAdminSuc
3261 * @tc.desc: Test GetDevicePolicyInner function success without admin.
3262 * @tc.type: FUNC
3263 */
3264 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDevicePolicyInnerWithoutAdminSuc, TestSize.Level1)
3265 {
3266 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3267
3268 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, WITHOUT_ADMIN_SUCCESS_POLICY_CODE);
3269 MessageParcel data;
3270 MessageParcel reply;
3271 data.WriteInt32(1);
3272 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3273 EDM_MANAGE_DATETIME_PERMISSION;
3274 PluginManager::GetInstance()->NotifyUnloadAllPlugin();
3275 PluginManager::GetInstance()->AddPlugin(plugin_);
3276 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3277 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3278 }
3279
3280 /**
3281 * @tc.name: GetDevicePolicyInnerFuncTest006
3282 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicyInner function.
3283 * @tc.desc: Test if (plugin->NeedSavePolicy())
3284 * @tc.type: FUNC
3285 * @tc.require: issueI5PBT1
3286 */
3287 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyInnerFuncTest006, TestSize.Level1)
3288 {
3289 PrepareBeforeHandleDevicePolicy();
3290 plugin_ = PLUGIN::HandlePolicyBiFunctionUnsavePlg::GetPlugin();
3291 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] =
3292 EDM_MANAGE_DATETIME_PERMISSION;
3293 PluginManager::GetInstance()->pluginsCode_.clear();
3294 PluginManager::GetInstance()->pluginsName_.clear();
3295 PluginManager::GetInstance()->AddPlugin(plugin_);
3296
3297 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3298 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3299 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3300 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3301 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3302 Return(ERR_OK)));
3303
3304 uint32_t code =
3305 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE);
3306 AppExecFwk::ElementName admin;
3307 admin.SetBundleName(ADMIN_PACKAGENAME);
3308 MessageParcel data;
3309 MessageParcel reply;
3310 data.WriteString("");
3311 data.WriteInt32(0);
3312 data.WriteParcelable(&admin);
3313 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3314 ASSERT_TRUE(reply.ReadInt32() == ERR_OK);
3315 }
3316
3317 /**
3318 * @tc.name: GetDevicePolicyInnerFuncTest007
3319 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicyInner function.
3320 * @tc.desc: Test if admin != nullptr && (deviceAdmin->CheckPermission fail)
3321 * @tc.type: FUNC
3322 * @tc.require: issueI5PBT1
3323 */
3324 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyInnerFuncTest007, TestSize.Level1)
3325 {
3326 PrepareBeforeHandleDevicePolicy();
3327 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3328 PluginManager::GetInstance()->AddPlugin(plugin_);
3329
3330 EXPECT_CALL(*osAccountMgrMock_, IsOsAccountExists).WillOnce(DoAll(SetArgReferee<1>(true), Return(ERR_OK)));
3331 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3332 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3333 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3334 Return(ERR_OK)));
3335
3336 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, MAP_TESTPLUGIN_POLICYCODE);
3337 AppExecFwk::ElementName admin;
3338 admin.SetBundleName(ADMIN_PACKAGENAME_FAILED);
3339 MessageParcel data;
3340 MessageParcel reply;
3341 data.WriteString("");
3342 data.WriteInt32(0);
3343 data.WriteParcelable(&admin);
3344 edmMgr_->GetDevicePolicyInner(code, data, reply, DEFAULT_USER_ID);
3345 ASSERT_TRUE(reply.ReadInt32() == EdmReturnErrCode::PERMISSION_DENIED);
3346 }
3347
3348 /**
3349 * @tc.name: TestSetDelegatedPoliciesWithoutAdmin
3350 * @tc.desc: Test SetDelegatedPolicies without administrator.
3351 * @tc.type: FUNC
3352 */
3353 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithoutAdmin, TestSize.Level1)
3354 {
3355 AppExecFwk::ElementName admin;
3356 admin.SetBundleName(ADMIN_PACKAGENAME);
3357 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3358
3359 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {});
3360 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
3361 }
3362
3363 /**
3364 * @tc.name: TestSetDelegatedPoliciesWithoutSDA
3365 * @tc.desc: Test SetDelegatedPolicies without administrator.
3366 * @tc.type: FUNC
3367 */
3368 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithoutSDA, TestSize.Level1)
3369 {
3370 AppExecFwk::ElementName admin;
3371 admin.SetBundleName(ADMIN_PACKAGENAME);
3372 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3373 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
3374
3375 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3376 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3377 Return(ERR_OK)));
3378 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3379 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3380
3381 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {});
3382 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
3383
3384 DisableAdminSuc(admin, DEFAULT_USER_ID);
3385 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3386 EXPECT_TRUE(normalAdmin == nullptr);
3387 }
3388
3389 /**
3390 * @tc.name: TestSetDelegatedPoliciesWithoutPermission
3391 * @tc.desc: Test SetDelegatedPolicies without permission.
3392 * @tc.type: FUNC
3393 */
3394 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithoutPermission, TestSize.Level1)
3395 {
3396 AppExecFwk::ElementName admin;
3397 admin.SetBundleName(ADMIN_PACKAGENAME);
3398 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3399 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
3400
3401 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3402 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3403 Return(ERR_OK)));
3404 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
3405
3406 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {});
3407 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
3408
3409 DisableAdminSuc(admin, DEFAULT_USER_ID);
3410 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3411 EXPECT_TRUE(normalAdmin == nullptr);
3412 }
3413
3414 /**
3415 * @tc.name: TestSetDelegatedPoliciesWithCallingUidFailed
3416 * @tc.desc: Test SetDelegatedPolicies with calling uid failed.
3417 * @tc.type: FUNC
3418 */
3419 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithCallingUidFailed, TestSize.Level1)
3420 {
3421 AppExecFwk::ElementName admin;
3422 admin.SetBundleName(ADMIN_PACKAGENAME);
3423 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3424 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
3425
3426 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3427 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3428 Return(ERR_OK)));
3429 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3430 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(Return(1)));
3431
3432 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {});
3433 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
3434
3435 DisableAdminSuc(admin, DEFAULT_USER_ID);
3436 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3437 EXPECT_TRUE(normalAdmin == nullptr);
3438 }
3439
3440 /**
3441 * @tc.name: TestSetDelegatedPoliciesWithEmptyPolicy
3442 * @tc.desc: Test SetDelegatedPolicies with empty policy.
3443 * @tc.type: FUNC
3444 */
3445 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithEmptyPolicy, TestSize.Level1)
3446 {
3447 AppExecFwk::ElementName admin;
3448 admin.SetBundleName(ADMIN_PACKAGENAME);
3449 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3450 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3451
3452 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3453 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3454 Return(ERR_OK)));
3455 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3456 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3457
3458 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {});
3459 ASSERT_TRUE(ret == ERR_OK);
3460
3461 DisableSuperAdminSuc(admin.GetBundleName());
3462 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3463 EXPECT_TRUE(superAdmin == nullptr);
3464 }
3465
3466 /**
3467 * @tc.name: TestSetDelegatedPoliciesWithInvalidPolicy
3468 * @tc.desc: Test SetDelegatedPolicies with invalid policy.
3469 * @tc.type: FUNC
3470 */
3471 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithInvalidPolicy, TestSize.Level1)
3472 {
3473 AppExecFwk::ElementName admin;
3474 admin.SetBundleName(ADMIN_PACKAGENAME);
3475 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3476 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3477
3478 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3479 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3480 Return(ERR_OK)));
3481 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3482 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3483
3484 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {"invalide_policy"});
3485 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
3486
3487 DisableSuperAdminSuc(admin.GetBundleName());
3488 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3489 EXPECT_TRUE(superAdmin == nullptr);
3490 }
3491
3492 /**
3493 * @tc.name: TestSetDelegatedPoliciesWithoutPlugin
3494 * @tc.desc: Test SetDelegatedPolicies without plugin.
3495 * @tc.type: FUNC
3496 */
3497 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithoutPlugin, TestSize.Level1)
3498 {
3499 AppExecFwk::ElementName admin;
3500 admin.SetBundleName(ADMIN_PACKAGENAME);
3501 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3502 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3503
3504 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3505 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_ENT_PERMISSION;
3506 PluginManager::GetInstance()->pluginsCode_.clear();
3507 PluginManager::GetInstance()->pluginsName_.clear();
3508 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3509
3510 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3511 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3512 Return(ERR_OK)));
3513 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3514 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3515
3516 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3517 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
3518
3519 DisableSuperAdminSuc(admin.GetBundleName());
3520 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3521 EXPECT_TRUE(superAdmin == nullptr);
3522 }
3523
3524 /**
3525 * @tc.name: TestSetDelegatedPoliciesWithPluginHasNoPermission
3526 * @tc.desc: Test SetDelegatedPolicies with plugin has no permission.
3527 * @tc.type: FUNC
3528 */
3529 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithPluginHasNoPermission, TestSize.Level1)
3530 {
3531 AppExecFwk::ElementName admin;
3532 admin.SetBundleName(ADMIN_PACKAGENAME);
3533 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3534 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3535
3536 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3537 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = "";
3538 PluginManager::GetInstance()->pluginsCode_.clear();
3539 PluginManager::GetInstance()->pluginsName_.clear();
3540 PluginManager::GetInstance()->AddPlugin(plugin_);
3541 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3542
3543 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3544 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3545 Return(ERR_OK)));
3546 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3547 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3548
3549 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3550
3551 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
3552
3553 DisableSuperAdminSuc(admin.GetBundleName());
3554 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3555 EXPECT_TRUE(superAdmin == nullptr);
3556 }
3557
3558 /**
3559 * @tc.name: TestSetDelegatedPoliciesWithNonePermissionMatch
3560 * @tc.desc: Test SetDelegatedPolicies with plugin has none permission match.
3561 * @tc.type: FUNC
3562 */
3563 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithNonePermissionMatch, TestSize.Level1)
3564 {
3565 AppExecFwk::ElementName admin;
3566 admin.SetBundleName(ADMIN_PACKAGENAME);
3567 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3568 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3569
3570 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3571 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = NONE_PERMISSION_MATCH;
3572 PluginManager::GetInstance()->pluginsCode_.clear();
3573 PluginManager::GetInstance()->pluginsName_.clear();
3574 PluginManager::GetInstance()->AddPlugin(plugin_);
3575 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3576
3577 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3578 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3579 Return(ERR_OK)));
3580 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3581 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3582
3583 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3584
3585 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
3586
3587 DisableSuperAdminSuc(admin.GetBundleName());
3588 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3589 EXPECT_TRUE(superAdmin == nullptr);
3590 }
3591
3592 /**
3593 * @tc.name: TestSetDelegatedPoliciesWithDelegatedBundleNotInstall
3594 * @tc.desc: Test SetDelegatedPolicies with delegaed bundle not install.
3595 * @tc.type: FUNC
3596 */
3597 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithDelegatedBundleNotInstall, TestSize.Level1)
3598 {
3599 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3600 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3601 PluginManager::GetInstance()->pluginsCode_.clear();
3602 PluginManager::GetInstance()->pluginsName_.clear();
3603 PluginManager::GetInstance()->AddPlugin(plugin_);
3604 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3605
3606 AppExecFwk::ElementName admin;
3607 admin.SetBundleName(ADMIN_PACKAGENAME);
3608 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3609 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3610
3611 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3612 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3613 Return(ERR_OK)));
3614 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3615 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3616 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(false)));
3617
3618 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3619 ASSERT_TRUE(ret == EdmReturnErrCode::AUTHORIZE_PERMISSION_FAILED);
3620
3621 DisableSuperAdminSuc(ADMIN_PACKAGENAME);
3622 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(ADMIN_PACKAGENAME, DEFAULT_USER_ID);
3623 EXPECT_TRUE(superAdmin == nullptr);
3624 }
3625
3626 /**
3627 * @tc.name: TestSetDelegatedPoliciesWithNormalBundle
3628 * @tc.desc: Test SetDelegatedPolicies with delegaed bundle not enterprise_mdm or enterprise_normal.
3629 * @tc.type: FUNC
3630 */
3631 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithNormalBundle, TestSize.Level1)
3632 {
3633 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3634 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3635 PluginManager::GetInstance()->pluginsCode_.clear();
3636 PluginManager::GetInstance()->pluginsName_.clear();
3637 PluginManager::GetInstance()->AddPlugin(plugin_);
3638 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3639
3640 AppExecFwk::ElementName admin;
3641 admin.SetBundleName(ADMIN_PACKAGENAME);
3642 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3643 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3644
3645 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3646 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3647 Return(ERR_OK)));
3648 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3649 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3650 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
3651 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("normal")));
3652
3653 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3654 ASSERT_TRUE(ret == EdmReturnErrCode::AUTHORIZE_PERMISSION_FAILED);
3655
3656 DisableSuperAdminSuc(admin.GetBundleName());
3657 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3658 EXPECT_TRUE(superAdmin == nullptr);
3659 }
3660
3661 /**
3662 * @tc.name: TestSetDelegatedPoliciesWithEnterpriseNormal
3663 * @tc.desc: Test SetDelegatedPolicies with delegaed bundle is enterprise_normal type.
3664 * @tc.type: FUNC
3665 */
3666 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithEnterpriseNormal, TestSize.Level1)
3667 {
3668 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3669 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3670 PluginManager::GetInstance()->pluginsCode_.clear();
3671 PluginManager::GetInstance()->pluginsName_.clear();
3672 PluginManager::GetInstance()->AddPlugin(plugin_);
3673 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3674
3675 AppExecFwk::ElementName admin;
3676 admin.SetBundleName(ADMIN_PACKAGENAME);
3677 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3678 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3679
3680 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3681 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3682 Return(ERR_OK)));
3683 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3684 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3685 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
3686 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("enterprise_normal")));
3687
3688 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3689 ASSERT_TRUE(ret == ERR_OK);
3690
3691 DisableSuperAdminSuc(admin.GetBundleName());
3692 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3693 EXPECT_TRUE(superAdmin == nullptr);
3694 std::shared_ptr<Admin> virtaulAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(ADMIN_PACKAGENAME_1, DEFAULT_USER_ID);
3695 EXPECT_TRUE(virtaulAdmin == nullptr);
3696 }
3697
3698 /**
3699 * @tc.name: TestGetDelegatedPoliciesWithoutPermission
3700 * @tc.desc: Test GetDelegatedPolicies without permission.
3701 * @tc.type: FUNC
3702 */
3703 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedPoliciesWithoutPermission, TestSize.Level1)
3704 {
3705 AppExecFwk::ElementName admin;
3706 admin.SetBundleName(ADMIN_PACKAGENAME);
3707 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3708 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
3709
3710 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3711 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3712 Return(ERR_OK)));
3713 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
3714
3715 std::vector<std::string> policies;
3716 ErrCode ret = edmMgr_->GetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, policies);
3717 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
3718
3719 DisableAdminSuc(admin, DEFAULT_USER_ID);
3720 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3721 EXPECT_TRUE(normalAdmin == nullptr);
3722 }
3723
3724 /**
3725 * @tc.name: TestGetDelegatedPoliciesWithoutVritualAdmin
3726 * @tc.desc: Test GetDelegatedPolicies success.
3727 * @tc.type: FUNC
3728 */
3729 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedPoliciesWithoutVritualAdmin, TestSize.Level1)
3730 {
3731 AppExecFwk::ElementName admin;
3732 admin.SetBundleName(ADMIN_PACKAGENAME);
3733 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3734 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3735
3736 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3737 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3738 Return(ERR_OK)));
3739 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3740 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3741
3742 std::vector<std::string> policies;
3743 ErrCode ret = edmMgr_->GetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, policies);
3744 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
3745
3746 DisableSuperAdminSuc(admin.GetBundleName());
3747 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3748 EXPECT_TRUE(superAdmin == nullptr);
3749 }
3750
3751 /**
3752 * @tc.name: TestGetDelegatedPoliciesWithVritualAdmin
3753 * @tc.desc: Test GetDelegatedPolicies success.
3754 * @tc.type: FUNC
3755 */
3756 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedPoliciesWithVritualAdmin, TestSize.Level1)
3757 {
3758 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3759 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3760 PluginManager::GetInstance()->pluginsCode_.clear();
3761 PluginManager::GetInstance()->pluginsName_.clear();
3762 PluginManager::GetInstance()->AddPlugin(plugin_);
3763 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3764
3765 AppExecFwk::ElementName admin;
3766 admin.SetBundleName(ADMIN_PACKAGENAME);
3767 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3768 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3769
3770 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3771 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3772 Return(ERR_OK)));
3773 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillRepeatedly(DoAll(Return(true)));
3774 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillRepeatedly(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
3775 Return(ERR_OK)));
3776 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
3777 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("enterprise_normal")));
3778
3779 ErrCode ret = edmMgr_->SetDelegatedPolicies(admin, ADMIN_PACKAGENAME_1, {plugin_->GetPolicyName()});
3780 ASSERT_TRUE(ret == ERR_OK);
3781
3782 std::vector<std::string> bundleNames;
3783 ret = edmMgr_->GetDelegatedBundleNames(admin, plugin_->GetPolicyName(), bundleNames);
3784 ASSERT_TRUE(ret == ERR_OK);
3785
3786 std::shared_ptr<Admin> virtualAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(ADMIN_PACKAGENAME_1, DEFAULT_USER_ID);
3787 ASSERT_TRUE(virtualAdmin != nullptr);
3788 EXPECT_TRUE(virtualAdmin->adminInfo_.adminType_ == AdminType::VIRTUAL_ADMIN);
3789 ASSERT_TRUE(virtualAdmin->adminInfo_.accessiblePolicies_.size() == 1);
3790 EXPECT_EQ(virtualAdmin->adminInfo_.accessiblePolicies_[0], plugin_->GetPolicyName());
3791
3792 DisableSuperAdminSuc(admin.GetBundleName());
3793 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3794 EXPECT_TRUE(superAdmin == nullptr);
3795 virtualAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(ADMIN_PACKAGENAME_1, DEFAULT_USER_ID);
3796 EXPECT_TRUE(virtualAdmin == nullptr);
3797 }
3798
3799 /**
3800 * @tc.name: TestGetDelegatedBundleNamesWithoutPermission
3801 * @tc.desc: Test GetDelegatedBundleNames without permission.
3802 * @tc.type: FUNC
3803 */
3804 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedBundleNamesWithoutPermission, TestSize.Level1)
3805 {
3806 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3807 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3808 PluginManager::GetInstance()->pluginsCode_.clear();
3809 PluginManager::GetInstance()->pluginsName_.clear();
3810 PluginManager::GetInstance()->AddPlugin(plugin_);
3811 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3812
3813 AppExecFwk::ElementName admin;
3814 admin.SetBundleName(ADMIN_PACKAGENAME);
3815 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3816 EnableAdminSuc(admin, AdminType::NORMAL, DEFAULT_USER_ID);
3817
3818 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3819 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3820 Return(ERR_OK)));
3821 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
3822
3823 std::vector<std::string> bundleNames;
3824 ErrCode ret = edmMgr_->GetDelegatedBundleNames(admin, plugin_->GetPolicyName(), bundleNames);
3825 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
3826
3827 DisableAdminSuc(admin, DEFAULT_USER_ID);
3828 std::shared_ptr<Admin> normalAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3829 EXPECT_TRUE(normalAdmin == nullptr);
3830 }
3831
3832 /**
3833 * @tc.name: TestGetDelegatedBundleNamesWithInvalidPolicy
3834 * @tc.desc: Test GetDelegatedBundleNames with invalid policy.
3835 * @tc.type: FUNC
3836 */
3837 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedBundleNamesWithInvalidPolicy, TestSize.Level1)
3838 {
3839 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3840 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3841 PluginManager::GetInstance()->pluginsCode_.clear();
3842 PluginManager::GetInstance()->pluginsName_.clear();
3843 PluginManager::GetInstance()->AddPlugin(plugin_);
3844 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3845
3846 AppExecFwk::ElementName admin;
3847 admin.SetBundleName(ADMIN_PACKAGENAME);
3848 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3849 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3850
3851 std::vector<std::string> bundleNames;
3852 ErrCode ret = edmMgr_->GetDelegatedBundleNames(admin, "invalid", bundleNames);
3853 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
3854
3855 DisableSuperAdminSuc(admin.GetBundleName());
3856 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3857 EXPECT_TRUE(superAdmin == nullptr);
3858 }
3859
3860 /**
3861 * @tc.name: TestGetDelegatedBundleNamesSuc
3862 * @tc.desc: Test GetDelegatedBundleNames success.
3863 * @tc.type: FUNC
3864 */
3865 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetDelegatedBundleNamesSuc, TestSize.Level1)
3866 {
3867 plugin_ = PLUGIN::StringTestPlugin::GetPlugin();
3868 plugin_->permissionConfig_.typePermissions[IPlugin::PermissionType::NORMAL_DEVICE_ADMIN] = EDM_TEST_PERMISSION;
3869 PluginManager::GetInstance()->pluginsCode_.clear();
3870 PluginManager::GetInstance()->pluginsName_.clear();
3871 PluginManager::GetInstance()->AddPlugin(plugin_);
3872 permissionCheckerMock_->allowDelegatedPolicies_ = { plugin_->GetPolicyName() };
3873
3874 AppExecFwk::ElementName admin;
3875 admin.SetBundleName(ADMIN_PACKAGENAME);
3876 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3877 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3878
3879 std::vector<int32_t> ids = {DEFAULT_USER_ID};
3880 EXPECT_CALL(*osAccountMgrMock_, QueryActiveOsAccountIds).WillRepeatedly(DoAll(SetArgReferee<0>(ids),
3881 Return(ERR_OK)));
3882 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3883 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME), Return(ERR_OK)));
3884
3885 std::vector<std::string> bundleNames;
3886 ErrCode ret = edmMgr_->GetDelegatedBundleNames(admin, plugin_->GetPolicyName(), bundleNames);
3887 ASSERT_TRUE(ret == ERR_OK);
3888
3889 DisableSuperAdminSuc(admin.GetBundleName());
3890 std::shared_ptr<Admin> superAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
3891 EXPECT_TRUE(superAdmin == nullptr);
3892 }
3893
3894 /**
3895 * @tc.name: TestReplaceSuperAdmin
3896 * @tc.desc: Test TestReplaceSuperAdmin suc and keep policy.
3897 * @tc.type: FUNC
3898 */
3899 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestReplaceSuperAdmin, TestSize.Level1)
3900 {
3901 AppExecFwk::ElementName admin;
3902 admin.SetBundleName(ADMIN_PACKAGENAME);
3903 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3904 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3905 AppExecFwk::ElementName replaceAdmin;
3906 replaceAdmin.SetBundleName(ADMIN_PACKAGENAME_1);
3907 replaceAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
3908 bool isKeepPolicy = true;
3909 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
3910 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(true)));
3911 QueryExtensionAbilityInfosMock(true, replaceAdmin.GetBundleName());
3912 GetBundleInfoMock(true, EDM_TEST_PERMISSION);
3913 ErrCode err = edmMgr_->ReplaceSuperAdmin(admin, replaceAdmin, isKeepPolicy);
3914 ASSERT_TRUE(err == ERR_OK);
3915 }
3916
3917 /**
3918 * @tc.name: TestReplaceSuperAdmin
3919 * @tc.desc: Test TestReplaceSuperAdmin suc but not keep policy.
3920 * @tc.type: FUNC
3921 */
3922 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestReplaceSuperAdmin001, TestSize.Level1)
3923 {
3924 AppExecFwk::ElementName admin;
3925 admin.SetBundleName(ADMIN_PACKAGENAME);
3926 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3927 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3928 AppExecFwk::ElementName replaceAdmin;
3929 replaceAdmin.SetBundleName(ADMIN_PACKAGENAME_1);
3930 replaceAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
3931 bool isKeepPolicy = false;
3932 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
3933 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(true)));
3934 QueryExtensionAbilityInfosMock(true, replaceAdmin.GetBundleName());
3935 GetBundleInfoMock(true, EDM_TEST_PERMISSION);
3936 ErrCode err = edmMgr_->ReplaceSuperAdmin(admin, replaceAdmin, isKeepPolicy);
3937 ASSERT_TRUE(err == ERR_OK);
3938 }
3939
3940 /**
3941 * @tc.name: TestReplaceSuperAdmin
3942 * @tc.desc: Test TestReplaceSuperAdmin without permission.
3943 * @tc.type: FUNC
3944 */
3945 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestReplaceSuperAdmin002, TestSize.Level1)
3946 {
3947 AppExecFwk::ElementName admin;
3948 admin.SetBundleName(ADMIN_PACKAGENAME);
3949 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3950 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3951 AppExecFwk::ElementName replaceAdmin;
3952 replaceAdmin.SetBundleName(ADMIN_PACKAGENAME_1);
3953 replaceAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
3954 bool isKeepPolicy = false;
3955 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
3956 ErrCode err = edmMgr_->ReplaceSuperAdmin(admin, replaceAdmin, isKeepPolicy);
3957 ASSERT_TRUE(err == EdmReturnErrCode::PERMISSION_DENIED);
3958 }
3959
3960 /**
3961 * @tc.name: TestReplaceSuperAdmin
3962 * @tc.desc: Test TestReplaceSuperAdmin without extensionAbility.
3963 * @tc.type: FUNC
3964 */
3965 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestReplaceSuperAdmin003, TestSize.Level1)
3966 {
3967 AppExecFwk::ElementName admin;
3968 admin.SetBundleName(ADMIN_PACKAGENAME);
3969 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3970 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
3971 AppExecFwk::ElementName replaceAdmin;
3972 replaceAdmin.SetBundleName(ADMIN_PACKAGENAME_1);
3973 replaceAdmin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY_1);
3974 bool isKeepPolicy = false;
3975 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
3976 QueryExtensionAbilityInfosMock(false, replaceAdmin.GetBundleName());
3977 ErrCode err = edmMgr_->ReplaceSuperAdmin(admin, replaceAdmin, isKeepPolicy);
3978 ASSERT_TRUE(err == EdmReturnErrCode::COMPONENT_INVALID);
3979 }
3980
3981 /**
3982 * @tc.name: TestEnableAndDisableBYODAdmin
3983 * @tc.desc: Test enable and disable BYOD admin.
3984 * @tc.type: FUNC
3985 */
3986 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestEnableAndDisableBYODAdmin, TestSize.Level1)
3987 {
3988 // enable byod admin
3989 AppExecFwk::ElementName admin;
3990 admin.SetBundleName(ADMIN_PACKAGENAME);
3991 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
3992 EnableAdminSuc(admin, AdminType::BYOD, DEFAULT_USER_ID);
3993 // disable byod admin
3994 DisableAdminSuc(admin, DEFAULT_USER_ID);
3995 }
3996
3997 /**
3998 * @tc.name: TestIsByodAdmin001
3999 * @tc.desc: Test IsByodAdmin without permission.
4000 * @tc.type: FUNC
4001 */
4002 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestIsByodAdmin001, TestSize.Level1)
4003 {
4004 AppExecFwk::ElementName admin;
4005 admin.SetBundleName(ADMIN_PACKAGENAME);
4006 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4007 EnableAdminSuc(admin, AdminType::BYOD, DEFAULT_USER_ID);
4008 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4009 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(false)));
4010 bool isByod = false;
4011 ErrCode ret = edmMgr_->IsByodAdmin(admin, isByod);
4012 DisableAdminSuc(admin, DEFAULT_USER_ID);
4013 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
4014 }
4015
4016 /**
4017 * @tc.name: TestIsByodAdmin002
4018 * @tc.desc: Test IsByodAdmin with GetHapTokenInfoFaild.
4019 * @tc.type: FUNC
4020 */
4021 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestIsByodAdmin002, TestSize.Level1)
4022 {
4023 AppExecFwk::ElementName admin;
4024 admin.SetBundleName(ADMIN_PACKAGENAME);
4025 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4026 EnableAdminSuc(admin, AdminType::BYOD, DEFAULT_USER_ID);
4027 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4028 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(true)));
4029 bool isByod = false;
4030 ErrCode ret = edmMgr_->IsByodAdmin(admin, isByod);
4031 DisableAdminSuc(admin, DEFAULT_USER_ID);
4032 ASSERT_TRUE(ret == EdmReturnErrCode::PARAMETER_VERIFICATION_FAILED);
4033 }
4034
4035 /**
4036 * @tc.name: TestCheckAndGetAdminProvisionInfoWithAdminExists
4037 * @tc.desc: Test CheckAndGetAdminProvisionInfo With Admin Exists.
4038 * @tc.type: FUNC
4039 */
4040 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckAndGetAdminProvisionInfoWithAdminExits, TestSize.Level1)
4041 {
4042 AppExecFwk::ElementName admin;
4043 admin.SetBundleName(ADMIN_PACKAGENAME);
4044 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4045 EnableAdminSuc(admin, AdminType::BYOD, DEFAULT_USER_ID);
4046
4047 MessageParcel data;
4048 MessageParcel reply;
4049 std::uint32_t funcCode =
4050 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::GET, (std::uint32_t)EdmInterfaceCode::GET_ADMINPROVISION_INFO);
4051 ErrCode ret = edmMgr_->CheckAndGetAdminProvisionInfo(funcCode, data, reply, DEFAULT_USER_ID);
4052 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
4053
4054 DisableAdminSuc(admin, DEFAULT_USER_ID);
4055 std::shared_ptr<Admin> byodAdmin = edmMgr_->adminMgr_->GetAdminByPkgName(admin.GetBundleName(), DEFAULT_USER_ID);
4056 EXPECT_TRUE(byodAdmin == nullptr);
4057 }
4058
4059 /**
4060 * @tc.name: TestCheckAndGetAdminProvisionInfoWithoutAdmin
4061 * @tc.desc: Test CheckAndGetAdminProvisionInfo without admin.
4062 * @tc.type: FUNC
4063 */
4064 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckAndGetAdminProvisionInfoWithoutAdmin, TestSize.Level1)
4065 {
4066 MessageParcel data;
4067 MessageParcel reply;
4068 std::uint32_t funcCode =
4069 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::GET, (std::uint32_t)EdmInterfaceCode::GET_ADMINPROVISION_INFO);
4070 ErrCode ret = edmMgr_->CheckAndGetAdminProvisionInfo(funcCode, data, reply, DEFAULT_USER_ID);
4071 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
4072 }
4073
4074 /**
4075 * @tc.name: TestCheckAndGetAdminProvisionInfoWithoutPermission
4076 * @tc.desc: Test CheckAndGetAdminProvisionInfo without permission.
4077 * @tc.type: FUNC
4078 */
4079 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckAndGetAdminProvisionInfoWithoutPermission, TestSize.Level1)
4080 {
4081 AppExecFwk::ElementName admin;
4082 admin.SetBundleName(ADMIN_PACKAGENAME);
4083 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4084 MessageParcel data;
4085 MessageParcel reply;
4086 data.WriteParcelable(&admin);
4087 std::uint32_t funcCode =
4088 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::GET, (std::uint32_t)EdmInterfaceCode::GET_ADMINPROVISION_INFO);
4089 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4090 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(false)));
4091 ErrCode ret = edmMgr_->CheckAndGetAdminProvisionInfo(funcCode, data, reply, DEFAULT_USER_ID);
4092 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
4093 }
4094
4095 /**
4096 * @tc.name: TestCheckAndGetAdminProvisionInfoGetHapTokenInfoFaild
4097 * @tc.desc: Test CheckAndGetAdminProvisionInfo with GetHapTokenInfoFaild.
4098 * @tc.type: FUNC
4099 */
4100 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckAndGetAdminProvisionInfoGetHapTokenInfoFaild, TestSize.Level1)
4101 {
4102 AppExecFwk::ElementName admin;
4103 admin.SetBundleName(ADMIN_PACKAGENAME);
4104 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4105 MessageParcel data;
4106 MessageParcel reply;
4107 data.WriteParcelable(&admin);
4108 std::uint32_t funcCode =
4109 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::GET, (std::uint32_t)EdmInterfaceCode::GET_ADMINPROVISION_INFO);
4110 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4111 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(true)));
4112 ErrCode ret = edmMgr_->CheckAndGetAdminProvisionInfo(funcCode, data, reply, DEFAULT_USER_ID);
4113 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
4114 }
4115
4116 /**
4117 * @tc.name: TestCheckDisableAdmin001
4118 * @tc.desc: Test CheckDisableAdmin isDebug is true.
4119 * @tc.type: FUNC
4120 */
4121 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckDisableAdmin001, TestSize.Level1)
4122 {
4123 bool result = edmMgr_->CheckDisableAdmin(ADMIN_PACKAGENAME, AdminType::BYOD, true);
4124 ASSERT_TRUE(result);
4125 }
4126
4127 /**
4128 * @tc.name: TestCheckDisableAdmin002
4129 * @tc.desc: Test CheckDisableAdmin VerifyCallingPermission success.
4130 * @tc.type: FUNC
4131 */
4132 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckDisableAdmin002, TestSize.Level1)
4133 {
4134 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4135 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(true)));
4136 bool result = edmMgr_->CheckDisableAdmin(ADMIN_PACKAGENAME, AdminType::BYOD, false);
4137 ASSERT_TRUE(result);
4138 }
4139
4140 /**
4141 * @tc.name: TestCheckDisableAdmin003
4142 * @tc.desc: Test CheckDisableAdmin with GetHapTokenInfoFailed.
4143 * @tc.type: FUNC
4144 */
4145 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestCheckDisableAdmin003, TestSize.Level1)
4146 {
4147 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission)
4148 .Times(testing::AtLeast(1)).WillRepeatedly(DoAll(Return(false)));
4149 bool result = edmMgr_->CheckDisableAdmin(ADMIN_PACKAGENAME, AdminType::BYOD, false);
4150 ASSERT_FALSE(result);
4151 }
4152
4153 /**
4154 * @tc.name: TestGetAdminsSuc
4155 * @tc.desc: Test GetAdmins success.
4156 * @tc.type: FUNC
4157 */
4158 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestGetAdmins, TestSize.Level1)
4159 {
4160 AppExecFwk::ElementName admin;
4161 admin.SetBundleName(ADMIN_PACKAGENAME);
4162 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4163 EnableAdminSuc(admin, AdminType::BYOD, DEFAULT_USER_ID);
4164
4165 std::vector<std::shared_ptr<AAFwk::Want>> wants;
4166 edmMgr_->GetAdmins(wants);
4167 int32_t wantSize = wants.size();
4168 ASSERT_TRUE(wantSize == 1);
4169 std::shared_ptr<AAFwk::Want> want = wants[0];
4170 ASSERT_TRUE(want != nullptr);
4171 std::string bundleName = want->GetStringParam("bundleName");
4172 EXPECT_TRUE(bundleName == ADMIN_PACKAGENAME);
4173 std::string abilityName = want->GetStringParam("abilityName");
4174 EXPECT_TRUE(abilityName == ADMIN_PACKAGENAME_ABILITY);
4175 int32_t adminType = want->GetIntParam("adminType", -1);
4176 EXPECT_TRUE(adminType == static_cast<int32_t>(AdminType::BYOD));
4177 }
4178
4179 /**
4180 * @tc.name: TestSetAdminRunningModeWithoutPermission
4181 * @tc.desc: Test SetAdminRunningMode func.
4182 * @tc.type: FUNC
4183 */
4184 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetAdminRunningModeWithoutPermission, TestSize.Level1)
4185 {
4186 AppExecFwk::ElementName admin;
4187 admin.SetBundleName(ADMIN_PACKAGENAME);
4188 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4189 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
4190
4191 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
4192 ErrCode res = edmMgr_->SetAdminRunningMode(admin, static_cast<uint32_t>(RunningMode::MULTI_USER));
4193 EXPECT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
4194 DisableSuperAdminSuc(admin.GetBundleName());
4195 }
4196
4197 /**
4198 * @tc.name: TestSetAdminRunningModeWithoutActiveAdmin
4199 * @tc.desc: Test SetAdminRunningMode func.
4200 * @tc.type: FUNC
4201 */
4202 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetAdminRunningModeWithoutActiveAdmin, TestSize.Level1)
4203 {
4204 AppExecFwk::ElementName admin;
4205 admin.SetBundleName(ADMIN_PACKAGENAME);
4206 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4207
4208 ErrCode res = edmMgr_->SetAdminRunningMode(admin, static_cast<uint32_t>(RunningMode::MULTI_USER));
4209 EXPECT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
4210 }
4211
4212 /**
4213 * @tc.name: TestSetAdminRunningModeSuc
4214 * @tc.desc: Test SetAdminRunningMode func.
4215 * @tc.type: FUNC
4216 */
4217 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetAdminRunningModeSuc, TestSize.Level1)
4218 {
4219 AppExecFwk::ElementName admin;
4220 admin.SetBundleName(ADMIN_PACKAGENAME);
4221 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4222 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
4223
4224 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4225 ErrCode res = edmMgr_->SetAdminRunningMode(admin, static_cast<uint32_t>(RunningMode::MULTI_USER));
4226 EXPECT_TRUE(res == ERR_OK);
4227 DisableSuperAdminSuc(admin.GetBundleName());
4228 }
4229
4230 /**
4231 * @tc.name: TestSetDelegatedPoliciesWithPermissionDenied
4232 * @tc.desc: Test SetDelegatedPolicies without permission.
4233 * @tc.type: FUNC
4234 */
4235 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithPermissionDenied, TestSize.Level1)
4236 {
4237 const std::string bundleName = "";
4238 const std::vector<std::string> policies = {};
4239 int32_t userId = 100;
4240 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
4241 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4242 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
4243 }
4244
4245 /**
4246 * @tc.name: TestSetDelegatedPoliciesWithAbnormalPolicy
4247 * @tc.desc: Test SetDelegatedPolicies without abnormal policy.
4248 * @tc.type: FUNC
4249 */
4250 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithAbnormalPolicy, TestSize.Level1)
4251 {
4252 const std::string bundleName = "";
4253 const std::vector<std::string> policies = {"test"};
4254 int32_t userId = 100;
4255 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4256 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4257 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
4258 }
4259
4260 /**
4261 * @tc.name: TestSetDelegatedPoliciesWithadmin
4262 * @tc.desc: Test SetDelegatedPolicies with bundlename is admin.
4263 * @tc.type: FUNC
4264 */
4265 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithadmin, TestSize.Level1)
4266 {
4267 const std::string bundleName = ADMIN_PACKAGENAME;
4268 const std::vector<std::string> policies = {"allow_all"};
4269 int32_t userId = 100;
4270 AppExecFwk::ElementName admin;
4271 admin.SetBundleName(ADMIN_PACKAGENAME);
4272 admin.SetAbilityName(ADMIN_PACKAGENAME_ABILITY);
4273 EnableAdminSuc(admin, AdminType::ENT, DEFAULT_USER_ID);
4274 initPolicies();
4275 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4276 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4277 ASSERT_TRUE(ret == ERR_EDM_ADD_ADMIN_FAILED);
4278 }
4279
4280 /**
4281 * @tc.name: TestSetDelegatedPoliciesWithUninstallBundle
4282 * @tc.desc: Test SetDelegatedPolicies with bundlename is uninstall.
4283 * @tc.type: FUNC
4284 */
4285 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithUninstallBundle, TestSize.Level1)
4286 {
4287 const std::string bundleName = ADMIN_PACKAGENAME;
4288 const std::vector<std::string> policies = {"allow_all"};
4289 int32_t userId = 100;
4290 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4291 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(false)));
4292 initPolicies();
4293 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4294 ASSERT_TRUE(ret == EdmReturnErrCode::AUTHORIZE_PERMISSION_FAILED);
4295 }
4296
4297 /**
4298 * @tc.name: TestSetDelegatedPoliciesWithIsNormalBundle
4299 * @tc.desc: Test SetDelegatedPolicies with bundlename is uninstall.
4300 * @tc.type: FUNC
4301 */
4302 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithIsNormalBundle, TestSize.Level1)
4303 {
4304 const std::string bundleName = ADMIN_PACKAGENAME;
4305 const std::vector<std::string> policies = {"allow_all"};
4306 int32_t userId = 100;
4307 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4308 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
4309 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("normal")));
4310 initPolicies();
4311 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4312 ASSERT_TRUE(ret == EdmReturnErrCode::AUTHORIZE_PERMISSION_FAILED);
4313 }
4314
4315 /**
4316 * @tc.name: TestSetDelegatedPoliciesWithGetNameForUidFailed
4317 * @tc.desc: Test SetDelegatedPolicies with bundlename is uninstall.
4318 * @tc.type: FUNC
4319 */
4320 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesWithGetNameForUidFailed, TestSize.Level1)
4321 {
4322 const std::string bundleName = ADMIN_PACKAGENAME;
4323 const std::vector<std::string> policies = {"allow_all"};
4324 int32_t userId = 100;
4325 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4326 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
4327 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("enterprise_normal")));
4328 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
4329 Return(1)));
4330 initPolicies();
4331 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4332 ASSERT_TRUE(ret == ERR_EDM_PERMISSION_ERROR);
4333 }
4334
4335 /**
4336 * @tc.name: TestSetDelegatedPoliciesSuccess
4337 * @tc.desc: Test SetDelegatedPolicies success.
4338 * @tc.type: FUNC
4339 */
4340 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetDelegatedPoliciesSuccess, TestSize.Level1)
4341 {
4342 const std::string bundleName = ADMIN_PACKAGENAME;
4343 const std::vector<std::string> policies = {"allow_all"};
4344 int32_t userId = 100;
4345 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4346 EXPECT_CALL(*bundleMgrMock_, IsBundleInstalled).WillOnce(DoAll(Return(true)));
4347 EXPECT_CALL(*bundleMgrMock_, GetApplicationInfo).WillOnce(DoAll(Return("enterprise_normal")));
4348 EXPECT_CALL(*bundleMgrMock_, GetNameForUid).WillOnce(DoAll(SetArgReferee<1>(ADMIN_PACKAGENAME),
4349 Return(ERR_OK)));
4350 initPolicies();
4351 ErrCode ret = edmMgr_->SetDelegatedPolicies(bundleName, policies, userId);
4352 ASSERT_TRUE(ret == ERR_OK);
4353 }
4354
4355 /**
4356 * @tc.name: TestSetBundleInstallPoliciesPermissionFailed
4357 * @tc.desc: Test SetDelegatedPolicies permission denied.
4358 * @tc.type: FUNC
4359 */
4360 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetBundleInstallPoliciesPermissionFailed, TestSize.Level1)
4361 {
4362 const std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
4363 int32_t userId = 100;
4364 int32_t policyType = 2;
4365 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(false)));
4366 ErrCode ret = edmMgr_->SetBundleInstallPolicies(bundles, userId, policyType);
4367 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
4368 }
4369
4370 /**
4371 * @tc.name: TestSetBundleInstallPoliciesTypeFailed
4372 * @tc.desc: Test SetDelegatedPolicies with policy type is not support.
4373 * @tc.type: FUNC
4374 */
4375 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetBundleInstallPoliciesTypeFailed, TestSize.Level1)
4376 {
4377 const std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
4378 int32_t userId = 100;
4379 int32_t policyType = 4;
4380 ErrCode ret = edmMgr_->SetBundleInstallPolicies(bundles, userId, policyType);
4381 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
4382 }
4383
4384 /**
4385 * @tc.name: TestSetBundleInstallPoliciesWithInvalidCallingUid
4386 * @tc.desc: Test SetDelegatedPolicies with invalid calling uid.
4387 * @tc.type: FUNC
4388 */
4389 HWTEST_F(EnterpriseDeviceMgrAbilityTest, TestSetBundleInstallPoliciesWithInvalidCallingUid, TestSize.Level1)
4390 {
4391 const std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
4392 int32_t userId = 100;
4393 int32_t policyType = 2;
4394 EXPECT_CALL(*accessTokenMgrMock_, VerifyCallingPermission).WillOnce(DoAll(Return(true)));
4395 ErrCode ret = edmMgr_->SetBundleInstallPolicies(bundles, userId, policyType);
4396 ASSERT_TRUE(ret == EdmReturnErrCode::PERMISSION_DENIED);
4397 }
4398 } // namespace TEST
4399 } // namespace EDM
4400 } // namespace OHOS