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 "update_policy_utils.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 SystemManagerProxyTest : public testing::Test {
34 protected:
35 void SetUp() override;
36
37 void TearDown() override;
38
39 static void TearDownTestSuite(void);
40 std::shared_ptr<SystemManagerProxy> systemmanagerProxy = nullptr;
41 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
42 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
43 };
44
SetUp()45 void SystemManagerProxyTest::SetUp()
46 {
47 systemmanagerProxy = SystemManagerProxy::GetSystemManagerProxy();
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 SystemManagerProxyTest::TearDown()
55 {
56 systemmanagerProxy.reset();
57 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
58 object_ = nullptr;
59 Utils::SetEdmServiceDisable();
60 }
61
TearDownTestSuite()62 void SystemManagerProxyTest::TearDownTestSuite()
63 {
64 ASSERT_FALSE(Utils::GetEdmServiceState());
65 }
66
67 /**
68 * @tc.name: TestSetNTPServerSuc
69 * @tc.desc: Test SetNTPServer func.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(SystemManagerProxyTest, TestSetNTPServerSuc, TestSize.Level1)
73 {
74 MessageParcel data;
75 OHOS::AppExecFwk::ElementName admin;
76 admin.SetBundleName(ADMIN_PACKAGENAME);
77 data.WriteParcelable(&admin);
78 data.WriteString("ntp.aliyun.com");
79 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
80 .Times(1)
81 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
82
83 int32_t ret = systemmanagerProxy->SetNTPServer(data);
84 ASSERT_TRUE(ret == ERR_OK);
85 }
86
87 /**
88 * @tc.name: TestSetNTPServerFail
89 * @tc.desc: Test SetNTPServer func.
90 * @tc.type: FUNC
91 */
92 HWTEST_F(SystemManagerProxyTest, TestSetNTPServerFail, TestSize.Level1)
93 {
94 Utils::SetEdmServiceDisable();
95 MessageParcel data;
96 OHOS::AppExecFwk::ElementName admin;
97 admin.SetBundleName(ADMIN_PACKAGENAME);
98 data.WriteParcelable(&admin);
99 data.WriteString("ntp.aliyun.com");
100
101 int32_t ret = systemmanagerProxy->SetNTPServer(data);
102 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
103 }
104
105 /**
106 * @tc.name: TestGetNTPServerSuc
107 * @tc.desc: Test GetNTPServer func.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(SystemManagerProxyTest, TestGetNTPServerSuc, TestSize.Level1)
111 {
112 MessageParcel data;
113 OHOS::AppExecFwk::ElementName admin;
114 admin.SetBundleName(ADMIN_PACKAGENAME);
115 data.WriteParcelable(&admin);
116 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
117 .Times(1)
118 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
119
120 std::string server = "";
121 int32_t ret = systemmanagerProxy->GetNTPServer(data, server);
122 ASSERT_TRUE(ret == ERR_OK);
123 ASSERT_TRUE(server == RETURN_STRING);
124 }
125
126 /**
127 * @tc.name: TestGetNTPServerFail
128 * @tc.desc: Test GetNTPServer func.
129 * @tc.type: FUNC
130 */
131 HWTEST_F(SystemManagerProxyTest, TestGetNTPServerFail, TestSize.Level1)
132 {
133 Utils::SetEdmServiceDisable();
134 MessageParcel data;
135 OHOS::AppExecFwk::ElementName admin;
136 admin.SetBundleName(ADMIN_PACKAGENAME);
137 data.WriteParcelable(&admin);
138 std::string server = "";
139 int32_t ret = systemmanagerProxy->GetNTPServer(data, server);
140 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
141 }
142
143 /**
144 * @tc.name: TestSetOTAUpdatePolicySuc
145 * @tc.desc: Test SetOTAUpdatePolicy func.
146 * @tc.type: FUNC
147 */
148 HWTEST_F(SystemManagerProxyTest, TestSetOTAUpdatePolicySuc, TestSize.Level1)
149 {
150 MessageParcel data;
151 OHOS::AppExecFwk::ElementName admin;
152 admin.SetBundleName(ADMIN_PACKAGENAME);
153 data.WriteParcelable(&admin);
154 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
155 .Times(1)
156 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
157 UpdatePolicy updatePolicy;
158 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
159
160 std::string message;
161 int32_t ret = systemmanagerProxy->SetOTAUpdatePolicy(data, message);
162 ASSERT_TRUE(ret == ERR_OK);
163 }
164
165 /**
166 * @tc.name: TestSetOTAUpdatePolicyParamError
167 * @tc.desc: Test SetOTAUpdatePolicy func.
168 * @tc.type: FUNC
169 */
170 HWTEST_F(SystemManagerProxyTest, TestSetOTAUpdatePolicyParamError, TestSize.Level1)
171 {
172 MessageParcel data;
173 OHOS::AppExecFwk::ElementName admin;
174 admin.SetBundleName(ADMIN_PACKAGENAME);
175 data.WriteParcelable(&admin);
176 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
177 .Times(1)
178 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestParamError));
179 UpdatePolicy updatePolicy;
180 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
181
182 std::string message;
183 int32_t ret = systemmanagerProxy->SetOTAUpdatePolicy(data, message);
184 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
185 ASSERT_EQ(message, RETURN_STRING);
186 }
187
188 /**
189 * @tc.name: TestGetOTAUpdatePolicyFail
190 * @tc.desc: Test GetOTAUpdatePolicy func.
191 * @tc.type: FUNC
192 */
193 HWTEST_F(SystemManagerProxyTest, TestGetOTAUpdatePolicyFail, TestSize.Level1)
194 {
195 Utils::SetEdmServiceDisable();
196 MessageParcel data;
197 OHOS::AppExecFwk::ElementName admin;
198 admin.SetBundleName(ADMIN_PACKAGENAME);
199 data.WriteParcelable(&admin);
200
201 UpdatePolicy updatePolicy;
202 int32_t ret = systemmanagerProxy->GetOTAUpdatePolicy(data, updatePolicy);
203 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
204 }
205
206 /**
207 * @tc.name: TestGetOTAUpdatePolicySuc
208 * @tc.desc: Test GetOTAUpdatePolicy func.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(SystemManagerProxyTest, TestGetOTAUpdatePolicySuc, TestSize.Level1)
212 {
213 MessageParcel data;
214 OHOS::AppExecFwk::ElementName admin;
215 admin.SetBundleName(ADMIN_PACKAGENAME);
216 data.WriteParcelable(&admin);
217 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
218 .Times(1)
219 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetOTAUpdatePolicy));
220
221 UpdatePolicy updatePolicy;
222 int32_t ret = systemmanagerProxy->GetOTAUpdatePolicy(data, updatePolicy);
223 ASSERT_TRUE(ret == ERR_OK);
224 ASSERT_EQ(updatePolicy.type, UpdatePolicyType::PROHIBIT);
225 ASSERT_EQ(updatePolicy.version, UPGRADE_VERSION);
226 }
227
228 /**
229 * @tc.name: TestNotifyUpdatePackagesSuc
230 * @tc.desc: Test NotifyUpdatePackages func.
231 * @tc.type: FUNC
232 */
233 HWTEST_F(SystemManagerProxyTest, TestNotifyUpdatePackagesSuc, TestSize.Level1)
234 {
235 AppExecFwk::ElementName admin;
236 admin.SetBundleName(ADMIN_PACKAGENAME);
237 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
238 .Times(1)
239 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
240 UpgradePackageInfo packageInfo;
241 std::string errMsg;
242 int32_t ret = systemmanagerProxy->NotifyUpdatePackages(admin, packageInfo, errMsg);
243 ASSERT_TRUE(ret == ERR_OK);
244 }
245
246 /**
247 * @tc.name: TestGetUpgradeResultFail
248 * @tc.desc: Test GetUpgradeResult func.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(SystemManagerProxyTest, TestGetUpgradeResultFail, TestSize.Level1)
252 {
253 Utils::SetEdmServiceDisable();
254 AppExecFwk::ElementName admin;
255 admin.SetBundleName(ADMIN_PACKAGENAME);
256 UpgradeResult upgradeResult;
257 int32_t ret = systemmanagerProxy->GetUpgradeResult(admin, UPGRADE_VERSION, upgradeResult);
258 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
259 }
260
261 /**
262 * @tc.name: TestGetUpgradeResultSuc
263 * @tc.desc: Test GetUpgradeResult func.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(SystemManagerProxyTest, TestGetUpgradeResultSuc, TestSize.Level1)
267 {
268 AppExecFwk::ElementName admin;
269 admin.SetBundleName(ADMIN_PACKAGENAME);
270 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
271 .Times(1)
272 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetUpgradeResult));
273 UpgradeResult upgradeResult;
274 int32_t ret = systemmanagerProxy->GetUpgradeResult(admin, UPGRADE_VERSION, upgradeResult);
275 ASSERT_TRUE(ret == ERR_OK);
276 ASSERT_TRUE(upgradeResult.status == UpgradeStatus::UPGRADE_FAILURE);
277 ASSERT_EQ(upgradeResult.version, UPGRADE_VERSION);
278 ASSERT_EQ(upgradeResult.errorCode, UPGRADE_FAILED_CODE);
279 ASSERT_EQ(upgradeResult.errorMessage, UPGRADE_FAILED_MESSAGE);
280 }
281 } // namespace TEST
282 } // namespace EDM
283 } // namespace OHOS
284