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 CloudSyncManagerImplTest : 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_ = nullptr;
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 
50 class CloudDownloadCallbackDerived : public CloudDownloadCallback {
51 public:
OnDownloadProcess(const DownloadProgressObj & progress)52     void OnDownloadProcess(const DownloadProgressObj& progress)
53     {
54         std::cout << "OnDownloadProcess" << std::endl;
55     }
56 };
57 
SetUpTestCase(void)58 void CloudSyncManagerImplTest::SetUpTestCase(void)
59 {
60     std::cout << "SetUpTestCase" << std::endl;
61 }
62 
TearDownTestCase(void)63 void CloudSyncManagerImplTest::TearDownTestCase(void)
64 {
65     std::cout << "TearDownTestCase" << std::endl;
66 }
67 
SetUp(void)68 void CloudSyncManagerImplTest::SetUp(void)
69 {
70     managePtr_ = make_shared<CloudSyncManagerImpl>();
71     std::cout << "SetUp" << std::endl;
72 }
73 
TearDown(void)74 void CloudSyncManagerImplTest::TearDown(void)
75 {
76     managePtr_ = nullptr;
77     std::cout << "TearDown" << std::endl;
78 }
79 
80 /**
81  * @tc.name: RegisterCallbackTest001
82  * @tc.desc: Verify the RegisterCallback function.
83  * @tc.type: FUNC
84  * @tc.require: I6H5MH
85  */
86 HWTEST_F(CloudSyncManagerImplTest, RegisterCallbackTest001, TestSize.Level1)
87 {
88     GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
89     try {
90         auto callback = nullptr;
91         int32_t res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
92         EXPECT_EQ(res, E_INVAL_ARG);
93     } catch (...) {
94         EXPECT_TRUE(false);
95         GTEST_LOG_(INFO) << "RegisterCallbackTest FAILED";
96     }
97     GTEST_LOG_(INFO) << "RegisterCallbackTest End";
98 }
99 
100 /**
101  * @tc.name: RegisterCallbackTest002
102  * @tc.desc: Verify the RegisterCallback function.
103  * @tc.type: FUNC
104  * @tc.require: I6H5MH
105  */
106 HWTEST_F(CloudSyncManagerImplTest, RegisterCallbackTest002, TestSize.Level1)
107 {
108     GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
109     try {
110         shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
111         int32_t res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
112         EXPECT_EQ(res, E_OK);
113     } catch (...) {
114         EXPECT_TRUE(false);
115         GTEST_LOG_(INFO) << "RegisterCallbackTest FAILED";
116     }
117     GTEST_LOG_(INFO) << "RegisterCallbackTest End";
118 }
119 
120 /*
121  * @tc.name: UnRegisterCallbackTest001
122  * @tc.desc: Verify the UnRegisterCallback function.
123  * @tc.type: FUNC
124  * @tc.require: I6H5MH
125  */
126 HWTEST_F(CloudSyncManagerImplTest, UnRegisterCallbackTest001, TestSize.Level1)
127 {
128     GTEST_LOG_(INFO) << "UnRegisterCallbackTest Start";
129     try {
130         string bundleName = "com.ohos.photos";
131         int32_t res = CloudSyncManagerImpl::GetInstance().UnRegisterCallback(bundleName);
132         EXPECT_EQ(res, E_OK);
133     } catch (...) {
134         EXPECT_TRUE(false);
135         GTEST_LOG_(INFO) << "UnRegisterCallbackTest FAILED";
136     }
137     GTEST_LOG_(INFO) << "UnRegisterCallbackTest End";
138 }
139 
140 /**
141  * @tc.name: StartSyncTest001
142  * @tc.desc: Verify the StartSync function.
143  * @tc.type: FUNC
144  * @tc.require: I6H5MH
145  */
146 HWTEST_F(CloudSyncManagerImplTest, StartSyncTest001, TestSize.Level1)
147 {
148     GTEST_LOG_(INFO) << "StartSyncTest Start";
149     try {
150         string bundleName = "com.ohos.photos";
151         int32_t res = CloudSyncManagerImpl::GetInstance().StartSync(bundleName);
152         EXPECT_EQ(res, E_OK);
153     } catch (...) {
154         EXPECT_TRUE(false);
155         GTEST_LOG_(INFO) << "StartSyncTest FAILED";
156     }
157     GTEST_LOG_(INFO) << "StartSyncTest End";
158 }
159 
160 /**
161  * @tc.name: StartSyncTest002
162  * @tc.desc: Verify the StartSync function.
163  * @tc.type: FUNC
164  * @tc.require: I6H5MH
165  */
166 HWTEST_F(CloudSyncManagerImplTest, StartSyncTest002, TestSize.Level1)
167 {
168     GTEST_LOG_(INFO) << "StartSyncTest Start";
169     try {
170         bool forceFlag = true;
171         string bundleName = "com.ohos.photos";
172         int32_t res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, nullptr);
173         EXPECT_EQ(res, E_INVAL_ARG);
174     } catch (...) {
175         EXPECT_TRUE(false);
176         GTEST_LOG_(INFO) << "StartSyncTest FAILED";
177     }
178     GTEST_LOG_(INFO) << "StartSyncTest End";
179 }
180 
181 /**
182  * @tc.name: StartSyncTest003
183  * @tc.desc: Verify the StartSync function.
184  * @tc.type: FUNC
185  * @tc.require: I6H5MH
186  */
187 HWTEST_F(CloudSyncManagerImplTest, StartSyncTest003, TestSize.Level1)
188 {
189     GTEST_LOG_(INFO) << "StartSyncTest Start";
190     try {
191         bool forceFlag = true;
192         shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
193         string bundleName = "com.ohos.photos";
194         int32_t res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, callback);
195         EXPECT_EQ(res, E_OK);
196     } catch (...) {
197         EXPECT_TRUE(false);
198         GTEST_LOG_(INFO) << "StartSyncTest FAILED";
199     }
200     GTEST_LOG_(INFO) << "StartSyncTest End";
201 }
202 
203 /**
204  * @tc.name: GetSyncTimeTest001
205  * @tc.desc: Verify the GetSyncTime function.
206  * @tc.type: FUNC
207  * @tc.require: I6H5MH
208  */
209 HWTEST_F(CloudSyncManagerImplTest, GetSyncTimeTest001, TestSize.Level1)
210 {
211     GTEST_LOG_(INFO) << "GetSyncTimeTest Start";
212     try {
213         int64_t syncTime = 0;
214         string bundleName = "com.ohos.photos";
215         int32_t res = CloudSyncManagerImpl::GetInstance().GetSyncTime(syncTime, bundleName);
216         EXPECT_EQ(res, E_OK);
217     } catch (...) {
218         EXPECT_TRUE(false);
219         GTEST_LOG_(INFO) << "GetSyncTimeTest FAILED";
220     }
221     GTEST_LOG_(INFO) << "GetSyncTimeTest End";
222 }
223 
224 /**
225  * @tc.name: TriggerSyncTest001
226  * @tc.desc: Verify the TriggerSync function.
227  * @tc.type: FUNC
228  * @tc.require: I6H5MH
229  */
230 HWTEST_F(CloudSyncManagerImplTest, TriggerSyncTest001, TestSize.Level1)
231 {
232     GTEST_LOG_(INFO) << "TriggerSyncTest Start";
233     try {
234         string bundleName = "";
235         int32_t userId = 0;
236         int32_t res = CloudSyncManagerImpl::GetInstance().TriggerSync(bundleName, userId);
237         EXPECT_EQ(res, E_INVAL_ARG);
238     } catch (...) {
239         EXPECT_TRUE(false);
240         GTEST_LOG_(INFO) << "TriggerSyncTest FAILED";
241     }
242     GTEST_LOG_(INFO) << "TriggerSyncTest End";
243 }
244 
245 /**
246  * @tc.name: TriggerSyncTest002
247  * @tc.desc: Verify the TriggerSync function.
248  * @tc.type: FUNC
249  * @tc.require: I6H5MH
250  */
251 HWTEST_F(CloudSyncManagerImplTest, TriggerSyncTest002, TestSize.Level1)
252 {
253     GTEST_LOG_(INFO) << "TriggerSyncTest Start";
254     try {
255         string bundleName = "com.ohos.photos";
256         int32_t userId = 100;
257         int32_t res = CloudSyncManagerImpl::GetInstance().TriggerSync(bundleName, userId);
258         EXPECT_EQ(res, E_OK);
259     } catch (...) {
260         EXPECT_TRUE(false);
261         GTEST_LOG_(INFO) << "TriggerSyncTest FAILED";
262     }
263     GTEST_LOG_(INFO) << "TriggerSyncTest End";
264 }
265 
266 /*
267  * @tc.name: StopSyncTest
268  * @tc.desc: Verify the StopSync function.
269  * @tc.type: FUNC
270  * @tc.require: I6H5MH
271  */
272 HWTEST_F(CloudSyncManagerImplTest, StopSyncTest, TestSize.Level1)
273 {
274     GTEST_LOG_(INFO) << "StopSyncTest Start";
275     try {
276         string bundleName = "com.ohos.photos";
277         int res = CloudSyncManagerImpl::GetInstance().StopSync(bundleName);
278         EXPECT_EQ(res, E_OK);
279     } catch (...) {
280         EXPECT_TRUE(false);
281         GTEST_LOG_(INFO) << " StopSyncTest FAILED";
282     }
283     GTEST_LOG_(INFO) << "StopSyncTest End";
284 }
285 
286 /*
287  * @tc.name: ChangeAppSwitchTest
288  * @tc.desc: Verify the ChangeAppSwitch function.
289  * @tc.type: FUNC
290  * @tc.require: I6H5MH
291  */
292 HWTEST_F(CloudSyncManagerImplTest, ChangeAppSwitchTest, TestSize.Level1)
293 {
294     GTEST_LOG_(INFO) << "ChangeAppSwitchTest Start";
295     try {
296         std::string accoutId = "accoutId";
297         std::string bundleName = "bundleName";
298         bool status = true;
299         auto res = CloudSyncManagerImpl::GetInstance().ChangeAppSwitch(accoutId, bundleName, status);
300         EXPECT_EQ(res, E_OK);
301     } catch (...) {
302         EXPECT_TRUE(false);
303         GTEST_LOG_(INFO) << " ChangeAppSwitchTest FAILED";
304     }
305     GTEST_LOG_(INFO) << "ChangeAppSwitchTest End";
306 }
307 
308 /*
309  * @tc.name: NotifyDataChangeTest
310  * @tc.desc: Verify the NotifyDataChange function.
311  * @tc.type: FUNC
312  * @tc.require: I6H5MH
313  */
314 HWTEST_F(CloudSyncManagerImplTest, NotifyDataChangeTest, TestSize.Level1)
315 {
316     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
317     try {
318         std::string accoutId = "accoutId";
319         std::string bundleName = "bundleName";
320         auto res = CloudSyncManagerImpl::GetInstance().NotifyDataChange(accoutId, bundleName);
321         EXPECT_EQ(res, E_OK);
322     } catch (...) {
323         EXPECT_TRUE(false);
324         GTEST_LOG_(INFO) << " NotifyDataChangeTest FAILED";
325     }
326     GTEST_LOG_(INFO) << "NotifyDataChangeTest End";
327 }
328 
329 /*
330  * @tc.name: NotifyEventChangeTest
331  * @tc.desc: Verify the NotifyEventChange function.
332  * @tc.type: FUNC
333  * @tc.require: I6H5MH
334  */
335 HWTEST_F(CloudSyncManagerImplTest, NotifyEventChangeTest, TestSize.Level1)
336 {
337     GTEST_LOG_(INFO) << "NotifyEventChangeTest Start";
338     try {
339         int32_t userId = 100;
340         std::string eventId = "eventId";
341         std::string extraData = "extraData";
342         auto res = CloudSyncManagerImpl::GetInstance().NotifyEventChange(userId, eventId, extraData);
343         EXPECT_EQ(res, E_OK);
344     } catch (...) {
345         EXPECT_TRUE(false);
346         GTEST_LOG_(INFO) << "NotifyEventChangeTest FAILED";
347     }
348     GTEST_LOG_(INFO) << "NotifyEventChangeTest End";
349 }
350 
351 /*
352  * @tc.name: StartDownloadFileTest
353  * @tc.desc: Verify the StartDownloadFile function.
354  * @tc.type: FUNC
355  * @tc.require: I6H5MH
356  */
357 HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest, TestSize.Level1)
358 {
359     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
360     try {
361         std::string uri = "uri";
362         auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri);
363         EXPECT_EQ(res, E_OK);
364     } catch (...) {
365         EXPECT_TRUE(false);
366         GTEST_LOG_(INFO) << " StartDownloadFileTest FAILED";
367     }
368     GTEST_LOG_(INFO) << "StartDownloadFileTest End";
369 }
370 
371 /*
372  * @tc.name: StartFileCacheTest
373  * @tc.desc: Verify the StartFileCache function.
374  * @tc.type: FUNC
375  * @tc.require: I6H5MH
376  */
377 HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest, TestSize.Level1)
378 {
379     GTEST_LOG_(INFO) << "StartFileCacheTest Start";
380     try {
381         std::string uri = "uri";
382         auto res = CloudSyncManagerImpl::GetInstance().StartFileCache(uri);
383         EXPECT_EQ(res, E_OK);
384     } catch (...) {
385         EXPECT_TRUE(false);
386         GTEST_LOG_(INFO) << "StartFileCacheTest FAILED";
387     }
388     GTEST_LOG_(INFO) << "StartFileCacheTest End";
389 }
390 
391 /*
392  * @tc.name: StopDownloadFileTest
393  * @tc.desc: Verify the StopDownloadFile function.
394  * @tc.type: FUNC
395  * @tc.require: I6H5MH
396  */
397 HWTEST_F(CloudSyncManagerImplTest, StopDownloadFileTest, TestSize.Level1)
398 {
399     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
400     try {
401         std::string uri = "uri";
402         auto res = CloudSyncManagerImpl::GetInstance().StopDownloadFile(uri);
403         EXPECT_EQ(res, E_OK);
404     } catch (...) {
405         EXPECT_TRUE(false);
406         GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED";
407     }
408     GTEST_LOG_(INFO) << "StopDownloadFileTest End";
409 }
410 
411 /*
412  * @tc.name: RegisterDownloadFileCallbackTest
413  * @tc.desc: Verify the UnregisterDownloadFileCallback function.
414  * @tc.type: FUNC
415  * @tc.require: I6H5MH
416  */
417 HWTEST_F(CloudSyncManagerImplTest, RegisterDownloadFileCallbackTest, TestSize.Level1)
418 {
419     GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest Start";
420     try {
421         shared_ptr<CloudDownloadCallback> downloadCallback = make_shared<CloudDownloadCallbackDerived>();
422         auto res = CloudSyncManagerImpl::GetInstance().RegisterDownloadFileCallback(downloadCallback);
423         EXPECT_EQ(res, E_OK);
424     } catch (...) {
425         EXPECT_TRUE(false);
426         GTEST_LOG_(INFO) << " RegisterDownloadFileCallbackTest FAILED";
427     }
428     GTEST_LOG_(INFO) << "RegisterDownloadFileCallbackTest End";
429 }
430 
431 /*
432  * @tc.name: UnregisterDownloadFileCallbackTest
433  * @tc.desc: Verify the UnregisterDownloadFileCallback function.
434  * @tc.type: FUNC
435  * @tc.require: I6H5MH
436  */
437 HWTEST_F(CloudSyncManagerImplTest, UnregisterDownloadFileCallbackTest, TestSize.Level1)
438 {
439     GTEST_LOG_(INFO) << "UnregisterDownloadFileCallbackTest Start";
440     try {
441         auto res = CloudSyncManagerImpl::GetInstance().UnregisterDownloadFileCallback();
442         EXPECT_EQ(res, E_OK);
443     } catch (...) {
444         EXPECT_TRUE(false);
445         GTEST_LOG_(INFO) << " UnregisterDownloadFileCallbackTest FAILED";
446     }
447     GTEST_LOG_(INFO) << "UnregisterDownloadFileCallbackTest End";
448 }
449 
450 /*
451  * @tc.name: SetDeathRecipientTest
452  * @tc.desc: Verify the SetDeathRecipient function.
453  * @tc.type: FUNC
454  * @tc.require: I6H5MH
455  */
456 HWTEST_F(CloudSyncManagerImplTest, SetDeathRecipientTest, TestSize.Level1)
457 {
458     GTEST_LOG_(INFO) << "SetDeathRecipientTest Start";
459     try {
460         auto CloudSyncServiceProxy = CloudSyncServiceProxy::GetInstance();
461         CloudSyncManagerImpl::GetInstance().SetDeathRecipient(CloudSyncServiceProxy->AsObject());
462         EXPECT_TRUE(true);
463     } catch (...) {
464         EXPECT_TRUE(false);
465         GTEST_LOG_(INFO) << "SetDeathRecipientTest FAILED";
466     }
467     GTEST_LOG_(INFO) << "SetDeathRecipientTest End";
468 }
469 
470 /*
471  * @tc.name: EnableCloudTest
472  * @tc.desc: Verify the EnableCloud function.
473  * @tc.type: FUNC
474  * @tc.require: I6H5MH
475  */
476 HWTEST_F(CloudSyncManagerImplTest, EnableCloudTest, TestSize.Level1)
477 {
478     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
479     try {
480         std::string accoutId = "accoutId";
481         SwitchDataObj switchData;
482         auto res = CloudSyncManagerImpl::GetInstance().EnableCloud(accoutId, switchData);
483         EXPECT_EQ(res, E_OK);
484     } catch (...) {
485         EXPECT_TRUE(false);
486         GTEST_LOG_(INFO) << " EnableCloudTest FAILED";
487     }
488     GTEST_LOG_(INFO) << "EnableCloudTest End";
489 }
490 
491 /*
492  * @tc.name: DisableCloudTest
493  * @tc.desc: Verify the DisableCloud function.
494  * @tc.type: FUNC
495  * @tc.require: I6H5MH
496  */
497 HWTEST_F(CloudSyncManagerImplTest, DisableCloudTest, TestSize.Level1)
498 {
499     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
500     try {
501         std::string accoutId = "accoutId";
502         auto res = CloudSyncManagerImpl::GetInstance().DisableCloud(accoutId);
503         EXPECT_EQ(res, E_OK);
504     } catch (...) {
505         EXPECT_TRUE(false);
506         GTEST_LOG_(INFO) << " DisableCloudTest FAILED";
507     }
508     GTEST_LOG_(INFO) << "DisableCloudTest End";
509 }
510 
511 /*
512  * @tc.name: CleanTest
513  * @tc.desc: Verify the Clean function.
514  * @tc.type: FUNC
515  * @tc.require: I6H5MH
516  */
517 HWTEST_F(CloudSyncManagerImplTest, CleanTest, TestSize.Level1)
518 {
519     GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
520     try {
521         std::string accoutId = "accoutId";
522         CleanOptions cleanOptions;
523         auto res = CloudSyncManagerImpl::GetInstance().Clean(accoutId, cleanOptions);
524         EXPECT_EQ(res, E_OK);
525     } catch (...) {
526         EXPECT_TRUE(false);
527         GTEST_LOG_(INFO) << " CleanTest FAILED";
528     }
529     GTEST_LOG_(INFO) << "CleanTest End";
530 }
531 
532 /*
533  * @tc.name: CleanCacheTest
534  * @tc.desc: Verify the CleanCache function.
535  * @tc.type: FUNC
536  * @tc.require: I6H5MH
537  */
538 HWTEST_F(CloudSyncManagerImplTest, CleanCacheTest, TestSize.Level1)
539 {
540     GTEST_LOG_(INFO) << "CleanCacheTest Start";
541     try {
542         string uri = "uri";
543         auto res = CloudSyncManagerImpl::GetInstance().CleanCache(uri);
544         EXPECT_EQ(res, E_OK);
545     } catch (...) {
546         EXPECT_TRUE(false);
547         GTEST_LOG_(INFO) << "CleanCacheTest FAILED";
548     }
549     GTEST_LOG_(INFO) << "CleanCacheTest End";
550 }
551 } // namespace Test
552 } // namespace FileManagement::CloudSync
553 } // namespace OHOS