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
20 #include "device_settings_proxy.h"
21 #include "edm_sys_manager_mock.h"
22 #include "enterprise_device_mgr_stub_mock.h"
23 #include "utils.h"
24
25 using namespace testing::ext;
26 using namespace testing;
27
28 namespace OHOS {
29 namespace EDM {
30 namespace TEST {
31 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
32 class DeviceSettingsProxyTest : public testing::Test {
33 protected:
34 void SetUp() override;
35
36 void TearDown() override;
37
38 static void TearDownTestSuite(void);
39 std::shared_ptr<DeviceSettingsProxy> deviceSettingsProxy = nullptr;
40 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
41 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
42 };
43
SetUp()44 void DeviceSettingsProxyTest::SetUp()
45 {
46 deviceSettingsProxy = DeviceSettingsProxy::GetDeviceSettingsProxy();
47 edmSysManager_ = std::make_shared<EdmSysManager>();
48 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
49 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
50 Utils::SetEdmServiceEnable();
51 }
52
TearDown()53 void DeviceSettingsProxyTest::TearDown()
54 {
55 deviceSettingsProxy.reset();
56 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
57 object_ = nullptr;
58 Utils::SetEdmServiceDisable();
59 }
60
TearDownTestSuite()61 void DeviceSettingsProxyTest::TearDownTestSuite()
62 {
63 ASSERT_FALSE(Utils::GetEdmServiceState());
64 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
65 }
66
67 /**
68 * @tc.name: TestSetScreenOffTimeSuc
69 * @tc.desc: Test SetGetScreenOffTime func.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(DeviceSettingsProxyTest, TestSetScreenOffTimeSuc, TestSize.Level1)
73 {
74 AppExecFwk::ElementName admin;
75 admin.SetBundleName(ADMIN_PACKAGENAME);
76 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
77 .Times(1)
78 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
79 int32_t time = 30000;
80 int32_t ret = deviceSettingsProxy->GetScreenOffTime(admin, time);
81 ASSERT_TRUE(ret == ERR_OK);
82 }
83
84 /**
85 * @tc.name: TestSetScreenOffTimeFail
86 * @tc.desc: Test SetGetScreenOffTime func.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(DeviceSettingsProxyTest, TestSetScreenOffTimeFail, TestSize.Level1)
90 {
91 Utils::SetEdmServiceDisable();
92 AppExecFwk::ElementName admin;
93 admin.SetBundleName(ADMIN_PACKAGENAME);
94 int32_t time = 30000;
95 int32_t ret = deviceSettingsProxy->SetScreenOffTime(admin, time);
96 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
97 }
98
99 /**
100 * @tc.name: TestGetScreenOffTimeSuc
101 * @tc.desc: Test GetGetScreenOffTime func.
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DeviceSettingsProxyTest, TestGetScreenOffTimeSuc, TestSize.Level1)
105 {
106 AppExecFwk::ElementName admin;
107 admin.SetBundleName(ADMIN_PACKAGENAME);
108 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
109 .Times(1)
110 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIntSendRequestGetPolicy));
111 int32_t info = 0;
112 int32_t ret = deviceSettingsProxy->GetScreenOffTime(admin, info);
113 ASSERT_TRUE(ret == ERR_OK);
114 ASSERT_TRUE(info == 0);
115 }
116
117 /**
118 * @tc.name: TestGetScreenOffTimeFail
119 * @tc.desc: Test GetGetScreenOffTime func.
120 * @tc.type: FUNC
121 */
122 HWTEST_F(DeviceSettingsProxyTest, TestGetScreenOffTimeFail, TestSize.Level1)
123 {
124 Utils::SetEdmServiceDisable();
125 AppExecFwk::ElementName admin;
126 admin.SetBundleName(ADMIN_PACKAGENAME);
127 int32_t info = 0;
128 int32_t ret = deviceSettingsProxy->GetScreenOffTime(admin, info);
129 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
130 }
131
132 /**
133 * @tc.name: TestInstallUserCertificateSuc
134 * @tc.desc: Test InstallUserCertificate func.
135 * @tc.type: FUNC
136 */
137 HWTEST_F(DeviceSettingsProxyTest, TestInstallUserCertificateSuc, TestSize.Level1)
138 {
139 AppExecFwk::ElementName admin;
140 admin.SetBundleName(ADMIN_PACKAGENAME);
141 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
142 .Times(1)
143 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
144 std::vector<uint8_t> certArray;
145 std::string alias = "alias";
146 std::string stringRet;
147 std::string innerCodeMsg;
148 int32_t ret = deviceSettingsProxy->InstallUserCertificate(admin, certArray, alias, stringRet, innerCodeMsg);
149 ASSERT_TRUE(ret == ERR_OK);
150 }
151
152 /**
153 * @tc.name: TestInstallUserCertificateFail
154 * @tc.desc: Test InstallUserCertificate func.
155 * @tc.type: FUNC
156 */
157 HWTEST_F(DeviceSettingsProxyTest, TestInstallUserCertificateFail, TestSize.Level1)
158 {
159 Utils::SetEdmServiceDisable();
160 AppExecFwk::ElementName admin;
161 admin.SetBundleName(ADMIN_PACKAGENAME);
162 std::vector<uint8_t> certArray;
163 std::string alias = "alias";
164 std::string stringRet;
165 std::string innerCodeMsg;
166 int32_t ret = deviceSettingsProxy->InstallUserCertificate(admin, certArray, alias, stringRet, innerCodeMsg);
167 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
168 }
169
170 /**
171 * @tc.name: TestUninstallUserCertificateSuc
172 * @tc.desc: Test UninstallUserCertificate func.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(DeviceSettingsProxyTest, TestUninstallUserCertificateSuc, TestSize.Level1)
176 {
177 AppExecFwk::ElementName admin;
178 admin.SetBundleName(ADMIN_PACKAGENAME);
179 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
180 .Times(1)
181 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
182 std::vector<uint8_t> certArray;
183 std::string alias = "alias";
184 std::string stringRet;
185 std::string innerCodeMsg;
186 int32_t ret = deviceSettingsProxy->UninstallUserCertificate(admin, alias, innerCodeMsg);
187 ASSERT_TRUE(ret == ERR_OK);
188 }
189
190 /**
191 * @tc.name: TestUninstallUserCertificateFail
192 * @tc.desc: Test UninstallUserCertificate func.
193 * @tc.type: FUNC
194 */
195 HWTEST_F(DeviceSettingsProxyTest, TestUninstallUserCertificateFail, TestSize.Level1)
196 {
197 Utils::SetEdmServiceDisable();
198 AppExecFwk::ElementName admin;
199 admin.SetBundleName(ADMIN_PACKAGENAME);
200 std::vector<uint8_t> certArray;
201 std::string alias = "alias";
202 std::string stringRet;
203 std::string innerCodeMsg;
204 int32_t ret = deviceSettingsProxy->UninstallUserCertificate(admin, alias, innerCodeMsg);
205 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
206 }
207
208 /**
209 * @tc.name: TestSetPowerPolicySuc
210 * @tc.desc: Test SetPowerPolicy func.
211 * @tc.type: FUNC
212 */
213 HWTEST_F(DeviceSettingsProxyTest, TestSetPowerPolicySuc, TestSize.Level1)
214 {
215 AppExecFwk::ElementName admin;
216 admin.SetBundleName(ADMIN_PACKAGENAME);
217 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
218 .Times(1)
219 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
220 PowerScene scene = PowerScene::TIME_OUT;
221 PowerPolicy powerPolicy;
222 int32_t ret = deviceSettingsProxy->SetPowerPolicy(admin, scene, powerPolicy);
223 ASSERT_TRUE(ret == ERR_OK);
224 }
225
226 /**
227 * @tc.name: TestSetPowerPolicyFail
228 * @tc.desc: Test SetPowerPolicy func.
229 * @tc.type: FUNC
230 */
231 HWTEST_F(DeviceSettingsProxyTest, TestSetPowerPolicyFail, TestSize.Level1)
232 {
233 Utils::SetEdmServiceDisable();
234 AppExecFwk::ElementName admin;
235 admin.SetBundleName(ADMIN_PACKAGENAME);
236 PowerScene scene = PowerScene::TIME_OUT;
237 PowerPolicy powerPolicy;
238 int32_t ret = deviceSettingsProxy->SetPowerPolicy(admin, scene, powerPolicy);
239 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
240 }
241
242 /**
243 * @tc.name: TestGetPowerPolicySuc
244 * @tc.desc: Test GetPowerPolicy func.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(DeviceSettingsProxyTest, TestGetPowerPolicySuc, TestSize.Level1)
248 {
249 AppExecFwk::ElementName admin;
250 admin.SetBundleName(ADMIN_PACKAGENAME);
251 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
252 .Times(1)
253 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIntSendRequestGetPolicy));
254 PowerScene scene = PowerScene::TIME_OUT;
255 PowerPolicy powerPolicy;
256 int32_t ret = deviceSettingsProxy->GetPowerPolicy(admin, scene, powerPolicy);
257 ASSERT_TRUE(ret == ERR_OK);
258 }
259
260 /**
261 * @tc.name: TestGetPowerPolicyFail
262 * @tc.desc: Test GetPowerPolicy func.
263 * @tc.type: FUNC
264 */
265 HWTEST_F(DeviceSettingsProxyTest, TestGetPowerPolicyFail, TestSize.Level1)
266 {
267 Utils::SetEdmServiceDisable();
268 AppExecFwk::ElementName admin;
269 admin.SetBundleName(ADMIN_PACKAGENAME);
270 PowerScene scene = PowerScene::TIME_OUT;
271 PowerPolicy powerPolicy;
272 int32_t ret = deviceSettingsProxy->GetPowerPolicy(admin, scene, powerPolicy);
273 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
274 }
275
276 } // namespace TEST
277 } // namespace EDM
278 } // namespace OHOS
279