1 /*
2 * Copyright (c) 2022 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 "iplugin_template.h"
20 #undef protected
21 #undef private
22 #include <gtest/gtest.h>
23 #include <string>
24 #include <vector>
25 #include "accesstoken_kit.h"
26 #include "cmd_utils.h"
27 #include "enterprise_device_mgr_ability_test.h"
28 #include "iplugin_template_test.h"
29 #include "nativetoken_kit.h"
30 #include "plugin_manager_test.h"
31 #include "token_setproc.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace EDM {
37 namespace TEST {
38 constexpr int32_t DEFAULT_USER_ID = 100;
39 constexpr int32_t ARRAY_MAP_TESTPLUGIN_POLICYCODE = 13;
40 constexpr int32_t HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE = 23;
41 constexpr int32_t HANDLE_POLICY_JSON_BIFUNCTIONPLG_POLICYCODE = 30;
42 constexpr int32_t HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE = 31;
43 constexpr int32_t INVALID_POLICYCODE = 123456;
44 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
45 const std::string EDM_MANAGE_DATETIME_PERMISSION = "ohos.permission.ENTERPRISE_SET_DATETIME";
46 const std::string EDM_TEST_PERMISSION = "ohos.permission.EDM_TEST_PERMISSION";
47 const std::string ARRAY_MAP_TESTPLG_POLICYNAME = "ArrayMapTestPlugin";
48 const std::string HANDLE_POLICY_BIFUNCTIONPLG_POLICYNAME = "HandlePolicyBiFunctionPlg";
49 const std::string TEAR_DOWN_CMD = "rm /data/service/el1/public/edm/device_policies.json";
50
NativeTokenGet(const char * perms[],int size)51 void NativeTokenGet(const char* perms[], int size)
52 {
53 uint64_t tokenId;
54 NativeTokenInfoParams infoInstance = {
55 .dcapsNum = 0,
56 .permsNum = size,
57 .aclsNum = 0,
58 .dcaps = nullptr,
59 .perms = perms,
60 .acls = nullptr,
61 .aplStr = "system_basic",
62 };
63
64 infoInstance.processName = "EdmServicesUnitTest";
65 tokenId = GetAccessTokenId(&infoInstance);
66 SetSelfTokenID(tokenId);
67 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
68 }
69
SetUp()70 void EnterpriseDeviceMgrAbilityTest::SetUp()
71 {
72 plugin_ = PLUGIN::ArrayMapTestPlugin::GetPlugin();
73 edmMgr_ = EnterpriseDeviceMgrAbility::GetInstance();
74 edmMgr_->adminMgr_ = AdminManager::GetInstance();
75 edmMgr_->pluginMgr_ = PluginManager::GetInstance();
76 edmMgr_->policyMgr_ = PolicyManager::GetInstance();
77 }
78
TearDown()79 void EnterpriseDeviceMgrAbilityTest::TearDown()
80 {
81 edmMgr_->policyMgr_->SetPolicy(ADMIN_PACKAGENAME, HANDLE_POLICY_BIFUNCTIONPLG_POLICYNAME, "", "");
82 edmMgr_->adminMgr_->instance_.reset();
83 edmMgr_->pluginMgr_->instance_.reset();
84 edmMgr_->policyMgr_->instance_.reset();
85 edmMgr_->instance_.clear();
86 edmMgr_.clear();
87 CmdUtils::ExecCmdSync(TEAR_DOWN_CMD);
88 }
89
90 // Give testAdmin and plugin_ Initial value
PrepareBeforeHandleDevicePolicy()91 void EnterpriseDeviceMgrAbilityTest::PrepareBeforeHandleDevicePolicy()
92 {
93 Admin testAdmin;
94 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
95 testAdmin.adminInfo_.permission_ = {EDM_MANAGE_DATETIME_PERMISSION};
96 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
97 edmMgr_->adminMgr_->admins_.
98 insert(std::pair<int32_t, std::vector<std::shared_ptr<Admin>>>(DEFAULT_USER_ID, adminVec));
99 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
100 edmMgr_->pluginMgr_->AddPlugin(plugin_);
101 }
102
103 /**
104 * @tc.name: HandleDevicePolicyFuncTest001
105 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.(return ERR_OK)
106 * @tc.desc: Test whether HandleDevicePolicy runs to the end
107 * @tc.type: FUNC
108 * @tc.require: issueI5PBT1
109 */
110 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest001, TestSize.Level1)
111 {
112 PrepareBeforeHandleDevicePolicy();
113 const char *perms[] = {EDM_MANAGE_DATETIME_PERMISSION.c_str()};
114 NativeTokenGet(perms, 1);
115 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, ARRAY_MAP_TESTPLUGIN_POLICYCODE);
116 AppExecFwk::ElementName elementName;
117 elementName.SetBundleName(ADMIN_PACKAGENAME);
118 MessageParcel data;
119 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
120 ASSERT_TRUE(res == ERR_OK);
121 }
122 /**
123 * @tc.name: HandleDevicePolicyFuncTest002
124 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.(if (deviceAdmin == nullptr))
125 * @tc.desc: Test if deviceAdmin is empty
126 * @tc.type: FUNC
127 * @tc.require: issueI5PBT1
128 */
129 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest002, TestSize.Level1)
130 {
131 PrepareBeforeHandleDevicePolicy();
132 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, ARRAY_MAP_TESTPLUGIN_POLICYCODE);
133 AppExecFwk::ElementName elementName;
134 elementName.SetBundleName("com.edm.test.demoFail");
135 MessageParcel data;
136 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
137 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_INACTIVE);
138 }
139
140 /**
141 * @tc.name: HandleDevicePolicyFuncTest003
142 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.(if (plugin == nullptr))
143 * @tc.desc: Test if plugin is empty
144 * @tc.type: FUNC
145 * @tc.require: issueI5PBT1
146 */
147 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest003, TestSize.Level1)
148 {
149 PrepareBeforeHandleDevicePolicy();
150 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
151 AppExecFwk::ElementName elementName;
152 elementName.SetBundleName(ADMIN_PACKAGENAME);
153 MessageParcel data;
154 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
155 ASSERT_TRUE(res == EdmReturnErrCode::INTERFACE_UNSUPPORTED);
156 }
157
158 /**
159 * @tc.name: HandleDevicePolicyFuncTest004
160 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
161 * @tc.desc: if (!deviceAdmin->CheckPermission(plugin->GetPermission()))
162 * @tc.type: FUNC
163 * @tc.require: issueI5PBT1
164 */
165 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest004, TestSize.Level1)
166 {
167 PrepareBeforeHandleDevicePolicy();
168 Admin testAdmin;
169 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
170 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
171 edmMgr_->adminMgr_->admins_.clear();
172 edmMgr_->adminMgr_->admins_.
173 insert(std::pair<int32_t, std::vector<std::shared_ptr<Admin>>>(DEFAULT_USER_ID, adminVec));
174 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, ARRAY_MAP_TESTPLUGIN_POLICYCODE);
175 AppExecFwk::ElementName elementName;
176 elementName.SetBundleName(ADMIN_PACKAGENAME);
177 MessageParcel data;
178 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
179 ASSERT_TRUE(res == EdmReturnErrCode::ADMIN_EDM_PERMISSION_DENIED);
180 }
181
182 /**
183 * @tc.name: HandleDevicePolicyFuncTest005
184 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
185 * @tc.desc: if (!VerifyCallingPermission(plugin->GetPermission()))
186 * @tc.type: FUNC
187 * @tc.require: issueI5PBT1
188 */
189 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest005, TestSize.Level1)
190 {
191 PrepareBeforeHandleDevicePolicy();
192 Admin testAdmin;
193 testAdmin.adminInfo_.packageName_ = ADMIN_PACKAGENAME;
194 testAdmin.adminInfo_.permission_ = {EDM_TEST_PERMISSION};
195 std::vector<std::shared_ptr<Admin>> adminVec = {std::make_shared<Admin>(testAdmin)};
196 edmMgr_->adminMgr_->admins_.clear();
197 edmMgr_->adminMgr_->admins_.
198 insert(std::pair<int32_t, std::vector<std::shared_ptr<Admin>>>(DEFAULT_USER_ID, adminVec));
199 plugin_->permission_ = EDM_TEST_PERMISSION;
200 edmMgr_->pluginMgr_->pluginsCode_.clear();
201 edmMgr_->pluginMgr_->pluginsName_.clear();
202 edmMgr_->pluginMgr_->AddPlugin(plugin_);
203 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, ARRAY_MAP_TESTPLUGIN_POLICYCODE);
204 AppExecFwk::ElementName elementName;
205 elementName.SetBundleName(ADMIN_PACKAGENAME);
206 MessageParcel data;
207 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
208 ASSERT_TRUE(res == EdmReturnErrCode::PERMISSION_DENIED);
209 }
210
211 /**
212 * @tc.name: HandleDevicePolicyFuncTest006
213 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
214 * @tc.desc: plugin->OnHandlePolicy(code, data, policyValue, isChanged)
215 * @tc.desc: Test the result of plugin->OnHandlePolicy is not OK
216 * @tc.type: FUNC
217 * @tc.require: issueI5PBT1
218 */
219 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest006, TestSize.Level1)
220 {
221 PrepareBeforeHandleDevicePolicy();
222 const char *perms[] = {EDM_MANAGE_DATETIME_PERMISSION.c_str()};
223 NativeTokenGet(perms, 1);
224 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
225 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
226 edmMgr_->pluginMgr_->pluginsCode_.clear();
227 edmMgr_->pluginMgr_->pluginsName_.clear();
228 edmMgr_->pluginMgr_->AddPlugin(plugin_);
229 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
230 AppExecFwk::ElementName elementName;
231 elementName.SetBundleName(ADMIN_PACKAGENAME);
232 MessageParcel data;
233 data.WriteString16(Str8ToStr16("ErrorData"));
234 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
235 ASSERT_TRUE(res == ERR_EDM_OPERATE_JSON);
236 }
237
238 /**
239 * @tc.name: HandleDevicePolicyFuncTest007
240 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.(if (plugin->NeedSavePolicy() && isChanged))
241 * @tc.desc: Test run into the branch if (plugin ->NeedSavePolicy() && isChanged)
242 * @tc.type: FUNC
243 * @tc.require: issueI5PBT1
244 */
245 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest007, TestSize.Level1)
246 {
247 PrepareBeforeHandleDevicePolicy();
248 const char *perms[] = {EDM_MANAGE_DATETIME_PERMISSION.c_str()};
249 NativeTokenGet(perms, 1);
250 plugin_ = PLUGIN::HandlePolicyBiFunctionPlg::GetPlugin();
251 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
252 edmMgr_->pluginMgr_->pluginsCode_.clear();
253 edmMgr_->pluginMgr_->pluginsName_.clear();
254 edmMgr_->pluginMgr_->AddPlugin(plugin_);
255 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTIONPLG_POLICYCODE);
256 AppExecFwk::ElementName elementName;
257 elementName.SetBundleName(ADMIN_PACKAGENAME);
258 MessageParcel data;
259 data.WriteString16(Str8ToStr16("testValue"));
260 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
261 ASSERT_TRUE(res == ERR_OK);
262
263 plugin_ = PLUGIN::HandlePolicyBiFunctionUnsavePlg::GetPlugin();
264 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
265 edmMgr_->pluginMgr_->pluginsCode_.clear();
266 edmMgr_->pluginMgr_->pluginsName_.clear();
267 edmMgr_->pluginMgr_->AddPlugin(plugin_);
268 code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, HANDLE_POLICY_BIFUNCTION_UNSAVE_PLG_POLICYCODE);
269 data.WriteString16(Str8ToStr16("{\"name\" : \"testValue\"}"));
270 res = edmMgr_->HandleDevicePolicy(code, elementName, data);
271 ASSERT_TRUE(res == ERR_OK);
272 }
273
274 /**
275 * @tc.name: HandleDevicePolicyFuncTest008
276 * @tc.desc: Test EnterpriseDeviceMgrAbility::HandleDevicePolicy function.
277 * @tc.desc: run into plugin->MergePolicyData(admin.GetBundleName(), mergedPolicy)
278 * @tc.desc: Test the MergePolicyData processing result is not OK
279 * @tc.type: FUNC
280 * @tc.require: issueI5PBT1
281 */
282 HWTEST_F(EnterpriseDeviceMgrAbilityTest, HandleDevicePolicyFuncTest008, TestSize.Level1)
283 {
284 PrepareBeforeHandleDevicePolicy();
285 const char *perms[] = {EDM_MANAGE_DATETIME_PERMISSION.c_str()};
286 NativeTokenGet(perms, 1);
287 plugin_ = PLUGIN::HandlePolicyJsonBiFunctionPlg::GetPlugin();
288 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
289 edmMgr_->pluginMgr_->pluginsCode_.clear();
290 edmMgr_->pluginMgr_->pluginsName_.clear();
291 edmMgr_->pluginMgr_->AddPlugin(plugin_);
292 AdminValueItemsMap map;
293 std::string errJsonStr = "v1,v2v3??v4"; // Enter a string that cannot be parsed by JSON
294 map.insert(std::pair<std::string, std::string>(ADMIN_PACKAGENAME, errJsonStr));
295 map.insert(std::pair<std::string, std::string>("com.edm.test.demo2", errJsonStr));
296 edmMgr_->policyMgr_->policyAdmins_.
297 insert(std::pair<std::string, AdminValueItemsMap>("HandlePolicyJsonBiFunctionPlg", map));
298 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET,
299 HANDLE_POLICY_JSON_BIFUNCTIONPLG_POLICYCODE);
300 AppExecFwk::ElementName elementName;
301 elementName.SetBundleName(ADMIN_PACKAGENAME);
302 MessageParcel data;
303 data.WriteString16(Str8ToStr16("{\"name\" : \"testValue\"}"));
304 ErrCode res = edmMgr_->HandleDevicePolicy(code, elementName, data);
305 ASSERT_TRUE(res == ERR_EDM_OPERATE_JSON);
306 }
307
308 /**
309 * @tc.name: GetDevicePolicyFuncTest001
310 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicy function.
311 * @tc.desc: Test if (plugin == nullptr)
312 * @tc.type: FUNC
313 * @tc.require: issueI5PBT1
314 */
315 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyFuncTest001, TestSize.Level1)
316 {
317 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, INVALID_POLICYCODE);
318 AppExecFwk::ElementName *elementName = nullptr;
319 MessageParcel reply;
320 ErrCode res = edmMgr_->GetDevicePolicy(code, elementName, reply);
321 ASSERT_TRUE(res == ERR_EDM_GET_PLUGIN_MGR_FAILED);
322 }
323
324 /**
325 * @tc.name: GetDevicePolicyFuncTest002
326 * @tc.desc: Test EnterpriseDeviceMgrAbility::GetDevicePolicy function.
327 * @tc.desc: Test policyMgr_->GetPolicy(adminName, policyName, policyValue)
328 * @tc.type: FUNC
329 * @tc.require: issueI5PBT1
330 */
331 HWTEST_F(EnterpriseDeviceMgrAbilityTest, GetDevicePolicyFuncTest002, TestSize.Level1)
332 {
333 uint32_t code = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, ARRAY_MAP_TESTPLUGIN_POLICYCODE);
334 AppExecFwk::ElementName admin;
335 admin.SetBundleName(ADMIN_PACKAGENAME);
336 AppExecFwk::ElementName *elementName = &admin;
337 MessageParcel reply;
338 plugin_->permission_ = EDM_MANAGE_DATETIME_PERMISSION;
339 edmMgr_->pluginMgr_->AddPlugin(plugin_);
340 ErrCode res = edmMgr_->GetDevicePolicy(code, elementName, reply);
341 ASSERT_TRUE(res == ERR_OK);
342
343 PolicyItemsMap map;
344 map.insert(std::pair<std::string, std::string>(ARRAY_MAP_TESTPLG_POLICYNAME, "TestValue"));
345 edmMgr_->policyMgr_->adminPolicies_.insert(std::pair<std::string, PolicyItemsMap>(ADMIN_PACKAGENAME, map));
346 res = edmMgr_->GetDevicePolicy(code, elementName, reply);
347 ASSERT_TRUE(res == ERR_OK);
348 }
349 } // namespace TEST
350 } // namespace EDM
351 } // namespace OHOS