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 <memory>
18
19 #include "cloud_sync_manager_impl.h"
20 #include "cloud_sync_service_proxy.h"
21 #include "dfs_error.h"
22 #include "i_cloud_sync_service_mock.h"
23 #include "iservice_registry.h"
24 #include "service_callback_mock.h"
25
26 namespace OHOS {
27 namespace FileManagement::CloudSync {
28 namespace Test {
29 using namespace testing::ext;
30 using namespace testing;
31 using namespace std;
32
33 class CloudSyncManagerTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 std::shared_ptr<CloudSyncManagerImpl> managePtr_;
40 };
41
42 class CloudSyncCallbackDerived : public CloudSyncCallback {
43 public:
OnSyncStateChanged(CloudSyncState state,ErrorType error)44 void OnSyncStateChanged(CloudSyncState state, ErrorType error)
45 {
46 std::cout << "OnSyncStateChanged" << std::endl;
47 }
48 };
49
SetUpTestCase(void)50 void CloudSyncManagerTest::SetUpTestCase(void)
51 {
52 std::cout << "SetUpTestCase" << std::endl;
53 }
54
TearDownTestCase(void)55 void CloudSyncManagerTest::TearDownTestCase(void)
56 {
57 std::cout << "TearDownTestCase" << std::endl;
58 }
59
SetUp(void)60 void CloudSyncManagerTest::SetUp(void)
61 {
62 std::cout << "SetUp" << std::endl;
63 }
64
TearDown(void)65 void CloudSyncManagerTest::TearDown(void)
66 {
67 managePtr_ = nullptr;
68 std::cout << "TearDown" << std::endl;
69 }
70
71 /**
72 * @tc.name: RegisterCallbackTest
73 * @tc.desc: Verify the RegisterCallback function.
74 * @tc.type: FUNC
75 * @tc.require: I6H5MH
76 */
77 HWTEST_F(CloudSyncManagerTest, RegisterCallbackTest, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
80 try {
81 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
82 auto res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
83 EXPECT_EQ(res, E_OK);
84 callback = nullptr;
85 res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
86 EXPECT_EQ(res, E_INVAL_ARG);
87 } catch (...) {
88 EXPECT_TRUE(false);
89 GTEST_LOG_(INFO) << " RegisterCallbackTest FAILED";
90 }
91 GTEST_LOG_(INFO) << "RegisterCallbackTest End";
92 }
93
94 /**
95 * @tc.name: StartSyncTest
96 * @tc.desc: Verify the StartSync function.
97 * @tc.type: FUNC
98 * @tc.require: I6H5MH
99 */
100 HWTEST_F(CloudSyncManagerTest, StartSyncTest, TestSize.Level1)
101 {
102 GTEST_LOG_(INFO) << "StartSyncTest Start";
103 try {
104 bool forceFlag = false;
105 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
106 auto res = CloudSyncManagerImpl::GetInstance().StartSync();
107 EXPECT_EQ(res, E_OK);
108 res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, callback);
109 EXPECT_EQ(res, E_OK);
110 forceFlag = true;
111 res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, callback);
112 EXPECT_EQ(res, E_OK);
113 forceFlag = true;
114 res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, nullptr);
115 EXPECT_EQ(res, E_INVAL_ARG);
116 forceFlag = false;
117 res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, nullptr);
118 EXPECT_EQ(res, E_INVAL_ARG);
119 } catch (...) {
120 EXPECT_TRUE(false);
121 GTEST_LOG_(INFO) << " StartSyncTest FAILED";
122 }
123 GTEST_LOG_(INFO) << "StartSyncTest End";
124 }
125
126 /*
127 * @tc.name: StopSyncTest
128 * @tc.desc: Verify the StopSync function.
129 * @tc.type: FUNC
130 * @tc.require: I6H5MH
131 */
132 HWTEST_F(CloudSyncManagerTest, StopSyncTest, TestSize.Level1)
133 {
134 GTEST_LOG_(INFO) << "StopSyncTest Start";
135 try {
136 int res = CloudSyncManagerImpl::GetInstance().StopSync();
137 EXPECT_EQ(res, E_OK);
138 } catch (...) {
139 EXPECT_TRUE(false);
140 GTEST_LOG_(INFO) << " StopSyncTest FAILED";
141 }
142 GTEST_LOG_(INFO) << "StopSyncTest End";
143 }
144
145 /*
146 * @tc.name: ChangeAppSwitchTest
147 * @tc.desc: Verify the ChangeAppSwitch function.
148 * @tc.type: FUNC
149 * @tc.require: I6H5MH
150 */
151 HWTEST_F(CloudSyncManagerTest, ChangeAppSwitchTest, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "ChangeAppSwitchTest Start";
154 try {
155 std::string accoutId = "accoutId";
156 std::string bundleName = "bundleName";
157 bool status = true;
158 auto res = CloudSyncManagerImpl::GetInstance().ChangeAppSwitch(accoutId, bundleName, status);
159 EXPECT_EQ(res, E_OK);
160 } catch (...) {
161 EXPECT_TRUE(false);
162 GTEST_LOG_(INFO) << " ChangeAppSwitchTest FAILED";
163 }
164 GTEST_LOG_(INFO) << "ChangeAppSwitchTest End";
165 }
166
167 /*
168 * @tc.name: NotifyDataChangeTest
169 * @tc.desc: Verify the NotifyDataChange function.
170 * @tc.type: FUNC
171 * @tc.require: I6H5MH
172 */
173 HWTEST_F(CloudSyncManagerTest, NotifyDataChangeTest, TestSize.Level1)
174 {
175 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
176 try {
177 std::string accoutId = "accoutId";
178 std::string bundleName = "bundleName";
179 auto res = CloudSyncManagerImpl::GetInstance().NotifyDataChange(accoutId, bundleName);
180 EXPECT_EQ(res, E_OK);
181 } catch (...) {
182 EXPECT_TRUE(false);
183 GTEST_LOG_(INFO) << " NotifyDataChangeTest FAILED";
184 }
185 GTEST_LOG_(INFO) << "NotifyDataChangeTest End";
186 }
187
188 /*
189 * @tc.name: StartDownloadFileTest
190 * @tc.desc: Verify the StartDownloadFile function.
191 * @tc.type: FUNC
192 * @tc.require: I6H5MH
193 */
194 HWTEST_F(CloudSyncManagerTest, StartDownloadFileTest, TestSize.Level1)
195 {
196 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
197 try {
198 std::string uri = "uri";
199 auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri);
200 EXPECT_EQ(res, E_OK);
201 } catch (...) {
202 EXPECT_TRUE(false);
203 GTEST_LOG_(INFO) << " StartDownloadFileTest FAILED";
204 }
205 GTEST_LOG_(INFO) << "StartDownloadFileTest End";
206 }
207
208 /*
209 * @tc.name: StopDownloadFileTest
210 * @tc.desc: Verify the StopDownloadFile function.
211 * @tc.type: FUNC
212 * @tc.require: I6H5MH
213 */
214 HWTEST_F(CloudSyncManagerTest, StopDownloadFileTest, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
217 try {
218 std::string uri = "uri";
219 auto res = CloudSyncManagerImpl::GetInstance().StopDownloadFile(uri);
220 EXPECT_EQ(res, E_OK);
221 } catch (...) {
222 EXPECT_TRUE(false);
223 GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED";
224 }
225 GTEST_LOG_(INFO) << "StopDownloadFileTest End";
226 }
227
228 /*
229 * @tc.name: RegisterDownloadFileCallbackTest
230 * @tc.desc: Verify the UnregisterDownloadFileCallback function.
231 * @tc.type: FUNC
232 * @tc.require: I6H5MH
233 */
234 HWTEST_F(CloudSyncManagerTest, RegisterDownloadFileCallbackTest, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
237 try {
238 auto res = CloudSyncManagerImpl::GetInstance().UnregisterDownloadFileCallback();
239 EXPECT_EQ(res, E_OK);
240 } catch (...) {
241 EXPECT_TRUE(false);
242 GTEST_LOG_(INFO) << " RegisterDownloadFileCallbackTest FAILED";
243 }
244 GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest End";
245 }
246
247 /*
248 * @tc.name: SetDeathRecipientTest
249 * @tc.desc: Verify the SetDeathRecipient function.
250 * @tc.type: FUNC
251 * @tc.require: I6H5MH
252 */
253 HWTEST_F(CloudSyncManagerTest, SetDeathRecipientTest, TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
256 try {
257 auto CloudSyncServiceProxy = CloudSyncServiceProxy::GetInstance();
258 CloudSyncManagerImpl::GetInstance().SetDeathRecipient(CloudSyncServiceProxy->AsObject());
259 EXPECT_TRUE(true);
260 } catch (...) {
261 EXPECT_TRUE(false);
262 GTEST_LOG_(INFO) << " SetDeathRecipientTest FAILED";
263 }
264 GTEST_LOG_(INFO) << "SetDeathRecipientTest End";
265 }
266
267 /*
268 * @tc.name: EnableCloudTest
269 * @tc.desc: Verify the EnableCloud function.
270 * @tc.type: FUNC
271 * @tc.require: I6H5MH
272 */
273 HWTEST_F(CloudSyncManagerTest, EnableCloudTest, TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
276 try {
277 std::string accoutId = "accoutId";
278 SwitchDataObj switchData;
279 auto res = CloudSyncManagerImpl::GetInstance().EnableCloud(accoutId, switchData);
280 EXPECT_EQ(res, E_OK);
281 } catch (...) {
282 EXPECT_TRUE(false);
283 GTEST_LOG_(INFO) << " EnableCloudTest FAILED";
284 }
285 GTEST_LOG_(INFO) << "EnableCloudTest End";
286 }
287
288 /*
289 * @tc.name: DisableCloudTest
290 * @tc.desc: Verify the DisableCloud function.
291 * @tc.type: FUNC
292 * @tc.require: I6H5MH
293 */
294 HWTEST_F(CloudSyncManagerTest, DisableCloudTest, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
297 try {
298 std::string accoutId = "accoutId";
299 auto res = CloudSyncManagerImpl::GetInstance().DisableCloud(accoutId);
300 EXPECT_EQ(res, E_OK);
301 } catch (...) {
302 EXPECT_TRUE(false);
303 GTEST_LOG_(INFO) << " DisableCloudTest FAILED";
304 }
305 GTEST_LOG_(INFO) << "DisableCloudTest End";
306 }
307
308 /*
309 * @tc.name: CleanTest
310 * @tc.desc: Verify the Clean function.
311 * @tc.type: FUNC
312 * @tc.require: I6H5MH
313 */
314 HWTEST_F(CloudSyncManagerTest, CleanTest, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
317 try {
318 std::string accoutId = "accoutId";
319 CleanOptions cleanOptions;
320 auto res = CloudSyncManagerImpl::GetInstance().Clean(accoutId, cleanOptions);
321 EXPECT_EQ(res, E_OK);
322 } catch (...) {
323 EXPECT_TRUE(false);
324 GTEST_LOG_(INFO) << " CleanTest FAILED";
325 }
326 GTEST_LOG_(INFO) << "CleanTest End";
327 }
328 } // namespace Test
329 } // namespace FileManagement::CloudSync
330 } // namespace OHOS
331