1 /*
2 * Copyright (c) 2023-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 #include <string>
18 #include <system_ability_definition.h>
19
20 #include "system_manager_proxy.h"
21 #include "edm_sys_manager_mock.h"
22 #include "enterprise_device_mgr_stub_mock.h"
23 #include "func_code.h"
24 #include "update_policy_utils.h"
25 #include "utils.h"
26
27 using namespace testing::ext;
28 using namespace testing;
29
30 namespace OHOS {
31 namespace EDM {
32 namespace TEST {
33 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
34 class SystemManagerProxyTest : public testing::Test {
35 protected:
36 void SetUp() override;
37
38 void TearDown() override;
39
40 static void TearDownTestSuite(void);
41 std::shared_ptr<SystemManagerProxy> systemmanagerProxy = nullptr;
42 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
43 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
44 };
45
SetUp()46 void SystemManagerProxyTest::SetUp()
47 {
48 systemmanagerProxy = SystemManagerProxy::GetSystemManagerProxy();
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 SystemManagerProxyTest::TearDown()
56 {
57 systemmanagerProxy.reset();
58 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
59 object_ = nullptr;
60 Utils::SetEdmServiceDisable();
61 }
62
TearDownTestSuite()63 void SystemManagerProxyTest::TearDownTestSuite()
64 {
65 ASSERT_FALSE(Utils::GetEdmServiceState());
66 }
67
68 /**
69 * @tc.name: TestSetNTPServerSuc
70 * @tc.desc: Test SetNTPServer func.
71 * @tc.type: FUNC
72 */
73 HWTEST_F(SystemManagerProxyTest, TestSetNTPServerSuc, TestSize.Level1)
74 {
75 MessageParcel data;
76 OHOS::AppExecFwk::ElementName admin;
77 admin.SetBundleName(ADMIN_PACKAGENAME);
78 data.WriteParcelable(&admin);
79 data.WriteString("ntp.aliyun.com");
80 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
81 .Times(1)
82 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
83
84 int32_t ret = systemmanagerProxy->SetNTPServer(data);
85 ASSERT_TRUE(ret == ERR_OK);
86 }
87
88 /**
89 * @tc.name: TestSetNTPServerFail
90 * @tc.desc: Test SetNTPServer func.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(SystemManagerProxyTest, TestSetNTPServerFail, TestSize.Level1)
94 {
95 Utils::SetEdmServiceDisable();
96 MessageParcel data;
97 OHOS::AppExecFwk::ElementName admin;
98 admin.SetBundleName(ADMIN_PACKAGENAME);
99 data.WriteParcelable(&admin);
100 data.WriteString("ntp.aliyun.com");
101
102 int32_t ret = systemmanagerProxy->SetNTPServer(data);
103 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
104 }
105
106 /**
107 * @tc.name: TestGetNTPServerSuc
108 * @tc.desc: Test GetNTPServer func.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(SystemManagerProxyTest, TestGetNTPServerSuc, TestSize.Level1)
112 {
113 MessageParcel data;
114 OHOS::AppExecFwk::ElementName admin;
115 admin.SetBundleName(ADMIN_PACKAGENAME);
116 data.WriteParcelable(&admin);
117 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
118 .Times(1)
119 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
120
121 std::string server = "";
122 int32_t ret = systemmanagerProxy->GetNTPServer(data, server);
123 ASSERT_TRUE(ret == ERR_OK);
124 ASSERT_TRUE(server == RETURN_STRING);
125 }
126
127 /**
128 * @tc.name: TestGetNTPServerFail
129 * @tc.desc: Test GetNTPServer func.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(SystemManagerProxyTest, TestGetNTPServerFail, TestSize.Level1)
133 {
134 Utils::SetEdmServiceDisable();
135 MessageParcel data;
136 OHOS::AppExecFwk::ElementName admin;
137 admin.SetBundleName(ADMIN_PACKAGENAME);
138 data.WriteParcelable(&admin);
139 std::string server = "";
140 int32_t ret = systemmanagerProxy->GetNTPServer(data, server);
141 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
142 }
143
144 /**
145 * @tc.name: TestSetOTAUpdatePolicySuc
146 * @tc.desc: Test SetOTAUpdatePolicy func.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(SystemManagerProxyTest, TestSetOTAUpdatePolicySuc, TestSize.Level1)
150 {
151 MessageParcel data;
152 OHOS::AppExecFwk::ElementName admin;
153 admin.SetBundleName(ADMIN_PACKAGENAME);
154 data.WriteParcelable(&admin);
155 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
156 .Times(1)
157 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
158 UpdatePolicy updatePolicy;
159 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
160
161 std::string message;
162 int32_t ret = systemmanagerProxy->SetOTAUpdatePolicy(data, message);
163 ASSERT_TRUE(ret == ERR_OK);
164 }
165
166 /**
167 * @tc.name: TestSetOTAUpdatePolicyParamError
168 * @tc.desc: Test SetOTAUpdatePolicy func.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(SystemManagerProxyTest, TestSetOTAUpdatePolicyParamError, TestSize.Level1)
172 {
173 MessageParcel data;
174 OHOS::AppExecFwk::ElementName admin;
175 admin.SetBundleName(ADMIN_PACKAGENAME);
176 data.WriteParcelable(&admin);
177 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
178 .Times(1)
179 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestParamError));
180 UpdatePolicy updatePolicy;
181 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
182
183 std::string message;
184 int32_t ret = systemmanagerProxy->SetOTAUpdatePolicy(data, message);
185 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
186 ASSERT_EQ(message, RETURN_STRING);
187 }
188
189 /**
190 * @tc.name: TestGetOTAUpdatePolicyFail
191 * @tc.desc: Test GetOTAUpdatePolicy func.
192 * @tc.type: FUNC
193 */
194 HWTEST_F(SystemManagerProxyTest, TestGetOTAUpdatePolicyFail, TestSize.Level1)
195 {
196 Utils::SetEdmServiceDisable();
197 MessageParcel data;
198 OHOS::AppExecFwk::ElementName admin;
199 admin.SetBundleName(ADMIN_PACKAGENAME);
200 data.WriteParcelable(&admin);
201
202 UpdatePolicy updatePolicy;
203 int32_t ret = systemmanagerProxy->GetOTAUpdatePolicy(data, updatePolicy);
204 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
205 }
206
207 /**
208 * @tc.name: TestGetOTAUpdatePolicySuc
209 * @tc.desc: Test GetOTAUpdatePolicy func.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(SystemManagerProxyTest, TestGetOTAUpdatePolicySuc, TestSize.Level1)
213 {
214 MessageParcel data;
215 OHOS::AppExecFwk::ElementName admin;
216 admin.SetBundleName(ADMIN_PACKAGENAME);
217 data.WriteParcelable(&admin);
218 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
219 .Times(1)
220 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetOTAUpdatePolicy));
221
222 UpdatePolicy updatePolicy;
223 int32_t ret = systemmanagerProxy->GetOTAUpdatePolicy(data, updatePolicy);
224 ASSERT_TRUE(ret == ERR_OK);
225 ASSERT_EQ(updatePolicy.type, UpdatePolicyType::PROHIBIT);
226 ASSERT_EQ(updatePolicy.version, UPGRADE_VERSION);
227 }
228
229 /**
230 * @tc.name: TestNotifyUpdatePackagesSuc
231 * @tc.desc: Test NotifyUpdatePackages func.
232 * @tc.type: FUNC
233 */
234 HWTEST_F(SystemManagerProxyTest, TestNotifyUpdatePackagesSuc, TestSize.Level1)
235 {
236 AppExecFwk::ElementName admin;
237 admin.SetBundleName(ADMIN_PACKAGENAME);
238 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
239 .Times(1)
240 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
241 UpgradePackageInfo packageInfo;
242 std::string errMsg;
243 int32_t ret = systemmanagerProxy->NotifyUpdatePackages(admin, packageInfo, errMsg);
244 ASSERT_TRUE(ret == ERR_OK);
245 }
246
247 /**
248 * @tc.name: TestGetUpgradeResultFail
249 * @tc.desc: Test GetUpgradeResult func.
250 * @tc.type: FUNC
251 */
252 HWTEST_F(SystemManagerProxyTest, TestGetUpgradeResultFail, TestSize.Level1)
253 {
254 Utils::SetEdmServiceDisable();
255 AppExecFwk::ElementName admin;
256 admin.SetBundleName(ADMIN_PACKAGENAME);
257 UpgradeResult upgradeResult;
258 int32_t ret = systemmanagerProxy->GetUpgradeResult(admin, UPGRADE_VERSION, upgradeResult);
259 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
260 }
261
262 /**
263 * @tc.name: TestGetUpgradeResultSuc
264 * @tc.desc: Test GetUpgradeResult func.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(SystemManagerProxyTest, TestGetUpgradeResultSuc, TestSize.Level1)
268 {
269 AppExecFwk::ElementName admin;
270 admin.SetBundleName(ADMIN_PACKAGENAME);
271 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
272 .Times(1)
273 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetUpgradeResult));
274 UpgradeResult upgradeResult;
275 int32_t ret = systemmanagerProxy->GetUpgradeResult(admin, UPGRADE_VERSION, upgradeResult);
276 ASSERT_TRUE(ret == ERR_OK);
277 ASSERT_TRUE(upgradeResult.status == UpgradeStatus::UPGRADE_FAILURE);
278 ASSERT_EQ(upgradeResult.version, UPGRADE_VERSION);
279 ASSERT_EQ(upgradeResult.errorCode, UPGRADE_FAILED_CODE);
280 ASSERT_EQ(upgradeResult.errorMessage, UPGRADE_FAILED_MESSAGE);
281 }
282
283
284 /**
285 * @tc.name: TestGetUpdateAuthDataFail
286 * @tc.desc: Test GetUpdateAuthData func.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(SystemManagerProxyTest, TestGetUpdateAuthDataFail, TestSize.Level1)
290 {
291 Utils::SetEdmServiceDisable();
292 MessageParcel data;
293 OHOS::AppExecFwk::ElementName admin;
294 admin.SetBundleName(ADMIN_PACKAGENAME);
295 data.WriteParcelable(&admin);
296 std::string authData;
297 int32_t ret = systemmanagerProxy->GetUpdateAuthData(data, authData);
298 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
299 }
300
301 /**
302 * @tc.name: TestGetUpdateAuthDataSuc
303 * @tc.desc: Test GetUpdateAuthData func.
304 * @tc.type: FUNC
305 */
306 HWTEST_F(SystemManagerProxyTest, TestGetUpdateAuthDataSuc, TestSize.Level1)
307 {
308 MessageParcel data;
309 OHOS::AppExecFwk::ElementName admin;
310 admin.SetBundleName(ADMIN_PACKAGENAME);
311 data.WriteParcelable(&admin);
312 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
313 .Times(1)
314 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetUpdateAuthData));
315 std::string authData;
316 int32_t ret = systemmanagerProxy->GetUpdateAuthData(data, authData);
317 ASSERT_TRUE(ret == ERR_OK);
318 ASSERT_EQ(authData, AUTH_DATA);
319 }
320
321 /**
322 * @tc.name: TestSetAutoUnlockAfterRebootSuc
323 * @tc.desc: Test SetAutoUnlockAfterReboot func.
324 * @tc.type: FUNC
325 */
326 HWTEST_F(SystemManagerProxyTest, TestSetAutoUnlockAfterRebootSuc, TestSize.Level1)
327 {
328 bool isAllowed = true;
329 MessageParcel data;
330 OHOS::AppExecFwk::ElementName admin;
331 admin.SetBundleName(ADMIN_PACKAGENAME);
332 data.WriteParcelable(&admin);
333 data.WriteBool(isAllowed);
334 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
335 .Times(1)
336 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
337
338 int32_t ret = systemmanagerProxy->SetAutoUnlockAfterReboot(data);
339 ASSERT_TRUE(ret == ERR_OK);
340 }
341
342
343 /**
344 * @tc.name: TestSetAutoUnlockAfterRebootFail
345 * @tc.desc: Test SetAutoUnlockAfterReboot func.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(SystemManagerProxyTest, TestSetAutoUnlockAfterRebootFail, TestSize.Level1)
349 {
350 bool isAllowed = true;
351 Utils::SetEdmServiceDisable();
352 MessageParcel data;
353 OHOS::AppExecFwk::ElementName admin;
354 admin.SetBundleName(ADMIN_PACKAGENAME);
355 data.WriteParcelable(&admin);
356 data.WriteBool(isAllowed);
357
358 int32_t ret = systemmanagerProxy->SetAutoUnlockAfterReboot(data);
359 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
360 }
361
362 /**
363 * @tc.name: TestGetInstallLocalEnterpriseAppEnabledFail
364 * @tc.desc: Test GetInstallLocalEnterpriseAppEnabled func.
365 * @tc.type: FUNC
366 */
367 HWTEST_F(SystemManagerProxyTest, TestGetInstallLocalEnterpriseAppEnabledFail, TestSize.Level1)
368 {
369 Utils::SetEdmServiceDisable();
370 MessageParcel data;
371 OHOS::AppExecFwk::ElementName admin;
372 admin.SetBundleName(ADMIN_PACKAGENAME);
373 data.WriteParcelable(&admin);
374 bool isAllowed = true;
375 int32_t ret = systemmanagerProxy->GetInstallLocalEnterpriseAppEnabled(data, isAllowed);
376 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
377 }
378
379 /**
380 * @tc.name: TestGetInstallLocalEnterpriseAppEnabledSuc
381 * @tc.desc: Test GetInstallLocalEnterpriseAppEnabled func.
382 * @tc.type: FUNC
383 */
384 HWTEST_F(SystemManagerProxyTest, TestGetInstallLocalEnterpriseAppEnabledSuc, TestSize.Level1)
385 {
386 MessageParcel data;
387 OHOS::AppExecFwk::ElementName admin;
388 admin.SetBundleName(ADMIN_PACKAGENAME);
389 data.WriteParcelable(&admin);
390 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
391 .Times(1)
392 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetUpdateAuthData));
393 bool isAllowed = true;
394 int32_t ret = systemmanagerProxy->GetInstallLocalEnterpriseAppEnabled(data, isAllowed);
395 ASSERT_TRUE(ret == ERR_OK);
396 ASSERT_TRUE(isAllowed);
397 }
398
399 /**
400 * @tc.name: TestSetInstallLocalEnterpriseAppEnabledSuc
401 * @tc.desc: Test SetInstallLocalEnterpriseAppEnabled func.
402 * @tc.type: FUNC
403 */
404 HWTEST_F(SystemManagerProxyTest, TestSetInstallLocalEnterpriseAppEnabledSuc, TestSize.Level1)
405 {
406 bool isAllowed = true;
407 MessageParcel data;
408 OHOS::AppExecFwk::ElementName admin;
409 admin.SetBundleName(ADMIN_PACKAGENAME);
410 data.WriteParcelable(&admin);
411 data.WriteBool(isAllowed);
412 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
413 .Times(1)
414 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
415
416 int32_t ret = systemmanagerProxy->SetInstallLocalEnterpriseAppEnabled(data);
417 ASSERT_TRUE(ret == ERR_OK);
418 }
419
420
421 /**
422 * @tc.name: TestSetInstallLocalEnterpriseAppEnabledFail
423 * @tc.desc: Test SetInstallLocalEnterpriseAppEnabled func.
424 * @tc.type: FUNC
425 */
426 HWTEST_F(SystemManagerProxyTest, TestSetInstallLocalEnterpriseAppEnabledFail, TestSize.Level1)
427 {
428 bool isAllowed = true;
429 Utils::SetEdmServiceDisable();
430 MessageParcel data;
431 OHOS::AppExecFwk::ElementName admin;
432 admin.SetBundleName(ADMIN_PACKAGENAME);
433 data.WriteParcelable(&admin);
434 data.WriteBool(isAllowed);
435
436 int32_t ret = systemmanagerProxy->SetInstallLocalEnterpriseAppEnabled(data);
437 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
438 }
439
440 /**
441 * @tc.name: TestAddOrRemoveDisallowedNearlinkProtocolsFail
442 * @tc.desc: Test AddOrRemoveDisallowedNearlinkProtocols without enable edm service func.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(SystemManagerProxyTest, TestAddOrRemoveDisallowedNearlinkProtocolsFail, TestSize.Level1)
446 {
447 Utils::SetEdmServiceDisable();
448 MessageParcel data;
449 OHOS::AppExecFwk::ElementName admin;
450 std::vector<int32_t> protocols;
451 data.WriteParcelable(&admin);
452 data.WriteInt32Vector(protocols);
453
454 ErrCode ret = systemmanagerProxy->AddOrRemoveDisallowedNearlinkProtocols(data, FuncOperateType::SET);
455 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
456 }
457
458 /**
459 * @tc.name: TestAddOrRemoveDisallowedNearlinkProtocolsSuc
460 * @tc.desc: Test AddOrRemoveDisallowedNearlinkProtocols success func.
461 * @tc.type: FUNC
462 */
463 HWTEST_F(SystemManagerProxyTest, TestAddOrRemoveDisallowedNearlinkProtocolsSuc, TestSize.Level1)
464 {
465 MessageParcel data;
466 OHOS::AppExecFwk::ElementName admin;
467 std::vector<int32_t> protocols;
468 data.WriteParcelable(&admin);
469 data.WriteInt32Vector(protocols);
470
471 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
472 .Times(1)
473 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
474 ErrCode ret = systemmanagerProxy->AddOrRemoveDisallowedNearlinkProtocols(data, FuncOperateType::SET);
475 ASSERT_TRUE(ret == ERR_OK);
476 }
477
478 } // namespace TEST
479 } // namespace EDM
480 } // namespace OHOS
481