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 = -1;
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 MessageParcel data;
149 data.WriteParcelable(&admin);
150 data.WriteUInt8Vector(certArray);
151 data.WriteString(alias);
152 int32_t ret = deviceSettingsProxy->InstallUserCertificate(data, stringRet, innerCodeMsg);
153 ASSERT_TRUE(ret == ERR_OK);
154 }
155
156 /**
157 * @tc.name: TestInstallUserCertificateFail
158 * @tc.desc: Test InstallUserCertificate func.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(DeviceSettingsProxyTest, TestInstallUserCertificateFail, TestSize.Level1)
162 {
163 Utils::SetEdmServiceDisable();
164 AppExecFwk::ElementName admin;
165 admin.SetBundleName(ADMIN_PACKAGENAME);
166 std::vector<uint8_t> certArray;
167 std::string alias = "alias";
168 std::string stringRet;
169 std::string innerCodeMsg;
170 MessageParcel data;
171 data.WriteParcelable(&admin);
172 data.WriteUInt8Vector(certArray);
173 data.WriteString(alias);
174 int32_t ret = deviceSettingsProxy->InstallUserCertificate(data, stringRet, innerCodeMsg);
175 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
176 }
177
178 /**
179 * @tc.name: TestUninstallUserCertificateSuc
180 * @tc.desc: Test UninstallUserCertificate func.
181 * @tc.type: FUNC
182 */
183 HWTEST_F(DeviceSettingsProxyTest, TestUninstallUserCertificateSuc, TestSize.Level1)
184 {
185 AppExecFwk::ElementName admin;
186 admin.SetBundleName(ADMIN_PACKAGENAME);
187 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
188 .Times(1)
189 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
190 std::vector<uint8_t> certArray;
191 std::string alias = "alias";
192 std::string innerCodeMsg;
193 MessageParcel data;
194 data.WriteParcelable(&admin);
195 data.WriteString(alias);
196 int32_t ret = deviceSettingsProxy->UninstallUserCertificate(data, innerCodeMsg);
197 ASSERT_TRUE(ret == ERR_OK);
198 }
199
200 /**
201 * @tc.name: TestUninstallUserCertificateFail
202 * @tc.desc: Test UninstallUserCertificate func.
203 * @tc.type: FUNC
204 */
205 HWTEST_F(DeviceSettingsProxyTest, TestUninstallUserCertificateFail, TestSize.Level1)
206 {
207 Utils::SetEdmServiceDisable();
208 AppExecFwk::ElementName admin;
209 admin.SetBundleName(ADMIN_PACKAGENAME);
210 std::vector<uint8_t> certArray;
211 std::string alias = "alias";
212 std::string innerCodeMsg;
213 MessageParcel data;
214 data.WriteParcelable(&admin);
215 data.WriteString(alias);
216 int32_t ret = deviceSettingsProxy->UninstallUserCertificate(data, innerCodeMsg);
217 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
218 }
219
220 /**
221 * @tc.name: TestSetPowerPolicySuc
222 * @tc.desc: Test SetPowerPolicy func.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(DeviceSettingsProxyTest, TestSetPowerPolicySuc, TestSize.Level1)
226 {
227 AppExecFwk::ElementName admin;
228 admin.SetBundleName(ADMIN_PACKAGENAME);
229 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
230 .Times(1)
231 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
232 PowerScene scene = PowerScene::TIME_OUT;
233 PowerPolicy powerPolicy;
234 int32_t ret = deviceSettingsProxy->SetPowerPolicy(admin, scene, powerPolicy);
235 ASSERT_TRUE(ret == ERR_OK);
236 }
237
238 /**
239 * @tc.name: TestSetPowerPolicyFail
240 * @tc.desc: Test SetPowerPolicy func.
241 * @tc.type: FUNC
242 */
243 HWTEST_F(DeviceSettingsProxyTest, TestSetPowerPolicyFail, TestSize.Level1)
244 {
245 Utils::SetEdmServiceDisable();
246 AppExecFwk::ElementName admin;
247 admin.SetBundleName(ADMIN_PACKAGENAME);
248 PowerScene scene = PowerScene::TIME_OUT;
249 PowerPolicy powerPolicy;
250 int32_t ret = deviceSettingsProxy->SetPowerPolicy(admin, scene, powerPolicy);
251 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
252 }
253
254 /**
255 * @tc.name: TestGetPowerPolicySuc
256 * @tc.desc: Test GetPowerPolicy func.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(DeviceSettingsProxyTest, TestGetPowerPolicySuc, TestSize.Level1)
260 {
261 AppExecFwk::ElementName admin;
262 admin.SetBundleName(ADMIN_PACKAGENAME);
263 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
264 .Times(1)
265 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIntSendRequestGetPolicy));
266 PowerScene scene = PowerScene::TIME_OUT;
267 PowerPolicy powerPolicy;
268 int32_t ret = deviceSettingsProxy->GetPowerPolicy(admin, scene, powerPolicy);
269 ASSERT_TRUE(ret == ERR_OK);
270 }
271
272 /**
273 * @tc.name: TestGetPowerPolicyFail
274 * @tc.desc: Test GetPowerPolicy func.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(DeviceSettingsProxyTest, TestGetPowerPolicyFail, TestSize.Level1)
278 {
279 Utils::SetEdmServiceDisable();
280 AppExecFwk::ElementName admin;
281 admin.SetBundleName(ADMIN_PACKAGENAME);
282 PowerScene scene = PowerScene::TIME_OUT;
283 PowerPolicy powerPolicy;
284 int32_t ret = deviceSettingsProxy->GetPowerPolicy(admin, scene, powerPolicy);
285 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
286 }
287
288 /**
289 * @tc.name: TestSetWallPaperFail
290 * @tc.desc: Test SetWallPaper func.
291 * @tc.type: FUNC
292 */
293 HWTEST_F(DeviceSettingsProxyTest, TestSetWallPaperFail, TestSize.Level1)
294 {
295 Utils::SetEdmServiceDisable();
296 AppExecFwk::ElementName admin;
297 admin.SetBundleName(ADMIN_PACKAGENAME);
298 int32_t fd = 100;
299 MessageParcel data;
300 data.WriteParcelable(&admin);
301 data.WriteFileDescriptor(fd);
302 data.WriteBool(true);
303 std::string errMsg;
304 int32_t ret = deviceSettingsProxy->SetWallPaper(data, errMsg);
305 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
306 }
307
308 /**
309 * @tc.name: TestSetWallPaperSuc
310 * @tc.desc: Test SetWallPaper func.
311 * @tc.type: FUNC
312 */
313 HWTEST_F(DeviceSettingsProxyTest, TestSetWallPaperSuc, TestSize.Level1)
314 {
315 AppExecFwk::ElementName admin;
316 admin.SetBundleName(ADMIN_PACKAGENAME);
317 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
318 .Times(1)
319 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
320 int32_t fd = 100;
321 MessageParcel data;
322 data.WriteParcelable(&admin);
323 data.WriteFileDescriptor(fd);
324 data.WriteBool(true);
325 std::string errMsg;
326 int32_t ret = deviceSettingsProxy->SetWallPaper(data, errMsg);
327 ASSERT_TRUE(ret == ERR_OK);
328 }
329 } // namespace TEST
330 } // namespace EDM
331 } // namespace OHOS
332