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