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 #include <gtest/gtest.h>
17
18 #include <string>
19 #include <vector>
20
21 #include "edm_sys_manager_mock.h"
22 #include "enterprise_device_mgr_proxy.h"
23 #include "enterprise_device_mgr_stub_mock.h"
24 #include "func_code.h"
25 #include "system_ability_definition.h"
26 #include "utils.h"
27
28 using namespace testing::ext;
29 using ::testing::_;
30 using ::testing::Invoke;
31 using ::testing::Mock;
32 using namespace testing;
33
34 namespace OHOS {
35 namespace EDM {
36 namespace TEST {
37 namespace {
38 constexpr int32_t DEFAULT_USERID = 100;
39 constexpr int32_t FUNC_CODE_ERR = -222;
40 }
41 class EnterpriseDeviceMgrProxyTest : public testing::Test {
42 protected:
43 void SetUp() override;
44
45 void TearDown() override;
46
47 static void TearDownTestSuite(void);
48 std::shared_ptr<EnterpriseDeviceMgrProxy> enterpriseDeviceMgrProxyTest = nullptr;
49 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
50 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
51 };
52
SetUp()53 void EnterpriseDeviceMgrProxyTest::SetUp()
54 {
55 enterpriseDeviceMgrProxyTest = EnterpriseDeviceMgrProxy::GetInstance();
56 edmSysManager_ = std::make_shared<EdmSysManager>();
57 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
58 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
59 Utils::SetEdmServiceEnable();
60 }
61
TearDown()62 void EnterpriseDeviceMgrProxyTest::TearDown()
63 {
64 EnterpriseDeviceMgrProxy::DestroyInstance();
65 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
66 object_ = nullptr;
67 Utils::SetEdmServiceDisable();
68 }
69
TearDownTestSuite()70 void EnterpriseDeviceMgrProxyTest::TearDownTestSuite()
71 {
72 ASSERT_FALSE(Utils::GetEdmServiceState());
73 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
74 }
75
76 /**
77 * @tc.name: TestEnableAdminSuc
78 * @tc.desc: Test EnableAdmin func.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestEnableAdminSuc, TestSize.Level0)
82 {
83 AppExecFwk::ElementName admin;
84 admin.SetBundleName("com.edm.test.demo");
85 admin.SetAbilityName("com.edm.test.demo.Ability");
86 EntInfo entInfo("test", "this is test");
87 EXPECT_CALL(*object_, EnableAdmin(_, _, _, _))
88 .Times(1)
89 .WillOnce(Return(ERR_OK));
90 ErrCode errVal = enterpriseDeviceMgrProxyTest->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USERID);
91 EXPECT_TRUE(errVal == ERR_OK);
92 }
93
94 /**
95 * @tc.name: TestEnableAdminFail
96 * @tc.desc: Test EnableAdmin func.
97 * @tc.type: FUNC
98 */
99 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestEnableAdminFail, TestSize.Level1)
100 {
101 AppExecFwk::ElementName admin;
102 admin.SetBundleName("com.edm.test.demo");
103 admin.SetAbilityName("com.edm.test.demo.Ability");
104 EntInfo entInfo("test", "this is test");
105 EXPECT_CALL(*object_, EnableAdmin(_, _, _, _))
106 .Times(1)
107 .WillOnce(Return(EdmReturnErrCode::SYSTEM_ABNORMALLY));
108 ErrCode errVal = enterpriseDeviceMgrProxyTest->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USERID);
109 EXPECT_TRUE(errVal != ERR_OK);
110 }
111
112 /**
113 * @tc.name: TestSetEnterpriseInfoSuc
114 * @tc.desc: Test SetEnterpriseInfo func.
115 * @tc.type: FUNC
116 */
117 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetEnterpriseInfoSuc, TestSize.Level1)
118 {
119 AppExecFwk::ElementName admin;
120 admin.SetBundleName("com.edm.test.demo");
121 admin.SetAbilityName("com.edm.test.demo.Ability");
122 EntInfo entInfo("test", "this is test");
123 EXPECT_CALL(*object_, SetEnterpriseInfo(_, _))
124 .Times(1)
125 .WillOnce(Return(ERR_OK));
126 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetEnterpriseInfo(admin, entInfo);
127 EXPECT_TRUE(errVal == ERR_OK);
128 }
129
130 /**
131 * @tc.name: TestSetEnterpriseInfoFail
132 * @tc.desc: Test SetEnterpriseInfo func.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetEnterpriseInfoFail, TestSize.Level1)
136 {
137 AppExecFwk::ElementName admin;
138 admin.SetBundleName("com.edm.test.demo");
139 admin.SetAbilityName("com.edm.test.demo.Ability");
140 EntInfo entInfo("test", "this is test");
141 EXPECT_CALL(*object_, SetEnterpriseInfo(_, _))
142 .Times(1)
143 .WillOnce(Return(EdmReturnErrCode::SYSTEM_ABNORMALLY));
144 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetEnterpriseInfo(admin, entInfo);
145 EXPECT_TRUE(errVal != ERR_OK);
146 }
147
148 /**
149 * @tc.name: TestGetEnterpriseInfoEntInfo
150 * @tc.desc: Test GetEnterpriseInfo func.
151 * @tc.type: FUNC
152 */
153 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnterpriseInfoEntInfo, TestSize.Level1)
154 {
155 AppExecFwk::ElementName admin;
156 admin.SetBundleName("com.edm.test.demo");
157 admin.SetAbilityName("com.edm.test.demo.Ability");
158 EXPECT_CALL(*object_, GetEnterpriseInfo(_, _))
159 .Times(1)
160 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeGetEnterpriseInfo));
161 EntInfo entInfo1;
162 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetEnterpriseInfo(admin, entInfo1);
163 EXPECT_TRUE(errVal == ERR_OK);
164 }
165
166 /**
167 * @tc.name: TestGetEnterpriseInfoFail
168 * @tc.desc: Test GetEnterpriseInfo func.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnterpriseInfoFail, TestSize.Level1)
172 {
173 AppExecFwk::ElementName admin;
174 admin.SetBundleName("com.edm.test.demo");
175 admin.SetAbilityName("com.edm.test.demo.Ability");
176 EntInfo entInfo1;
177 EXPECT_CALL(*object_, GetEnterpriseInfo(_, _))
178 .Times(1)
179 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeGetEnterpriseInfoFail));
180 enterpriseDeviceMgrProxyTest->GetEnterpriseInfo(admin, entInfo1);
181 EXPECT_TRUE(entInfo1.enterpriseName.size() == 0);
182 EXPECT_TRUE(entInfo1.description.size() == 0);
183 }
184
185 /**
186 * @tc.name: TestIsAdminEnabledFail
187 * @tc.desc: Test IsAdminEnabled func.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsAdminEnabledFail, TestSize.Level1)
191 {
192 AppExecFwk::ElementName admin;
193 admin.SetBundleName("com.edm.test.demo");
194 admin.SetAbilityName("com.edm.test.demo.Ability");
195 EXPECT_CALL(*object_, IsAdminEnabled(_, _, _))
196 .Times(1)
197 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIsAdminEnabledFail));
198 bool ret = true;
199 enterpriseDeviceMgrProxyTest->IsAdminEnabled(admin, DEFAULT_USERID, ret);
200 EXPECT_FALSE(ret);
201 }
202
203 /**
204 * @tc.name: TestGetEnabledAdminReplyFail
205 * @tc.desc: Test GetEnabledAdmin func.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnabledAdminReplyFail, TestSize.Level1)
209 {
210 EXPECT_CALL(*object_, GetEnabledAdmin(_, _))
211 .Times(1)
212 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
213 std::vector<std::string> enabledAdminList1;
214 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetEnabledAdmin(AdminType::NORMAL, enabledAdminList1);
215 EXPECT_TRUE(errVal != ERR_OK);
216 }
217
218 /**
219 * @tc.name: TestGetEnabledAdminFail
220 * @tc.desc: Test GetEnabledAdmin func.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnabledAdminFail, TestSize.Level1)
224 {
225 std::vector<std::string> enabledAdminList1;
226 EXPECT_CALL(*object_, GetEnabledAdmin(_, _))
227 .Times(1)
228 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
229 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetEnabledAdmin(AdminType::NORMAL, enabledAdminList1);
230 EXPECT_TRUE(errVal != ERR_OK);
231 }
232
233 /**
234 * @tc.name: TestIsPolicyDisabledSuc
235 * @tc.desc: Test IsPolicyDisabled func.
236 * @tc.type: FUNC
237 */
238 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledSuc, TestSize.Level1)
239 {
240 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
241 .Times(1)
242 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
243 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
244 bool isDisabled = false;
245 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, funcCode, isDisabled);
246 EXPECT_TRUE(!isDisabled);
247 }
248
249 /**
250 * @tc.name: TestIsPolicyDisabledFail
251 * @tc.desc: Test IsPolicyDisabled func.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledFail, TestSize.Level1)
255 {
256 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
257 bool isDisabled = false;
258 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
259 .Times(1)
260 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
261 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, funcCode, isDisabled);
262 EXPECT_TRUE(!isDisabled);
263 }
264
265 /**
266 * @tc.name: TestIsPolicyDisabledFuncCodeFail
267 * @tc.desc: Test IsPolicyDisabled func.
268 * @tc.type: FUNC
269 */
270 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledFuncCodeFail, TestSize.Level1)
271 {
272 bool isDisabled = false;
273 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, FUNC_CODE_ERR, isDisabled);
274 EXPECT_TRUE(!isDisabled);
275 }
276
277 /**
278 * @tc.name: TestIsPolicyDisabledWithTagSuc
279 * @tc.desc: Test IsPolicyDisabled func.
280 * @tc.type: FUNC
281 */
282 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledWithTagSuc, TestSize.Level1)
283 {
284 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
285 .Times(1)
286 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
287 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
288 bool isDisabled = false;
289 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, funcCode, isDisabled, "version_11");
290 EXPECT_TRUE(!isDisabled);
291 }
292
293 /**
294 * @tc.name: TestIsPolicyDisabledWithTagFail
295 * @tc.desc: Test IsPolicyDisabled func.
296 * @tc.type: FUNC
297 */
298 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledWithTagFail, TestSize.Level1)
299 {
300 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
301 bool isDisabled = false;
302 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
303 .Times(1)
304 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
305 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, funcCode, isDisabled, "version_11");
306 EXPECT_TRUE(!isDisabled);
307 }
308
309 /**
310 * @tc.name: TestIsPolicyDisabledWithTagFuncCodeFail
311 * @tc.desc: Test IsPolicyDisabled func.
312 * @tc.type: FUNC
313 */
314 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsPolicyDisabledWithTagFuncCodeFail, TestSize.Level1)
315 {
316 bool isDisabled = false;
317 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, FUNC_CODE_ERR, isDisabled, "version_11");
318 EXPECT_TRUE(!isDisabled);
319 }
320
321 /**
322 * @tc.name: TestSetPolicyDisabledSuc
323 * @tc.desc: Test SetPolicyDisabled func.
324 * @tc.type: FUNC
325 */
326 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledSuc, TestSize.Level1)
327 {
328 AppExecFwk::ElementName admin;
329 admin.SetBundleName("com.edm.test.demo");
330 admin.SetAbilityName("com.edm.test.demo.Ability");
331 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
332 .Times(1)
333 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
334 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_PRINTER);
335 bool isDisabled = true;
336 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, funcCode, isDisabled);
337 EXPECT_TRUE(ret == ERR_OK);
338 }
339
340 /**
341 * @tc.name: TestSetPolicyDisabledFail
342 * @tc.desc: Test SetPolicyDisabled func.
343 * @tc.type: FUNC
344 */
345 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledFail, TestSize.Level1)
346 {
347 AppExecFwk::ElementName admin;
348 admin.SetBundleName("com.edm.test.demo");
349 admin.SetAbilityName("com.edm.test.demo.Ability");
350 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_PRINTER);
351 bool isDisabled = true;
352 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
353 .Times(1)
354 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
355 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, funcCode, isDisabled);
356 EXPECT_TRUE(ret != ERR_OK);
357 }
358
359 /**
360 * @tc.name: TestSetPolicyDisabledFuncCodeFail
361 * @tc.desc: Test SetPolicyDisabled func.
362 * @tc.type: FUNC
363 */
364 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledFuncCodeFail, TestSize.Level1)
365 {
366 AppExecFwk::ElementName admin;
367 admin.SetBundleName("com.edm.test.demo");
368 admin.SetAbilityName("com.edm.test.demo.Ability");
369 bool isDisabled = true;
370 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, FUNC_CODE_ERR, isDisabled);
371 EXPECT_TRUE(ret != ERR_OK);
372 }
373
374 /**
375 * @tc.name: TestSetPolicyDisabledWithTagSuc
376 * @tc.desc: Test SetPolicyDisabled func.
377 * @tc.type: FUNC
378 */
379 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledWithTagSuc, TestSize.Level1)
380 {
381 AppExecFwk::ElementName admin;
382 admin.SetBundleName("com.edm.test.demo");
383 admin.SetAbilityName("com.edm.test.demo.Ability");
384 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
385 .Times(1)
386 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
387 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_PRINTER);
388 bool isDisabled = true;
389 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, funcCode, isDisabled, "version_11");
390 EXPECT_TRUE(ret == ERR_OK);
391 }
392
393 /**
394 * @tc.name: TestSetPolicyDisabledWithTagFail
395 * @tc.desc: Test SetPolicyDisabled func.
396 * @tc.type: FUNC
397 */
398 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledWithTagFail, TestSize.Level1)
399 {
400 AppExecFwk::ElementName admin;
401 admin.SetBundleName("com.edm.test.demo");
402 admin.SetAbilityName("com.edm.test.demo.Ability");
403 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_PRINTER);
404 bool isDisabled = true;
405 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
406 .Times(1)
407 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
408 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, funcCode, isDisabled, "version_11");
409 EXPECT_TRUE(ret != ERR_OK);
410 }
411
412 /**
413 * @tc.name: TestSetPolicyDisabledWithTagFuncCodeFail
414 * @tc.desc: Test SetPolicyDisabled func.
415 * @tc.type: FUNC
416 */
417 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetPolicyDisabledWithTagFuncCodeFail, TestSize.Level1)
418 {
419 AppExecFwk::ElementName admin;
420 admin.SetBundleName("com.edm.test.demo");
421 admin.SetAbilityName("com.edm.test.demo.Ability");
422 bool isDisabled = true;
423 int32_t ret = enterpriseDeviceMgrProxyTest->SetPolicyDisabled(admin, FUNC_CODE_ERR, isDisabled, "version_11");
424 EXPECT_TRUE(ret != ERR_OK);
425 }
426
427 /**
428 * @tc.name: TestGetPolicyValueSuc
429 * @tc.desc: Test GetPolicyValue func.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyValueSuc, TestSize.Level1)
433 {
434 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
435 .Times(1)
436 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
437 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
438 std::string policyData;
439 MessageParcel data;
440 data.WriteInt32(HAS_USERID);
441 data.WriteInt32(DEFAULT_USER_ID);
442 data.WriteString(WITHOUT_PERMISSION_TAG);
443 data.WriteInt32(WITHOUT_ADMIN);
444 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyValue(data, funcCode, policyData);
445 EXPECT_TRUE(ret);
446 }
447
448 /**
449 * @tc.name: TestGetPolicyValueReplyFail
450 * @tc.desc: Test GetPolicyValue func.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyValueReplyFail, TestSize.Level1)
454 {
455 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
456 std::string policyData;
457 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
458 .Times(1)
459 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestReplyFail));
460 MessageParcel data;
461 data.WriteInt32(HAS_USERID);
462 data.WriteInt32(DEFAULT_USER_ID);
463 data.WriteString(WITHOUT_PERMISSION_TAG);
464 data.WriteInt32(WITHOUT_ADMIN);
465 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyValue(data, funcCode, policyData);
466 EXPECT_TRUE(!ret);
467 }
468
469 /**
470 * @tc.name: TestHandleDevicePolicyFuncCodeFail
471 * @tc.desc: Test HandleDevicePolicy func.
472 * @tc.type: FUNC
473 */
474 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestHandleDevicePolicyFuncCodeFail, TestSize.Level1)
475 {
476 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
477 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
478 .Times(1)
479 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
480 MessageParcel data;
481 ErrCode errVal = enterpriseDeviceMgrProxyTest->HandleDevicePolicy(funcCode, data);
482 EXPECT_TRUE(errVal != ERR_OK);
483 }
484
485 /**
486 * @tc.name: TestDisableAdminSuc
487 * @tc.desc: Test DisableAdmin func.
488 * @tc.type: FUNC
489 */
490 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableAdminSuc, TestSize.Level1)
491 {
492 AppExecFwk::ElementName admin;
493 admin.SetBundleName("com.edm.test.demo");
494 admin.SetAbilityName("com.edm.test.demo.Ability");
495 EXPECT_CALL(*object_, DisableAdmin(_, _))
496 .Times(1)
497 .WillOnce(Return(ERR_OK));
498 ErrCode errVal = enterpriseDeviceMgrProxyTest->DisableAdmin(admin, DEFAULT_USERID);
499 EXPECT_TRUE(errVal == ERR_OK);
500 }
501
502 /**
503 * @tc.name: TestDisableAdminFail
504 * @tc.desc: Test DisableAdmin func.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableAdminFail, TestSize.Level1)
508 {
509 AppExecFwk::ElementName admin;
510 admin.SetBundleName("com.edm.test.demo");
511 admin.SetAbilityName("com.edm.test.demo.Ability");
512 EXPECT_CALL(*object_, DisableAdmin(_, _))
513 .Times(1)
514 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
515 ErrCode errVal = enterpriseDeviceMgrProxyTest->DisableAdmin(admin, DEFAULT_USERID);
516 EXPECT_TRUE(errVal != ERR_OK);
517 }
518
519 /**
520 * @tc.name: TestGetPolicyArrayEnableAdmin
521 * @tc.desc: Test GetPolicyArray func.
522 * @tc.type: FUNC
523 */
524 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyArrayEnableAdmin, TestSize.Level1)
525 {
526 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
527 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
528 .Times(1)
529 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestEnableAdmin));
530 std::vector<std::string> policyArrayData;
531 enterpriseDeviceMgrProxyTest->GetPolicyArray(nullptr, funcCode, policyArrayData);
532 EXPECT_TRUE(policyArrayData.size() == 1);
533 }
534
535 /**
536 * @tc.name: TestGetPolicyArrayFail
537 * @tc.desc: Test GetPolicyArray func.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyArrayFail, TestSize.Level1)
541 {
542 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
543 std::vector<std::string> policyArrayData;
544 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
545 .Times(1)
546 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
547 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyArray(nullptr, funcCode, policyArrayData);
548 EXPECT_TRUE(!ret);
549 }
550
551 /**
552 * @tc.name: TestGetPolicyArraySuc
553 * @tc.desc: Test GetPolicyArray func.
554 * @tc.type: FUNC
555 */
556 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyArraySuc, TestSize.Level1)
557 {
558 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
559 std::vector<std::string> policyArrayData;
560 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
561 .Times(1)
562 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
563 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyArray(nullptr, funcCode, policyArrayData);
564 EXPECT_TRUE(ret);
565 }
566
567 /**
568 * @tc.name: TestGetPolicyMapSuc
569 * @tc.desc: Test GetPolicyMap func.
570 * @tc.type: FUNC
571 */
572 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyMapSuc, TestSize.Level1)
573 {
574 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
575 std::map<std::string, std::string> policyMapData;
576 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
577 .Times(1)
578 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequest));
579 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyMap(nullptr, funcCode, policyMapData);
580 EXPECT_TRUE(ret);
581 }
582
583 /**
584 * @tc.name: TestGetPolicyMapReplyFail
585 * @tc.desc: Test GetPolicyMap func.
586 * @tc.type: FUNC
587 */
588 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyMapReplyFail, TestSize.Level1)
589 {
590 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
591 std::map<std::string, std::string> policyMapData;
592 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
593 .Times(1)
594 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestReplyFail));
595 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyMap(nullptr, funcCode, policyMapData);
596 EXPECT_FALSE(ret);
597 }
598
599 /**
600 * @tc.name: TestGetPolicyMapEnableAdminNotEqual
601 * @tc.desc: Test GetPolicyMap func.
602 * @tc.type: FUNC
603 */
604 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyMapEnableAdminNotEqual, TestSize.Level1)
605 {
606 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
607 std::map<std::string, std::string> policyMapData;
608 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
609 .Times(1)
610 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestEnableAdmin));
611 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyMap(nullptr, funcCode, policyMapData);
612 EXPECT_FALSE(ret);
613 }
614
615 /**
616 * @tc.name: TestGetPolicyMapEnableAdminSizeEqual
617 * @tc.desc: Test GetPolicyMap func.
618 * @tc.type: FUNC
619 */
620 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetPolicyMapEnableAdminSizeEqual, TestSize.Level1)
621 {
622 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
623 std::map<std::string, std::string> policyMapData;
624 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
625 .Times(1)
626 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestMapEnableAdminTwoSuc));
627 bool ret = enterpriseDeviceMgrProxyTest->GetPolicyMap(nullptr, funcCode, policyMapData);
628 EXPECT_TRUE(ret);
629 }
630
631 /**
632 * @tc.name: TestIsSuperAdminReturnFail
633 * @tc.desc: Test IsSuperAdmin func.
634 * @tc.type: FUNC
635 */
636 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsSuperAdminReturnFail, TestSize.Level1)
637 {
638 EXPECT_CALL(*object_, IsSuperAdmin(_, _))
639 .Times(1)
640 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIsSuperAdminFail));
641 bool ret = true;
642 std::string bundleName = "com.edm.test.demo";
643 enterpriseDeviceMgrProxyTest->IsSuperAdmin(bundleName, ret);
644 EXPECT_FALSE(ret);
645 }
646
647 /**
648 * @tc.name: TestIsByodAdminReturnFail
649 * @tc.desc: Test IsByodAdmin func.
650 * @tc.type: FUNC
651 */
652 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsByodAdminReturnFail, TestSize.Level1)
653 {
654 EXPECT_CALL(*object_, IsByodAdmin(_, _))
655 .Times(1)
656 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIsByodAdminFail));
657 bool ret = true;
658 AppExecFwk::ElementName admin;
659 enterpriseDeviceMgrProxyTest->IsByodAdmin(admin, ret);
660 EXPECT_FALSE(ret);
661 }
662
663 /**
664 * @tc.name: TestGetEnabledSuperAdminReturnFail
665 * @tc.desc: Test GetEnabledSuperAdmin func.
666 * @tc.type: FUNC
667 */
668 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnabledSuperAdminReturnFail, TestSize.Level1)
669 {
670 EXPECT_CALL(*object_, GetEnabledAdmin(_, _))
671 .Times(1)
672 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
673 std::string enabledAdmin;
674 enterpriseDeviceMgrProxyTest->GetEnabledSuperAdmin(enabledAdmin);
675 EXPECT_TRUE(enabledAdmin.size() == 0);
676 }
677
678 /**
679 * @tc.name: TestGetEnabledSuperAdminReturnReplyFail
680 * @tc.desc: Test GetEnabledSuperAdmin func.
681 * @tc.type: FUNC
682 */
683 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnabledSuperAdminReturnReplyFail, TestSize.Level1)
684 {
685 std::string enabledAdmin;
686 EXPECT_CALL(*object_, GetEnabledAdmin(_, _))
687 .Times(1)
688 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
689 enterpriseDeviceMgrProxyTest->GetEnabledSuperAdmin(enabledAdmin);
690 EXPECT_TRUE(enabledAdmin.size() == 0);
691 }
692
693 /**
694 * @tc.name: TestGetEnabledSuperAdminReturnEnableAdmin
695 * @tc.desc: Test GetEnabledSuperAdmin func.
696 * @tc.type: FUNC
697 */
698 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetEnabledSuperAdminReturnEnableAdmin, TestSize.Level1)
699 {
700 std::string enabledAdmin;
701 EXPECT_CALL(*object_, GetEnabledAdmin(_, _))
702 .Times(1)
703 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeGetEnabledAdmin));
704 enterpriseDeviceMgrProxyTest->GetEnabledSuperAdmin(enabledAdmin);
705 GTEST_LOG_(INFO) << "mock enabledAdmin enabledAdmin item :" << enabledAdmin;
706 EXPECT_TRUE(enabledAdmin.size() > 0);
707 }
708
709 /**
710 * @tc.name: TestDisableSuperAdminReturnSuc
711 * @tc.desc: Test DisableSuperAdmin func.
712 * @tc.type: FUNC
713 */
714 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableSuperAdminReturnSuc, TestSize.Level1)
715 {
716 EXPECT_CALL(*object_, DisableSuperAdmin(_))
717 .Times(1)
718 .WillOnce(Return(ERR_OK));
719 ErrCode errVal = enterpriseDeviceMgrProxyTest->DisableSuperAdmin("com.edm.test.demo");
720 EXPECT_TRUE(errVal == ERR_OK);
721 }
722
723 /**
724 * @tc.name: TestDisableSuperAdminReturnFail
725 * @tc.desc: Test DisableSuperAdmin func.
726 * @tc.type: FUNC
727 */
728 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableSuperAdminReturnFail, TestSize.Level1)
729 {
730 EXPECT_CALL(*object_, DisableSuperAdmin(_))
731 .Times(1)
732 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
733 ErrCode errVal = enterpriseDeviceMgrProxyTest->DisableSuperAdmin("com.edm.test.demo");
734 EXPECT_TRUE(errVal != ERR_OK);
735 }
736
737 /**
738 * @tc.name: TestHandleManagedEventReturnFail
739 * @tc.desc: Test HandleManagedEvent func.
740 * @tc.type: FUNC
741 */
742 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestHandleManagedEventReturnFail, TestSize.Level1)
743 {
744 AppExecFwk::ElementName admin;
745 admin.SetBundleName("com.edm.test.demo");
746 admin.SetAbilityName("com.edm.test.demo.Ability");
747 const std::vector<uint32_t> events;
748 EXPECT_CALL(*object_, UnsubscribeManagedEvent(_, _))
749 .Times(1)
750 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
751 ErrCode errVal = enterpriseDeviceMgrProxyTest->HandleManagedEvent(admin, events, false);
752 EXPECT_TRUE(errVal != ERR_OK);
753 }
754
755 /**
756 * @tc.name: TestHandleManagedEventSuc
757 * @tc.desc: Test HandleManagedEvent func.
758 * @tc.type: FUNC
759 */
760 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestHandleManagedEventSuc, TestSize.Level1)
761 {
762 AppExecFwk::ElementName admin;
763 admin.SetBundleName("com.edm.test.demo");
764 admin.SetAbilityName("com.edm.test.demo.Ability");
765 const std::vector<uint32_t> events;
766 EXPECT_CALL(*object_, SubscribeManagedEvent(_, _))
767 .Times(1)
768 .WillOnce(Return(ERR_OK));
769 ErrCode errVal = enterpriseDeviceMgrProxyTest->HandleManagedEvent(admin, events, true);
770 EXPECT_TRUE(errVal == ERR_OK);
771 }
772
773 /**
774 * @tc.name: TestAuthorizeAdminEdmDisable
775 * @tc.desc: Test AuthorizeAdmin without enable edm service func.
776 * @tc.type: FUNC
777 */
778 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestAuthorizeAdminEdmDisable, TestSize.Level1)
779 {
780 Utils::SetEdmServiceDisable();
781 OHOS::AppExecFwk::ElementName admin;
782 std::string bundleName = "com.edm.test.demo";
783 ErrCode ret = enterpriseDeviceMgrProxyTest->AuthorizeAdmin(admin, bundleName);
784 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
785 }
786
787 /**
788 * @tc.name: TestAuthorizeAdminIpcFail
789 * @tc.desc: Test AuthorizeAdmin func with ipc failed.
790 * @tc.type: FUNC
791 */
792 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestAuthorizeAdminIpcFail, TestSize.Level1)
793 {
794 OHOS::AppExecFwk::ElementName admin;
795 EXPECT_CALL(*object_, AuthorizeAdmin(_, _))
796 .Times(1)
797 .WillOnce(Return(ERR_INVALID_VALUE));
798 std::string bundleName = "com.edm.test.demo";
799 ErrCode errVal = enterpriseDeviceMgrProxyTest->AuthorizeAdmin(admin, bundleName);
800 EXPECT_TRUE(errVal != ERR_OK);
801 }
802
803 /**
804 * @tc.name: TestAuthorizeAdminReplyFail
805 * @tc.desc: Test AuthorizeAdmin func with reply failed.
806 * @tc.type: FUNC
807 */
808 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestAuthorizeAdminReplyFail, TestSize.Level1)
809 {
810 OHOS::AppExecFwk::ElementName admin;
811 EXPECT_CALL(*object_, AuthorizeAdmin(_, _))
812 .Times(1)
813 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
814 std::string bundleName = "com.edm.test.demo";
815 ErrCode errVal = enterpriseDeviceMgrProxyTest->AuthorizeAdmin(admin, bundleName);
816 EXPECT_TRUE(errVal == ERR_PROXY_SENDREQUEST_FAIL);
817 }
818
819 /**
820 * @tc.name: TestAuthorizeAdminSuccess
821 * @tc.desc: Test AuthorizeAdmin func success.
822 * @tc.type: FUNC
823 */
824 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestAuthorizeAdminSuccess, TestSize.Level1)
825 {
826 OHOS::AppExecFwk::ElementName admin;
827 EXPECT_CALL(*object_, AuthorizeAdmin(_, _))
828 .Times(1)
829 .WillOnce(Return(ERR_OK));
830 std::string bundleName = "com.edm.test.demo";
831 ErrCode errVal = enterpriseDeviceMgrProxyTest->AuthorizeAdmin(admin, bundleName);
832 EXPECT_TRUE(errVal == ERR_OK);
833 }
834
835 /**
836 * @tc.name: TestDisableAdmin
837 * @tc.desc: Test DisableAdmin func.
838 * @tc.type: FUNC
839 */
840 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableAdmin, TestSize.Level1)
841 {
842 AppExecFwk::ElementName admin;
843 admin.SetBundleName("com.edm.test.demo");
844 admin.SetAbilityName("com.edm.test.demo.Ability");
845 EntInfo entInfo("test", "this is test");
846
847 EXPECT_CALL(*object_, EnableAdmin(_, _, _, _))
848 .Times(1)
849 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
850 ErrCode errVal = enterpriseDeviceMgrProxyTest->EnableAdmin(admin, entInfo, AdminType::NORMAL, DEFAULT_USERID);
851 EXPECT_TRUE(errVal != ERR_OK);
852
853 EXPECT_CALL(*object_, SetEnterpriseInfo(_, _))
854 .Times(1)
855 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
856 errVal = enterpriseDeviceMgrProxyTest->SetEnterpriseInfo(admin, entInfo);
857 EXPECT_TRUE(errVal != ERR_OK);
858
859 EntInfo entInfo1;
860 enterpriseDeviceMgrProxyTest->GetEnterpriseInfo(admin, entInfo1);
861 EXPECT_TRUE(entInfo1.enterpriseName.size() == 0);
862 EXPECT_TRUE(entInfo1.description.size() == 0);
863
864 bool ret = false;
865 enterpriseDeviceMgrProxyTest->IsAdminEnabled(admin, DEFAULT_USERID, ret);
866 EXPECT_FALSE(ret);
867
868 std::vector<std::string> enabledAdminList;
869 enterpriseDeviceMgrProxyTest->GetEnabledAdmins(enabledAdminList);
870 EXPECT_TRUE(enabledAdminList.empty());
871
872 std::vector<std::string> enabledAdminList1;
873 enterpriseDeviceMgrProxyTest->GetEnabledAdmin(AdminType::NORMAL, enabledAdminList1);
874 EXPECT_TRUE(enabledAdminList1.empty());
875
876 int funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::SET_DATETIME);
877 bool isDisabled = false;
878 enterpriseDeviceMgrProxyTest->IsPolicyDisabled(nullptr, funcCode, isDisabled);
879 EXPECT_FALSE(isDisabled);
880
881 EXPECT_CALL(*object_, DisableAdmin(_, _))
882 .Times(1)
883 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
884 errVal = enterpriseDeviceMgrProxyTest->DisableAdmin(admin, DEFAULT_USERID);
885 EXPECT_TRUE(errVal != ERR_OK);
886 }
887
888 /**
889 * @tc.name: TestDisableSuperAdmin
890 * @tc.desc: Test DisableSuperAdmin func.
891 * @tc.type: FUNC
892 */
893 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestDisableSuperAdmin, TestSize.Level1)
894 {
895 AppExecFwk::ElementName admin;
896 admin.SetBundleName("com.edm.test.demo");
897 admin.SetAbilityName("com.edm.test.demo.Ability");
898 EntInfo entInfo("test", "this is test");
899
900 EXPECT_CALL(*object_, EnableAdmin(_, _, _, _))
901 .Times(1)
902 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
903 ErrCode errVal = enterpriseDeviceMgrProxyTest->EnableAdmin(admin, entInfo, AdminType::ENT, DEFAULT_USERID);
904 EXPECT_TRUE(errVal != ERR_OK);
905
906 bool ret = false;
907 std::string bundleName = "com.edm.test.demo";
908 enterpriseDeviceMgrProxyTest->IsSuperAdmin(bundleName, ret);
909 EXPECT_FALSE(ret);
910
911 std::string enabledAdmin;
912 enterpriseDeviceMgrProxyTest->GetEnabledSuperAdmin(enabledAdmin);
913 EXPECT_TRUE(enabledAdmin.size() == 0);
914
915 ret = enterpriseDeviceMgrProxyTest->IsSuperAdminExist();
916 EXPECT_FALSE(ret);
917
918 EXPECT_CALL(*object_, DisableSuperAdmin(_))
919 .Times(1)
920 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
921 errVal = enterpriseDeviceMgrProxyTest->DisableSuperAdmin("com.edm.test.demo");
922 EXPECT_TRUE(errVal != ERR_OK);
923 }
924
925 /**
926 * @tc.name: TestGetSuperAdminSuccess
927 * @tc.desc: Test GetSuperAdmin func.
928 * @tc.type: FUNC
929 */
930 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetSuperAdminSuccess, TestSize.Level1)
931 {
932 std::string bundleName;
933 std::string abilityName;
934 EXPECT_CALL(*object_, GetSuperAdmin(_, _))
935 .Times(1)
936 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeGetSuperAdmin));
937 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetSuperAdmin(bundleName, abilityName);
938 EXPECT_TRUE(errVal == ERR_OK);
939 EXPECT_TRUE(bundleName == RETURN_STRING);
940 EXPECT_TRUE(abilityName == RETURN_STRING);
941 }
942
943 /**
944 * @tc.name: TestGetSuperAdminFail
945 * @tc.desc: Test GetSuperAdmin func.
946 * @tc.type: FUNC
947 */
948 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetSuperAdminFail, TestSize.Level1)
949 {
950 std::string bundleName;
951 std::string abilityName;
952 EXPECT_CALL(*object_, GetSuperAdmin(_, _))
953 .Times(1)
954 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
955 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetSuperAdmin(bundleName, abilityName);
956 EXPECT_TRUE(errVal != ERR_OK);
957 EXPECT_TRUE(bundleName.empty());
958 EXPECT_TRUE(abilityName.empty());
959 }
960
961 /**
962 * @tc.name: TestSetDelegatedPoliciesWithEdmDisable
963 * @tc.desc: Test SetDelegatedPolicies without enable edm service func.
964 * @tc.type: FUNC
965 */
966 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetDelegatedPoliciesWithEdmDisable, TestSize.Level1)
967 {
968 Utils::SetEdmServiceDisable();
969 OHOS::AppExecFwk::ElementName admin;
970 std::string bundleName = "com.edm.test.demo";
971 std::vector<std::string> policies;
972 ErrCode ret = enterpriseDeviceMgrProxyTest->SetDelegatedPolicies(admin, bundleName, policies);
973 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
974 }
975
976 /**
977 * @tc.name: TestSetDelegatedPoliciesIpcFail
978 * @tc.desc: Test SetDelegatedPolicies func with ipc failed.
979 * @tc.type: FUNC
980 */
981 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetDelegatedPoliciesIpcFail, TestSize.Level1)
982 {
983 OHOS::AppExecFwk::ElementName admin;
984 std::string bundleName = "com.edm.test.demo";
985 std::vector<std::string> policies;
986 EXPECT_CALL(*object_, SetDelegatedPolicies(testing::An<const AppExecFwk::ElementName &>(),
987 testing::An<const std::string &>(), testing::An<const std::vector<std::string> &>()))
988 .Times(1)
989 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
990 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetDelegatedPolicies(admin, bundleName, policies);
991 EXPECT_TRUE(errVal == ERR_PROXY_SENDREQUEST_FAIL);
992 }
993
994 /**
995 * @tc.name: TestSetDelegatedPoliciesSuccess
996 * @tc.desc: Test SetDelegatedPolicies func success.
997 * @tc.type: FUNC
998 */
999 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetDelegatedPoliciesSuccess, TestSize.Level1)
1000 {
1001 OHOS::AppExecFwk::ElementName admin;
1002 std::string bundleName = "com.edm.test.demo";
1003 std::vector<std::string> policies;
1004 EXPECT_CALL(*object_, SetDelegatedPolicies(testing::An<const AppExecFwk::ElementName &>(),
1005 testing::An<const std::string &>(), testing::An<const std::vector<std::string> &>()))
1006 .Times(1)
1007 .WillOnce(Return(ERR_OK));
1008 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetDelegatedPolicies(admin, bundleName, policies);
1009 EXPECT_TRUE(errVal == ERR_OK);
1010 }
1011
1012 /**
1013 * @tc.name: TestGetDelegatedPoliciesWithEdmDisable
1014 * @tc.desc: Test GetDelegatedPolicies without enable edm service func.
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetDelegatedPoliciesWithEdmDisable, TestSize.Level1)
1018 {
1019 Utils::SetEdmServiceDisable();
1020 OHOS::AppExecFwk::ElementName admin;
1021 std::string bundleName = "com.edm.test.demo";
1022 std::vector<std::string> result;
1023 ErrCode ret = enterpriseDeviceMgrProxyTest->GetDelegatedPolicies(admin, bundleName,
1024 EdmInterfaceCode::GET_DELEGATED_POLICIES, result);
1025 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
1026 }
1027
1028 /**
1029 * @tc.name: TestGetDelegatedPoliciesIpcFail
1030 * @tc.desc: Test GetDelegatedPolicies func with ipc failed.
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetDelegatedPoliciesIpcFail, TestSize.Level1)
1034 {
1035 OHOS::AppExecFwk::ElementName admin;
1036 std::string bundleName = "com.edm.test.demo";
1037 EXPECT_CALL(*object_, GetDelegatedPolicies(_, _, _))
1038 .Times(1)
1039 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
1040 std::vector<std::string> result;
1041 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetDelegatedPolicies(admin, bundleName,
1042 EdmInterfaceCode::GET_DELEGATED_POLICIES, result);
1043 EXPECT_TRUE(errVal == ERR_PROXY_SENDREQUEST_FAIL);
1044 }
1045
1046 /**
1047 * @tc.name: TestGetDelegatedPoliciesSuccess
1048 * @tc.desc: Test GetDelegatedPolicies func success.
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetDelegatedPoliciesSuccess, TestSize.Level1)
1052 {
1053 OHOS::AppExecFwk::ElementName admin;
1054 std::string bundleName = "com.edm.test.demo";
1055 EXPECT_CALL(*object_, GetDelegatedPolicies(_, _, _))
1056 .Times(1)
1057 .WillOnce(Return(ERR_OK));
1058 std::vector<std::string> result;
1059 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetDelegatedPolicies(admin, bundleName,
1060 EdmInterfaceCode::GET_DELEGATED_POLICIES, result);
1061 EXPECT_TRUE(errVal == ERR_OK);
1062 }
1063
1064 /**
1065 * @tc.name: TestReplaceSuperAdminSuc
1066 * @tc.desc: Test ReplaceSuperAdmin func.
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(EnterpriseDeviceMgrProxyTest, ReplaceSuperAdminSuc, TestSize.Level1)
1070 {
1071 AppExecFwk::ElementName oldAdmin;
1072 AppExecFwk::ElementName newAdmin;
1073 bool isKeepPolicy = false;
1074 EXPECT_CALL(*object_, ReplaceSuperAdmin(_, _, _))
1075 .Times(1)
1076 .WillOnce(Return(ERR_OK));
1077 ErrCode errVal = enterpriseDeviceMgrProxyTest->ReplaceSuperAdmin(oldAdmin, newAdmin, isKeepPolicy);
1078 EXPECT_TRUE(errVal == ERR_OK);
1079 }
1080
1081 /**
1082 * @tc.name: TestReplaceSuperAdminFail
1083 * @tc.desc: Test ReplaceSuperAdmin func.
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestReplaceSuperAdminFail, TestSize.Level1)
1087 {
1088 AppExecFwk::ElementName oldAdmin;
1089 AppExecFwk::ElementName newAdmin;
1090 bool isKeepPolicy = false;
1091 EXPECT_CALL(*object_, ReplaceSuperAdmin(_, _, _))
1092 .Times(1)
1093 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
1094 ErrCode errVal = enterpriseDeviceMgrProxyTest->ReplaceSuperAdmin(oldAdmin, newAdmin, isKeepPolicy);
1095 EXPECT_TRUE(errVal != ERR_OK);
1096 }
1097
1098 /**
1099 * @tc.name: TestGetAdminsSucc
1100 * @tc.desc: Test GetAdmins func succ.
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetAdminsSucc, TestSize.Level1)
1104 {
1105 EXPECT_CALL(*object_, GetAdmins(_))
1106 .Times(1)
1107 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeGetAdmins));
1108 std::vector<std::shared_ptr<AAFwk::Want>> wants;
1109 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetAdmins(wants);
1110 ASSERT_TRUE(errVal == ERR_OK);
1111 int32_t wantSize = wants.size();
1112 ASSERT_TRUE(wantSize == 1);
1113 std::shared_ptr<AAFwk::Want> want = wants[0];
1114 ASSERT_TRUE(want != nullptr);
1115 std::string bundleName = want->GetStringParam("bundleName");
1116 EXPECT_TRUE(bundleName == "com.edm.test.demo");
1117 std::string abilityName = want->GetStringParam("abilityName");
1118 EXPECT_TRUE(abilityName == "test.ability");
1119 int32_t adminType = want->GetIntParam("adminType", -1);
1120 EXPECT_TRUE(adminType == static_cast<int32_t>(AdminType::BYOD));
1121 }
1122
1123 /**
1124 * @tc.name: TestGetAdminsIpcFail
1125 * @tc.desc: Test GetAdmins func with ipc failed.
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetAdminsIpcFail, TestSize.Level1)
1129 {
1130 EXPECT_CALL(*object_, GetAdmins(_))
1131 .Times(1)
1132 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
1133 std::vector<std::shared_ptr<AAFwk::Want>> wants;
1134 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetAdmins(wants);
1135 EXPECT_TRUE(errVal == ERR_PROXY_SENDREQUEST_FAIL);
1136 }
1137
1138 /**
1139 * @tc.name: TestGetAdminsWithEdmDisable
1140 * @tc.desc: Test GetAdmins without enable edm service func.
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestGetAdminsWithEdmDisable, TestSize.Level1)
1144 {
1145 Utils::SetEdmServiceDisable();
1146 std::vector<std::shared_ptr<AAFwk::Want>> wants;
1147 ErrCode errVal = enterpriseDeviceMgrProxyTest->GetAdmins(wants);
1148 ASSERT_TRUE(errVal == ERR_OK);
1149 }
1150
1151 /**
1152 * @tc.name: TestCheckAndGetAdminProvisionInfoSucc
1153 * @tc.desc: Test CheckAndGetAdminProvisionInfo func succ.
1154 * @tc.type: FUNC
1155 */
1156 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestCheckAndGetAdminProvisionInfoSucc, TestSize.Level1)
1157 {
1158 OHOS::AppExecFwk::ElementName admin;
1159 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
1160 .Times(1)
1161 .WillOnce(Invoke(object_.GetRefPtr(),
1162 &EnterpriseDeviceMgrStubMock::InvokeSendRequestCheckAndGetAdminProvisionInfo));
1163 std::string bundleName;
1164 ErrCode errVal = enterpriseDeviceMgrProxyTest->CheckAndGetAdminProvisionInfo(admin, bundleName);
1165 ASSERT_TRUE(errVal == ERR_OK);
1166 ASSERT_TRUE(bundleName == "com.edm.test.demo");
1167 }
1168
1169 /**
1170 * @tc.name: TestCheckAndGetAdminProvisionInfoFail
1171 * @tc.desc: Test CheckAndGetAdminProvisionInfo func with ipc failed.
1172 * @tc.type: FUNC
1173 */
1174 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestCheckAndGetAdminProvisionInfoIpcFail, TestSize.Level1)
1175 {
1176 OHOS::AppExecFwk::ElementName admin;
1177 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
1178 .Times(1)
1179 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestFail));
1180 std::string bundleName;
1181 ErrCode errVal = enterpriseDeviceMgrProxyTest->CheckAndGetAdminProvisionInfo(admin, bundleName);
1182 EXPECT_TRUE(errVal == EdmReturnErrCode::SYSTEM_ABNORMALLY);
1183 }
1184
1185 /**
1186 * @tc.name: TestIsEdmEnabledSuc
1187 * @tc.desc: Test IsEdmEnabled with enable edm service func.
1188 * @tc.type: FUNC
1189 */
1190 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsEdmEnabledSuc, TestSize.Level0)
1191 {
1192 bool errVal = enterpriseDeviceMgrProxyTest->IsEdmEnabled();
1193 ASSERT_TRUE(errVal);
1194 }
1195
1196 /**
1197 * @tc.name: TestIsEdmEnabledWithEdmDisable
1198 * @tc.desc: Test IsEdmEnabled without enable edm service func.
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestIsEdmEnabledWithEdmDisable, TestSize.Level1)
1202 {
1203 Utils::SetEdmServiceDisable();
1204 bool errVal = enterpriseDeviceMgrProxyTest->IsEdmEnabled();
1205 ASSERT_FALSE(errVal);
1206 }
1207
1208 /**
1209 * @tc.name: TestSetDelegatedPolicies
1210 * @tc.desc: Test SetDelegatedPolicies failed.
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetDelegatedPolicies, TestSize.Level1)
1214 {
1215 std::string bundleName = "com.edm.test.demo";
1216 std::vector<std::string> policies;
1217 int32_t userId = 100;
1218 EXPECT_CALL(*object_, SetDelegatedPolicies(testing::An<const std::string &>(),
1219 testing::An<const std::vector<std::string> &>(), testing::An<int32_t>()))
1220 .Times(1)
1221 .WillOnce(Return(ERR_PROXY_SENDREQUEST_FAIL));
1222 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetDelegatedPolicies(bundleName, policies, userId);
1223 EXPECT_TRUE(errVal == ERR_PROXY_SENDREQUEST_FAIL);
1224 }
1225
1226 /**
1227 * @tc.name: TestSetDelegatedPoliciesIsSuccess
1228 * @tc.desc: Test SetDelegatedPolicies func success.
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetDelegatedPoliciesIsSuccess, TestSize.Level1)
1232 {
1233 std::string bundleName = "com.edm.test.demo";
1234 std::vector<std::string> policies;
1235 int32_t userId = 100;
1236 EXPECT_CALL(*object_, SetDelegatedPolicies(testing::An<const std::string &>(),
1237 testing::An<const std::vector<std::string> &>(), testing::An<int32_t>()))
1238 .Times(1)
1239 .WillOnce(Return(ERR_OK));
1240 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetDelegatedPolicies(bundleName, policies, userId);
1241 EXPECT_TRUE(errVal == ERR_OK);
1242 }
1243
1244 /**
1245 * @tc.name: TestSetAdminRunningModeFail
1246 * @tc.desc: Test SetAdminRunningMode fail.
1247 * @tc.type: FUNC
1248 */
1249 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetAdminRunningModeFail, TestSize.Level1)
1250 {
1251 AppExecFwk::ElementName admin;
1252 admin.SetBundleName("com.edm.test.demo");
1253 admin.SetAbilityName("com.edm.test.demo.Ability");
1254 EXPECT_CALL(*object_, SetAdminRunningMode(_, _))
1255 .Times(1)
1256 .WillOnce(Return(EdmReturnErrCode::SYSTEM_ABNORMALLY));
1257 uint32_t runningMode = 0;
1258 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetAdminRunningMode(admin, runningMode);
1259 EXPECT_TRUE(errVal != ERR_OK);
1260 }
1261
1262 /**
1263 * @tc.name: TestSetAdminRunningModeSuc
1264 * @tc.desc: Test SetAdminRunningMode success.
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetAdminRunningModeSuc, TestSize.Level1)
1268 {
1269 AppExecFwk::ElementName admin;
1270 admin.SetBundleName("com.edm.test.demo");
1271 admin.SetAbilityName("com.edm.test.demo.Ability");
1272 EXPECT_CALL(*object_, SetAdminRunningMode(_, _))
1273 .Times(1)
1274 .WillOnce(Return(ERR_OK));
1275 uint32_t runningMode = 0;
1276 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetAdminRunningMode(admin, runningMode);
1277 EXPECT_TRUE(errVal == ERR_OK);
1278 }
1279
1280 /**
1281 * @tc.name: TestSetBundleInstallPoliciesFail
1282 * @tc.desc: Test SetBundleInstallPolicies fail.
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetBundleInstallPoliciesFail, TestSize.Level1)
1286 {
1287 std::vector<std::string> bundles = { "test" };
1288 int32_t userId = 100;
1289 int32_t policyType = 1;
1290 EXPECT_CALL(*object_, SetBundleInstallPolicies(_, _, _))
1291 .Times(1)
1292 .WillOnce(Return(EdmReturnErrCode::SYSTEM_ABNORMALLY));
1293 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetBundleInstallPolicies(bundles, userId, policyType);
1294 EXPECT_TRUE(errVal != ERR_OK);
1295 }
1296
1297 /**
1298 * @tc.name: TestSetBundleInstallPoliciesSuc
1299 * @tc.desc: Test SetBundleInstallPolicies success.
1300 * @tc.type: FUNC
1301 */
1302 HWTEST_F(EnterpriseDeviceMgrProxyTest, TestSetBundleInstallPoliciesSuc, TestSize.Level1)
1303 {
1304 std::vector<std::string> bundles = { "test" };
1305 int32_t userId = 100;
1306 int32_t policyType = 1;
1307 EXPECT_CALL(*object_, SetBundleInstallPolicies(_, _, _))
1308 .Times(1)
1309 .WillOnce(Return(ERR_OK));
1310 ErrCode errVal = enterpriseDeviceMgrProxyTest->SetBundleInstallPolicies(bundles, userId, policyType);
1311 EXPECT_TRUE(errVal == ERR_OK);
1312 }
1313 } // namespace TEST
1314 } // namespace EDM
1315 } // namespace OHOS
1316