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