1 /*
2 * Copyright (c) 2023 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 #include <string>
18 #include <system_ability_definition.h>
19 #include <vector>
20
21 #include "edm_sys_manager_mock.h"
22 #include "enterprise_device_mgr_stub_mock.h"
23 #include "security_manager_proxy.h"
24 #include "utils.h"
25
26 using namespace testing::ext;
27 using namespace testing;
28
29 namespace OHOS {
30 namespace EDM {
31 namespace TEST {
32 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
33 constexpr int32_t ACCOUTID_VALID_VALUE = 100;
34 class SecurityManagerProxyTest : public testing::Test {
35 protected:
36 void SetUp() override;
37
38 void TearDown() override;
39
40 static void TearDownTestSuite(void);
41 std::shared_ptr<SecurityManagerProxy> proxy_ = nullptr;
42 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
43 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
44 };
45
SetUp()46 void SecurityManagerProxyTest::SetUp()
47 {
48 proxy_ = SecurityManagerProxy::GetSecurityManagerProxy();
49 edmSysManager_ = std::make_shared<EdmSysManager>();
50 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
51 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
52 Utils::SetEdmServiceEnable();
53 }
54
TearDown()55 void SecurityManagerProxyTest::TearDown()
56 {
57 proxy_.reset();
58 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
59 object_ = nullptr;
60 Utils::SetEdmServiceDisable();
61 }
62
TearDownTestSuite()63 void SecurityManagerProxyTest::TearDownTestSuite()
64 {
65 ASSERT_FALSE(Utils::GetEdmServiceState());
66 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
67 }
68
69 /**
70 * @tc.name: TestGetSecurityPatchTagSuc
71 * @tc.desc: Test GetSecurityPatchTag success func.
72 * @tc.type: FUNC
73 */
74 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagSuc, TestSize.Level1)
75 {
76 OHOS::AppExecFwk::ElementName admin;
77 admin.SetBundleName(ADMIN_PACKAGENAME);
78 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
79 .Times(1)
80 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
81 std::string res;
82 int32_t ret = proxy_->GetSecurityPatchTag(admin, res);
83 ASSERT_TRUE(ret == ERR_OK);
84 ASSERT_TRUE(res == RETURN_STRING);
85 }
86
87 /**
88 * @tc.name: TestGetSecurityPatchTagFail
89 * @tc.desc: Test GetSecurityPatchTag without enable edm service func.
90 * @tc.type: FUNC
91 */
92 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagFail, TestSize.Level1)
93 {
94 Utils::SetEdmServiceDisable();
95 OHOS::AppExecFwk::ElementName admin;
96 admin.SetBundleName(ADMIN_PACKAGENAME);
97 std::string res;
98 int32_t ret = proxy_->GetSecurityPatchTag(admin, res);
99 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
100 }
101
102 /**
103 * @tc.name: TestGetSecurityPatchTagSuc_01
104 * @tc.desc: Test GetSecurityPatchTag success func.
105 * @tc.type: FUNC
106 */
107 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagSuc_01, TestSize.Level1)
108 {
109 OHOS::AppExecFwk::ElementName admin;
110 admin.SetBundleName(ADMIN_PACKAGENAME);
111 MessageParcel data;
112 data.WriteParcelable(&admin);
113 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
114 .Times(1)
115 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
116 std::string res;
117 int32_t ret = proxy_->GetSecurityPatchTag(data, res);
118 ASSERT_TRUE(ret == ERR_OK);
119 ASSERT_TRUE(res == RETURN_STRING);
120 }
121
122 /**
123 * @tc.name: TestGetSecurityPatchTagFail_01
124 * @tc.desc: Test GetSecurityPatchTag without enable edm service func.
125 * @tc.type: FUNC
126 */
127 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagFail_01, TestSize.Level1)
128 {
129 Utils::SetEdmServiceDisable();
130 OHOS::AppExecFwk::ElementName admin;
131 admin.SetBundleName(ADMIN_PACKAGENAME);
132 MessageParcel data;
133 data.WriteParcelable(&admin);
134 std::string res;
135 int32_t ret = proxy_->GetSecurityPatchTag(data, res);
136 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
137 }
138
139 /**
140 * @tc.name: TestGetDeviceEncryptionStatusSuc
141 * @tc.desc: Test GetDeviceEncryptionStatus success func.
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusSuc, TestSize.Level1)
145 {
146 OHOS::AppExecFwk::ElementName admin;
147 admin.SetBundleName(ADMIN_PACKAGENAME);
148 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
149 .Times(1)
150 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
151 DeviceEncryptionStatus deviceEncryptionStatus;
152 int32_t ret = proxy_->GetDeviceEncryptionStatus(admin, deviceEncryptionStatus);
153 ASSERT_TRUE(ret == ERR_OK);
154 ASSERT_TRUE(deviceEncryptionStatus.isEncrypted == true);
155 }
156
157 /**
158 * @tc.name: TestGetDeviceEncryptionStatusFail
159 * @tc.desc: Test GetDeviceEncryptionStatus without enable edm service func.
160 * @tc.type: FUNC
161 */
162 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusFail, TestSize.Level1)
163 {
164 Utils::SetEdmServiceDisable();
165 OHOS::AppExecFwk::ElementName admin;
166 admin.SetBundleName(ADMIN_PACKAGENAME);
167 DeviceEncryptionStatus deviceEncryptionStatus;
168 int32_t ret = proxy_->GetDeviceEncryptionStatus(admin, deviceEncryptionStatus);
169 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
170 }
171
172 /**
173 * @tc.name: TestGetDeviceEncryptionStatusSuc_01
174 * @tc.desc: Test GetDeviceEncryptionStatus success func.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusSuc_01, TestSize.Level1)
178 {
179 OHOS::AppExecFwk::ElementName admin;
180 admin.SetBundleName(ADMIN_PACKAGENAME);
181 MessageParcel data;
182 data.WriteParcelable(&admin);
183 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
184 .Times(1)
185 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
186 DeviceEncryptionStatus deviceEncryptionStatus;
187 int32_t ret = proxy_->GetDeviceEncryptionStatus(data, deviceEncryptionStatus);
188 ASSERT_TRUE(ret == ERR_OK);
189 ASSERT_TRUE(deviceEncryptionStatus.isEncrypted == true);
190 }
191
192 /**
193 * @tc.name: TestGetDeviceEncryptionStatusFail_01
194 * @tc.desc: Test GetDeviceEncryptionStatus without enable edm service func.
195 * @tc.type: FUNC
196 */
197 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusFail_01, TestSize.Level1)
198 {
199 Utils::SetEdmServiceDisable();
200 OHOS::AppExecFwk::ElementName admin;
201 admin.SetBundleName(ADMIN_PACKAGENAME);
202 MessageParcel data;
203 data.WriteParcelable(&admin);
204 DeviceEncryptionStatus deviceEncryptionStatus;
205 int32_t ret = proxy_->GetDeviceEncryptionStatus(data, deviceEncryptionStatus);
206 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
207 }
208
209 /**
210 * @tc.name: TestGetRootCheckStatusSuc
211 * @tc.desc: Test TestGetRootCheckStatusSuc success func.
212 * @tc.type: FUNC
213 */
214 HWTEST_F(SecurityManagerProxyTest, TestGetRootCheckStatusSuc, TestSize.Level1)
215 {
216 OHOS::AppExecFwk::ElementName admin;
217 admin.SetBundleName(ADMIN_PACKAGENAME);
218 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
219 .Times(1)
220 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
221 std::string res;
222 int32_t ret = proxy_->GetRootCheckStatus(admin, res);
223 ASSERT_TRUE(ret == ERR_OK);
224 ASSERT_TRUE(res == RETURN_STRING);
225 }
226
227 /**
228 * @tc.name: TesGetRootCheckStatusFail
229 * @tc.desc: Test GetRootCheckStatus without enable edm service func.
230 * @tc.type: FUNC
231 */
232 HWTEST_F(SecurityManagerProxyTest, TestGetRootCheckStatusFail, TestSize.Level1)
233 {
234 Utils::SetEdmServiceDisable();
235 OHOS::AppExecFwk::ElementName admin;
236 admin.SetBundleName(ADMIN_PACKAGENAME);
237 std::string res;
238 int32_t ret = proxy_->GetRootCheckStatus(admin, res);
239 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
240 }
241
242 /**
243 * @tc.name: TestSetPasswordPolicySuc
244 * @tc.desc: Test SetPasswordPolicy success func.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SecurityManagerProxyTest, TestSetPasswordPolicySuc, TestSize.Level1)
248 {
249 OHOS::AppExecFwk::ElementName admin;
250 admin.SetBundleName(ADMIN_PACKAGENAME);
251 PasswordPolicy policy;
252 MessageParcel data;
253 data.WriteParcelable(&admin);
254 data.WriteString(policy.complexityReg);
255 data.WriteInt64(policy.validityPeriod);
256 data.WriteString(policy.additionalDescription);
257 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
258 .Times(1)
259 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
260 int32_t ret = proxy_->SetPasswordPolicy(data);
261 ASSERT_TRUE(ret == ERR_OK);
262 }
263
264 /**
265 * @tc.name: TestGetPasswordPolicySuc
266 * @tc.desc: Test GetPasswordPolicy success func without admin.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicySucWithoutAdmin, TestSize.Level1)
270 {
271 PasswordPolicy policy;
272 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
273 .Times(1)
274 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
275 int32_t ret = proxy_->GetPasswordPolicy(policy);
276 ASSERT_TRUE(ret == ERR_OK);
277 }
278
279 /**
280 * @tc.name: TestGetPasswordPolicySuc
281 * @tc.desc: Test GetPasswordPolicy success func.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicySuc, TestSize.Level1)
285 {
286 OHOS::AppExecFwk::ElementName admin;
287 admin.SetBundleName(ADMIN_PACKAGENAME);
288 PasswordPolicy policy;
289 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
290 .Times(1)
291 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPasswordPolicy));
292 int32_t ret = proxy_->GetPasswordPolicy(admin, policy);
293 ASSERT_TRUE(ret == ERR_OK);
294 ASSERT_TRUE(policy.complexityReg == "test_complexityReg");
295 ASSERT_TRUE(policy.validityPeriod == 1);
296 ASSERT_TRUE(policy.additionalDescription == "test_additionalDescription");
297 }
298
299 /**
300 * @tc.name: TestGetPasswordPolicyFail
301 * @tc.desc: Test GetPasswordPolicy fail func.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicyFail, TestSize.Level1)
305 {
306 Utils::SetEdmServiceDisable();
307 OHOS::AppExecFwk::ElementName admin;
308 admin.SetBundleName(ADMIN_PACKAGENAME);
309 PasswordPolicy policy;
310 int32_t ret = proxy_->GetPasswordPolicy(admin, policy);
311 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
312 }
313
314 /**
315 * @tc.name: TestSetAppClipboardPolicySuc
316 * @tc.desc: Test SetAppClipboardPolicy success func.
317 * @tc.type: FUNC
318 */
319 HWTEST_F(SecurityManagerProxyTest, TestSetAppClipboardPolicySuc, TestSize.Level1)
320 {
321 OHOS::AppExecFwk::ElementName admin;
322 admin.SetBundleName(ADMIN_PACKAGENAME);
323 MessageParcel data;
324 data.WriteParcelable(&admin);
325 data.WriteInt32(123);
326 data.WriteInt32(1);
327 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
328 .Times(1)
329 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
330 int32_t ret = proxy_->SetAppClipboardPolicy(data);
331 ASSERT_TRUE(ret == ERR_OK);
332 }
333
334 /**
335 * @tc.name: TestGetAppClipboardPolicySuc
336 * @tc.desc: Test GetAppClipboardPolicy success func.
337 * @tc.type: FUNC
338 */
339 HWTEST_F(SecurityManagerProxyTest, TestGetAppClipboardPolicySuc, TestSize.Level1)
340 {
341 OHOS::AppExecFwk::ElementName admin;
342 admin.SetBundleName(ADMIN_PACKAGENAME);
343 std::string policy;
344 MessageParcel data;
345 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
346 .Times(1)
347 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
348 int32_t ret = proxy_->GetAppClipboardPolicy(data, policy);
349 ASSERT_TRUE(ret == ERR_OK);
350 }
351
352 /**
353 * @tc.name: TestGetAppClipboardPolicyFail
354 * @tc.desc: Test GetAppClipboardPolicy fail func.
355 * @tc.type: FUNC
356 */
357 HWTEST_F(SecurityManagerProxyTest, TestGetAppClipboardPolicyFail, TestSize.Level1)
358 {
359 Utils::SetEdmServiceDisable();
360 OHOS::AppExecFwk::ElementName admin;
361 admin.SetBundleName(ADMIN_PACKAGENAME);
362 std::string policy;
363 MessageParcel data;
364 int32_t ret = proxy_->GetAppClipboardPolicy(data, policy);
365 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
366 }
367
368 /**
369 * @tc.name: TestSetWatermarkImageSuc
370 * @tc.desc: Test SetWatermarkImage success func.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(SecurityManagerProxyTest, TestSetWatermarkImageSuc, TestSize.Level1)
374 {
375 OHOS::AppExecFwk::ElementName admin;
376 admin.SetBundleName(ADMIN_PACKAGENAME);
377 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
378 .Times(1)
379 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
380 std::shared_ptr<WatermarkParam> paramPtr = std::make_shared<WatermarkParam>();
381 int32_t ret = proxy_->SetWatermarkImage(admin, paramPtr);
382 ASSERT_TRUE(ret == ERR_OK);
383 }
384
385 /**
386 * @tc.name: TestCancelWatermarkImageSec
387 * @tc.desc: Test CancelWatermarkImage success func.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(SecurityManagerProxyTest, TestCancelWatermarkImageSuc, TestSize.Level1)
391 {
392 OHOS::AppExecFwk::ElementName admin;
393 admin.SetBundleName(ADMIN_PACKAGENAME);
394 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
395 .Times(1)
396 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
397 std::string bundleName = "testBundleName";
398 MessageParcel data;
399 data.WriteParcelable(&admin);
400 data.WriteString(bundleName);
401 data.WriteInt32(100);
402 int32_t ret = proxy_->CancelWatermarkImage(data);
403 ASSERT_TRUE(ret == ERR_OK);
404 }
405
406 /**
407 * @tc.name: TestInstallUserCertificateSuc
408 * @tc.desc: Test InstallUserCertificate func without specific accountId.
409 * @tc.type: FUNC
410 */
411 HWTEST_F(SecurityManagerProxyTest, TestInstallUserCertificateSuc, TestSize.Level1)
412 {
413 AppExecFwk::ElementName admin;
414 admin.SetBundleName(ADMIN_PACKAGENAME);
415 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
416 .Times(1)
417 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
418 CertBlobCA certblobCA;
419 certblobCA.alias = "alias";
420 certblobCA.accountId = ACCOUTID_VALID_VALUE;
421 std::string stringRet;
422 std::string innerCodeMsg;
423 int32_t ret = proxy_->InstallUserCertificate(admin, certblobCA, stringRet, innerCodeMsg);
424 ASSERT_TRUE(ret == ERR_OK);
425 }
426
427 /**
428 * @tc.name: TestInstallUserCertificateFail
429 * @tc.desc: Test InstallUserCertificate func without admin.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(SecurityManagerProxyTest, TestInstallUserCertificateFail, TestSize.Level1)
433 {
434 Utils::SetEdmServiceDisable();
435 AppExecFwk::ElementName admin;
436 admin.SetBundleName(ADMIN_PACKAGENAME);
437 CertBlobCA certblobCA;
438 certblobCA.alias = "alias";
439 certblobCA.accountId = ACCOUTID_VALID_VALUE;
440 std::string stringRet;
441 std::string innerCodeMsg;
442 int32_t ret = proxy_->InstallUserCertificate(admin, certblobCA, stringRet, innerCodeMsg);
443 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
444 }
445
446 /**
447 * @tc.name: TestGetUserCertificatesSuc
448 * @tc.desc: Test GetUserCertificates func.
449 * @tc.type: FUNC
450 */
451 HWTEST_F(SecurityManagerProxyTest, TestGetUserCertificatesSuc, TestSize.Level1)
452 {
453 AppExecFwk::ElementName admin;
454 admin.SetBundleName(ADMIN_PACKAGENAME);
455 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
456 .Times(1)
457 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeArrayStringSendRequestGetPolicy));
458 int32_t accountId = ACCOUTID_VALID_VALUE;
459 std::vector<std::string> uriList;
460 MessageParcel data;
461 data.WriteParcelable(&admin);
462 data.WriteInt32(accountId);
463 int32_t ret = proxy_->GetUserCertificates(data, uriList);
464 ASSERT_TRUE(ret == ERR_OK);
465 }
466
467 /**
468 * @tc.name: TestGetUserCertificatesFail
469 * @tc.desc: Test GetUserCertificates func.
470 * @tc.type: FUNC
471 */
472 HWTEST_F(SecurityManagerProxyTest, TestGetUserCertificatesFail, TestSize.Level1)
473 {
474 Utils::SetEdmServiceDisable();
475 AppExecFwk::ElementName admin;
476 admin.SetBundleName(ADMIN_PACKAGENAME);
477 int32_t accountId = ACCOUTID_VALID_VALUE;
478 std::vector<std::string> uriList;
479 MessageParcel data;
480 data.WriteParcelable(&admin);
481 data.WriteInt32(accountId);
482 int32_t ret = proxy_->GetUserCertificates(data, uriList);
483 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
484 }
485 } // namespace TEST
486 } // namespace EDM
487 } // namespace OHOS
488