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