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 class SecurityManagerProxyTest : public testing::Test {
34 protected:
35     void SetUp() override;
36 
37     void TearDown() override;
38 
39     static void TearDownTestSuite(void);
40     std::shared_ptr<SecurityManagerProxy> proxy_ = nullptr;
41     std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
42     sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
43 };
44 
SetUp()45 void SecurityManagerProxyTest::SetUp()
46 {
47     proxy_ = SecurityManagerProxy::GetSecurityManagerProxy();
48     edmSysManager_ = std::make_shared<EdmSysManager>();
49     object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
50     edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
51     Utils::SetEdmServiceEnable();
52 }
53 
TearDown()54 void SecurityManagerProxyTest::TearDown()
55 {
56     proxy_.reset();
57     edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
58     object_ = nullptr;
59     Utils::SetEdmServiceDisable();
60 }
61 
TearDownTestSuite()62 void SecurityManagerProxyTest::TearDownTestSuite()
63 {
64     ASSERT_FALSE(Utils::GetEdmServiceState());
65     std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
66 }
67 
68 /**
69  * @tc.name: TestGetSecurityPatchTagSuc
70  * @tc.desc: Test GetSecurityPatchTag success func.
71  * @tc.type: FUNC
72  */
73 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagSuc, TestSize.Level1)
74 {
75     OHOS::AppExecFwk::ElementName admin;
76     admin.SetBundleName(ADMIN_PACKAGENAME);
77     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
78         .Times(1)
79         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
80     std::string res;
81     int32_t ret = proxy_->GetSecurityPatchTag(admin, res);
82     ASSERT_TRUE(ret == ERR_OK);
83     ASSERT_TRUE(res == RETURN_STRING);
84 }
85 
86 /**
87  * @tc.name: TestGetSecurityPatchTagFail
88  * @tc.desc: Test GetSecurityPatchTag without enable edm service func.
89  * @tc.type: FUNC
90  */
91 HWTEST_F(SecurityManagerProxyTest, TestGetSecurityPatchTagFail, TestSize.Level1)
92 {
93     Utils::SetEdmServiceDisable();
94     OHOS::AppExecFwk::ElementName admin;
95     admin.SetBundleName(ADMIN_PACKAGENAME);
96     std::string res;
97     int32_t ret = proxy_->GetSecurityPatchTag(admin, res);
98     ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
99 }
100 
101 /**
102  * @tc.name: TestGetDeviceEncryptionStatusSuc
103  * @tc.desc: Test GetDeviceEncryptionStatus success func.
104  * @tc.type: FUNC
105  */
106 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusSuc, TestSize.Level1)
107 {
108     OHOS::AppExecFwk::ElementName admin;
109     admin.SetBundleName(ADMIN_PACKAGENAME);
110     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
111         .Times(1)
112         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
113     DeviceEncryptionStatus deviceEncryptionStatus;
114     int32_t ret = proxy_->GetDeviceEncryptionStatus(admin, deviceEncryptionStatus);
115     ASSERT_TRUE(ret == ERR_OK);
116     ASSERT_TRUE(deviceEncryptionStatus.isEncrypted == true);
117 }
118 
119 /**
120  * @tc.name: TestGetDeviceEncryptionStatusFail
121  * @tc.desc: Test GetDeviceEncryptionStatus without enable edm service func.
122  * @tc.type: FUNC
123  */
124 HWTEST_F(SecurityManagerProxyTest, TestGetDeviceEncryptionStatusFail, TestSize.Level1)
125 {
126     Utils::SetEdmServiceDisable();
127     OHOS::AppExecFwk::ElementName admin;
128     admin.SetBundleName(ADMIN_PACKAGENAME);
129     DeviceEncryptionStatus deviceEncryptionStatus;
130     int32_t ret = proxy_->GetDeviceEncryptionStatus(admin, deviceEncryptionStatus);
131     ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
132 }
133 
134 /**
135  * @tc.name: TestGetRootCheckStatusSuc
136  * @tc.desc: Test TestGetRootCheckStatusSuc success func.
137  * @tc.type: FUNC
138  */
139 HWTEST_F(SecurityManagerProxyTest, TestGetRootCheckStatusSuc, TestSize.Level1)
140 {
141     OHOS::AppExecFwk::ElementName admin;
142     admin.SetBundleName(ADMIN_PACKAGENAME);
143     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
144         .Times(1)
145         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
146     std::string res;
147     int32_t ret = proxy_->GetRootCheckStatus(admin, res);
148     ASSERT_TRUE(ret == ERR_OK);
149     ASSERT_TRUE(res == RETURN_STRING);
150 }
151 
152 /**
153  * @tc.name: TesGetRootCheckStatusFail
154  * @tc.desc: Test GetRootCheckStatus without enable edm service func.
155  * @tc.type: FUNC
156  */
157 HWTEST_F(SecurityManagerProxyTest, TestGetRootCheckStatusFail, TestSize.Level1)
158 {
159     Utils::SetEdmServiceDisable();
160     OHOS::AppExecFwk::ElementName admin;
161     admin.SetBundleName(ADMIN_PACKAGENAME);
162     std::string res;
163     int32_t ret = proxy_->GetRootCheckStatus(admin, res);
164     ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
165 }
166 
167 /**
168  * @tc.name: TestSetPasswordPolicySuc
169  * @tc.desc: Test SetPasswordPolicy success func.
170  * @tc.type: FUNC
171  */
172 HWTEST_F(SecurityManagerProxyTest, TestSetPasswordPolicySuc, TestSize.Level1)
173 {
174     OHOS::AppExecFwk::ElementName admin;
175     admin.SetBundleName(ADMIN_PACKAGENAME);
176     PasswordPolicy policy;
177     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
178         .Times(1)
179         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
180     int32_t ret = proxy_->SetPasswordPolicy(admin, policy);
181     ASSERT_TRUE(ret == ERR_OK);
182 }
183 
184 /**
185  * @tc.name: TestGetPasswordPolicySuc
186  * @tc.desc: Test GetPasswordPolicy success func without admin.
187  * @tc.type: FUNC
188  */
189 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicySucWithoutAdmin, TestSize.Level1)
190 {
191     PasswordPolicy policy;
192     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
193         .Times(1)
194         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
195     int32_t ret = proxy_->GetPasswordPolicy(policy);
196     ASSERT_TRUE(ret == ERR_OK);
197 }
198 
199 /**
200  * @tc.name: TestGetPasswordPolicySuc
201  * @tc.desc: Test GetPasswordPolicy success func.
202  * @tc.type: FUNC
203  */
204 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicySuc, TestSize.Level1)
205 {
206     OHOS::AppExecFwk::ElementName admin;
207     admin.SetBundleName(ADMIN_PACKAGENAME);
208     PasswordPolicy policy;
209     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
210         .Times(1)
211         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPasswordPolicy));
212     int32_t ret = proxy_->GetPasswordPolicy(admin, policy);
213     ASSERT_TRUE(ret == ERR_OK);
214     ASSERT_TRUE(policy.complexityReg == "test_complexityReg");
215     ASSERT_TRUE(policy.validityPeriod == 1);
216     ASSERT_TRUE(policy.additionalDescription == "test_additionalDescription");
217 }
218 
219 /**
220  * @tc.name: TestGetPasswordPolicyFail
221  * @tc.desc: Test GetPasswordPolicy fail func.
222  * @tc.type: FUNC
223  */
224 HWTEST_F(SecurityManagerProxyTest, TestGetPasswordPolicyFail, TestSize.Level1)
225 {
226     Utils::SetEdmServiceDisable();
227     OHOS::AppExecFwk::ElementName admin;
228     admin.SetBundleName(ADMIN_PACKAGENAME);
229     PasswordPolicy policy;
230     int32_t ret = proxy_->GetPasswordPolicy(admin, policy);
231     ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
232 }
233 
234 /**
235  * @tc.name: TestSetAppClipboardPolicySuc
236  * @tc.desc: Test SetAppClipboardPolicy success func.
237  * @tc.type: FUNC
238  */
239 HWTEST_F(SecurityManagerProxyTest, TestSetAppClipboardPolicySuc, TestSize.Level1)
240 {
241     OHOS::AppExecFwk::ElementName admin;
242     admin.SetBundleName(ADMIN_PACKAGENAME);
243     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
244         .Times(1)
245         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
246     int32_t ret = proxy_->SetAppClipboardPolicy(admin, 123, 1);
247     ASSERT_TRUE(ret == ERR_OK);
248 }
249 
250 /**
251  * @tc.name: TestGetAppClipboardPolicySuc
252  * @tc.desc: Test GetAppClipboardPolicy success func.
253  * @tc.type: FUNC
254  */
255 HWTEST_F(SecurityManagerProxyTest, TestGetAppClipboardPolicySuc, TestSize.Level1)
256 {
257     OHOS::AppExecFwk::ElementName admin;
258     admin.SetBundleName(ADMIN_PACKAGENAME);
259     std::string policy;
260     EXPECT_CALL(*object_, SendRequest(_, _, _, _))
261         .Times(1)
262         .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
263     int32_t ret = proxy_->GetAppClipboardPolicy(admin, 123, policy);
264     ASSERT_TRUE(ret == ERR_OK);
265 }
266 
267 /**
268  * @tc.name: TestGetAppClipboardPolicyFail
269  * @tc.desc: Test GetAppClipboardPolicy fail func.
270  * @tc.type: FUNC
271  */
272 HWTEST_F(SecurityManagerProxyTest, TestGetAppClipboardPolicyFail, TestSize.Level1)
273 {
274     Utils::SetEdmServiceDisable();
275     OHOS::AppExecFwk::ElementName admin;
276     admin.SetBundleName(ADMIN_PACKAGENAME);
277     std::string policy;
278     int32_t ret = proxy_->GetAppClipboardPolicy(admin, 123, policy);
279     ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
280 }
281 } // namespace TEST
282 } // namespace EDM
283 } // namespace OHOS
284