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