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