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 <filesystem>
17 #include <fstream>
18 #include <gtest/gtest.h>
19 #include <memory>
20 #include <sys/stat.h>
21 #include <unistd.h>
22
23 #include "cloud_sync_manager_impl.h"
24 #include "dfs_error.h"
25 #include "icloud_sync_service.h"
26 #include "iservice_registry.h"
27 #include "meta_file.h"
28 #include "service_callback_mock.h"
29 #include "service_proxy.h"
30 #include "service_proxy_mock.h"
31 #include "system_ability_manager_client_mock.h"
32
33 namespace OHOS {
34 namespace FileManagement::CloudSync {
35 namespace fs = std::filesystem;
36 using namespace testing::ext;
37 using namespace testing;
38 using namespace std;
39 constexpr int32_t MAX_DENTRY_FILE_SIZE = 500;
40 constexpr int32_t MAX_FILE_CACHE_NUM = 400;
41
42 class CloudSyncManagerImplTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 static inline std::shared_ptr<MockServiceProxy> proxy_ = nullptr;
49 static inline sptr<CloudSyncServiceMock> serviceProxy_ = nullptr;
50 static inline std::shared_ptr<SystemAbilityManagerClientMock> saMgrClient_{nullptr};
51 static inline sptr<ISystemAbilityManagerMock> saMgr_{nullptr};
52 };
53
54 class CloudSyncCallbackDerived : public CloudSyncCallback {
55 public:
OnSyncStateChanged(CloudSyncState state,ErrorType error)56 void OnSyncStateChanged(CloudSyncState state, ErrorType error)
57 {
58 std::cout << "OnSyncStateChanged" << std::endl;
59 }
60 };
61
62 class CloudDownloadCallbackDerived : public CloudDownloadCallback {
63 public:
OnDownloadProcess(const DownloadProgressObj & progress)64 void OnDownloadProcess(const DownloadProgressObj &progress)
65 {
66 std::cout << "OnDownloadProcess" << std::endl;
67 }
68 };
69
70 class DowngradeDlCallbackDerived : public DowngradeDlCallback {
71 public:
OnDownloadProcess(const DowngradeProgress & progress)72 void OnDownloadProcess(const DowngradeProgress &progress)
73 {
74 std::cout << "OnDownloadProcess" << std::endl;
75 }
76 };
77
SetUpTestCase(void)78 void CloudSyncManagerImplTest::SetUpTestCase(void)
79 {
80 saMgrClient_ = make_shared<SystemAbilityManagerClientMock>();
81 proxy_ = std::make_shared<MockServiceProxy>();
82 IserviceProxy::proxy_ = proxy_;
83 serviceProxy_ = sptr(new CloudSyncServiceMock());
84 CloudSyncManagerImpl::GetInstance().isFirstCall_.test_and_set();
85 std::cout << "SetUpTestCase" << std::endl;
86 }
87
TearDownTestCase(void)88 void CloudSyncManagerImplTest::TearDownTestCase(void)
89 {
90 ISystemAbilityManagerClient::smc = nullptr;
91 IserviceProxy::proxy_ = nullptr;
92 saMgrClient_ = nullptr;
93 proxy_ = nullptr;
94 serviceProxy_ = nullptr;
95 std::cout << "TearDownTestCase" << std::endl;
96 }
97
SetUp(void)98 void CloudSyncManagerImplTest::SetUp(void)
99 {
100 std::cout << "SetUp" << std::endl;
101 }
102
TearDown(void)103 void CloudSyncManagerImplTest::TearDown(void)
104 {
105 std::cout << "TearDown" << std::endl;
106 }
107
108 /**
109 * @tc.name: RegisterCallbackTest002
110 * @tc.desc: Verify the RegisterCallback function.
111 * @tc.type: FUNC
112 * @tc.require: I6H5MH
113 */
114 HWTEST_F(CloudSyncManagerImplTest, RegisterCallbackTest002, TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
117 try {
118 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
119 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
120 EXPECT_CALL(*serviceProxy_, RegisterCallbackInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
121 int32_t res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
122 EXPECT_EQ(res, E_PERMISSION_DENIED);
123 } catch (...) {
124 EXPECT_TRUE(false);
125 GTEST_LOG_(INFO) << "RegisterCallbackTest FAILED";
126 }
127 GTEST_LOG_(INFO) << "RegisterCallbackTest End";
128 }
129
130 /*
131 * @tc.name: UnRegisterCallbackTest001
132 * @tc.desc: Verify the UnRegisterCallback function.
133 * @tc.type: FUNC
134 * @tc.require: I6H5MH
135 */
136 HWTEST_F(CloudSyncManagerImplTest, UnRegisterCallbackTest001, TestSize.Level1)
137 {
138 GTEST_LOG_(INFO) << "UnRegisterCallbackTest Start";
139 try {
140 string bundleName = "com.ohos.photos";
141 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
142 EXPECT_CALL(*serviceProxy_, UnRegisterCallbackInner(_)).WillOnce(Return(E_PERMISSION_DENIED));
143 int32_t res = CloudSyncManagerImpl::GetInstance().UnRegisterCallback(bundleName);
144 EXPECT_EQ(res, E_PERMISSION_DENIED);
145 } catch (...) {
146 EXPECT_TRUE(false);
147 GTEST_LOG_(INFO) << "UnRegisterCallbackTest FAILED";
148 }
149 GTEST_LOG_(INFO) << "UnRegisterCallbackTest End";
150 }
151
152 /**
153 * @tc.name: StartSyncTest001
154 * @tc.desc: Verify the StartSync function.
155 * @tc.type: FUNC
156 * @tc.require: I6H5MH
157 */
158 HWTEST_F(CloudSyncManagerImplTest, StartSyncTest001, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "StartSyncTest Start";
161 try {
162 string bundleName = "com.ohos.photos";
163 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
164 EXPECT_CALL(*serviceProxy_, StartSyncInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
165 int32_t res = CloudSyncManagerImpl::GetInstance().StartSync(bundleName);
166 EXPECT_EQ(res, E_PERMISSION_DENIED);
167 } catch (...) {
168 EXPECT_TRUE(false);
169 GTEST_LOG_(INFO) << "StartSyncTest FAILED";
170 }
171 GTEST_LOG_(INFO) << "StartSyncTest End";
172 }
173
174 /**
175 * @tc.name: StartSyncTest003
176 * @tc.desc: Verify the StartSync function.
177 * @tc.type: FUNC
178 * @tc.require: I6H5MH
179 */
180 HWTEST_F(CloudSyncManagerImplTest, StartSyncTest003, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO) << "StartSyncTest Start";
183 try {
184 bool forceFlag = true;
185 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
186 string bundleName = "com.ohos.photos";
187 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
188 EXPECT_CALL(*serviceProxy_, RegisterCallbackInner(_, _)).WillOnce(Return(E_OK));
189 EXPECT_CALL(*serviceProxy_, StartSyncInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
190 int32_t res = CloudSyncManagerImpl::GetInstance().StartSync(forceFlag, callback);
191 EXPECT_EQ(res, E_PERMISSION_DENIED);
192 } catch (...) {
193 EXPECT_TRUE(false);
194 GTEST_LOG_(INFO) << "StartSyncTest FAILED";
195 }
196 GTEST_LOG_(INFO) << "StartSyncTest End";
197 }
198
199 /**
200 * @tc.name: GetSyncTimeTest001
201 * @tc.desc: Verify the GetSyncTime function.
202 * @tc.type: FUNC
203 * @tc.require: I6H5MH
204 */
205 HWTEST_F(CloudSyncManagerImplTest, GetSyncTimeTest001, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "GetSyncTimeTest Start";
208 try {
209 int64_t syncTime = 0;
210 string bundleName = "com.ohos.photos";
211 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
212 EXPECT_CALL(*serviceProxy_, GetSyncTimeInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
213 int32_t res = CloudSyncManagerImpl::GetInstance().GetSyncTime(syncTime, bundleName);
214 EXPECT_EQ(res, E_PERMISSION_DENIED);
215 } catch (...) {
216 EXPECT_TRUE(false);
217 GTEST_LOG_(INFO) << "GetSyncTimeTest FAILED";
218 }
219 GTEST_LOG_(INFO) << "GetSyncTimeTest End";
220 }
221
222 /**
223 * @tc.name: TriggerSyncTest002
224 * @tc.desc: Verify the TriggerSync function.
225 * @tc.type: FUNC
226 * @tc.require: I6H5MH
227 */
228 HWTEST_F(CloudSyncManagerImplTest, TriggerSyncTest002, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "TriggerSyncTest Start";
231 try {
232 string bundleName = "com.ohos.photos";
233 int32_t userId = 100;
234 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
235 EXPECT_CALL(*serviceProxy_, TriggerSyncInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
236 int32_t res = CloudSyncManagerImpl::GetInstance().TriggerSync(bundleName, userId);
237 EXPECT_EQ(res, E_PERMISSION_DENIED);
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: StopSyncTest
247 * @tc.desc: Verify the StopSync function.
248 * @tc.type: FUNC
249 * @tc.require: I6H5MH
250 */
251 HWTEST_F(CloudSyncManagerImplTest, StopSyncTest, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "StopSyncTest Start";
254 try {
255 string bundleName = "com.ohos.photos";
256 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
257 EXPECT_CALL(*serviceProxy_, StopSyncInner(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
258 int res = CloudSyncManagerImpl::GetInstance().StopSync(bundleName);
259 EXPECT_EQ(res, E_PERMISSION_DENIED);
260 } catch (...) {
261 EXPECT_TRUE(false);
262 GTEST_LOG_(INFO) << " StopSyncTest FAILED";
263 }
264 GTEST_LOG_(INFO) << "StopSyncTest End";
265 }
266
267 /*
268 * @tc.name: ChangeAppSwitchTest
269 * @tc.desc: Verify the ChangeAppSwitch function.
270 * @tc.type: FUNC
271 * @tc.require: I6H5MH
272 */
273 HWTEST_F(CloudSyncManagerImplTest, ChangeAppSwitchTest, TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "ChangeAppSwitchTest Start";
276 try {
277 std::string accoutId = "accoutId";
278 std::string bundleName = "bundleName";
279 bool status = true;
280 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
281 EXPECT_CALL(*serviceProxy_, ChangeAppSwitch(_, _, _)).WillOnce(Return(E_INVAL_ARG));
282 auto res = CloudSyncManagerImpl::GetInstance().ChangeAppSwitch(accoutId, bundleName, status);
283 EXPECT_EQ(res, E_INVAL_ARG);
284 } catch (...) {
285 EXPECT_TRUE(false);
286 GTEST_LOG_(INFO) << " ChangeAppSwitchTest FAILED";
287 }
288 GTEST_LOG_(INFO) << "ChangeAppSwitchTest End";
289 }
290
291 /*
292 * @tc.name: NotifyEventChangeTest
293 * @tc.desc: Verify the NotifyEventChange function.
294 * @tc.type: FUNC
295 * @tc.require: I6H5MH
296 */
297 HWTEST_F(CloudSyncManagerImplTest, NotifyEventChangeTest, TestSize.Level1)
298 {
299 GTEST_LOG_(INFO) << "NotifyEventChangeTest Start";
300 try {
301 int32_t userId = 100;
302 std::string eventId = "eventId";
303 std::string extraData = "extraData";
304 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
305 EXPECT_CALL(*serviceProxy_, NotifyEventChange(_, _, _)).WillOnce(Return(E_PERMISSION_DENIED));
306 auto res = CloudSyncManagerImpl::GetInstance().NotifyEventChange(userId, eventId, extraData);
307 EXPECT_EQ(res, E_PERMISSION_DENIED);
308 } catch (...) {
309 EXPECT_TRUE(false);
310 GTEST_LOG_(INFO) << "NotifyEventChangeTest FAILED";
311 }
312 GTEST_LOG_(INFO) << "NotifyEventChangeTest End";
313 }
314
315 /*
316 * @tc.name: StartDownloadFileTest001
317 * @tc.desc: Verify the StartDownloadFile function.
318 * @tc.type: FUNC
319 * @tc.require: I6H5MH
320 */
321 HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest001, TestSize.Level1)
322 {
323 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
324 try {
325 std::string uri = "uri";
326 int64_t downloadId = 0;
327 shared_ptr<CloudDownloadCallback> callback = make_shared<CloudDownloadCallbackDerived>();
328 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
329 EXPECT_CALL(*serviceProxy_, StartDownloadFile).WillOnce(Return(E_PERMISSION_DENIED));
330 auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri, callback, downloadId);
331 EXPECT_EQ(res, E_PERMISSION_DENIED);
332 } catch (...) {
333 EXPECT_TRUE(false);
334 GTEST_LOG_(INFO) << " StartDownloadFileTest001 FAILED";
335 }
336 GTEST_LOG_(INFO) << "StartDownloadFileTest001 End";
337 }
338
339 /*
340 * @tc.name: StartDownloadFileTest002
341 * @tc.desc: Verify the StartDownloadFile function.
342 * @tc.type: FUNC
343 * @tc.require: I6H5MH
344 */
345 HWTEST_F(CloudSyncManagerImplTest, StartDownloadFileTest002, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
348 try {
349 std::string uri = "uri";
350 int64_t downloadId = 0;
351 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
352 auto res = CloudSyncManagerImpl::GetInstance().StartDownloadFile(uri, nullptr, downloadId);
353 EXPECT_EQ(res, E_INVAL_ARG);
354 } catch (...) {
355 EXPECT_TRUE(false);
356 GTEST_LOG_(INFO) << " StartDownloadFileTest002 FAILED";
357 }
358 GTEST_LOG_(INFO) << "StartDownloadFileTest002 End";
359 }
360
361 /*
362 * @tc.name: StartFileCacheTest
363 * @tc.desc: Verify the StartFileCache function.
364 * @tc.type: FUNC
365 * @tc.require: I6H5MH
366 */
367 HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "StartFileCacheTest Start";
370 try {
371 std::string uri = "uri";
372 int64_t downloadId = 0;
373 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
374 EXPECT_CALL(*serviceProxy_, StartFileCache).WillOnce(Return(E_PERMISSION_DENIED));
375 auto res = CloudSyncManagerImpl::GetInstance().StartFileCache({uri}, downloadId);
376 EXPECT_EQ(res, E_PERMISSION_DENIED);
377 } catch (...) {
378 EXPECT_TRUE(false);
379 GTEST_LOG_(INFO) << "StartFileCacheTest FAILED";
380 }
381 GTEST_LOG_(INFO) << "StartFileCacheTest End";
382 }
383
384 /*
385 * @tc.name: StopDownloadFileTest
386 * @tc.desc: Verify the StopDownloadFile function.
387 * @tc.type: FUNC
388 * @tc.require: I6H5MH
389 */
390 HWTEST_F(CloudSyncManagerImplTest, StopDownloadFileTest, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
393 try {
394 int64_t downloadId = 1;
395 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
396 EXPECT_CALL(*serviceProxy_, StopDownloadFile(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
397 auto res = CloudSyncManagerImpl::GetInstance().StopDownloadFile(downloadId, true);
398 EXPECT_EQ(res, E_PERMISSION_DENIED);
399 } catch (...) {
400 EXPECT_TRUE(false);
401 GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED";
402 }
403 GTEST_LOG_(INFO) << "StopDownloadFileTest End";
404 }
405
406 /*
407 * @tc.name: EnableCloudTest
408 * @tc.desc: Verify the EnableCloud function.
409 * @tc.type: FUNC
410 * @tc.require: I6H5MH
411 */
412 HWTEST_F(CloudSyncManagerImplTest, EnableCloudTest, TestSize.Level1)
413 {
414 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
415 try {
416 std::string accoutId = "accoutId";
417 SwitchDataObj switchData;
418 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
419 EXPECT_CALL(*serviceProxy_, EnableCloud(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
420 auto res = CloudSyncManagerImpl::GetInstance().EnableCloud(accoutId, switchData);
421 EXPECT_EQ(res, E_PERMISSION_DENIED);
422 } catch (...) {
423 EXPECT_TRUE(false);
424 GTEST_LOG_(INFO) << " EnableCloudTest FAILED";
425 }
426 GTEST_LOG_(INFO) << "EnableCloudTest End";
427 }
428
429 /*
430 * @tc.name: DisableCloudTest
431 * @tc.desc: Verify the DisableCloud function.
432 * @tc.type: FUNC
433 * @tc.require: I6H5MH
434 */
435 HWTEST_F(CloudSyncManagerImplTest, DisableCloudTest, TestSize.Level1)
436 {
437 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
438 try {
439 std::string accoutId = "accoutId";
440 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
441 EXPECT_CALL(*serviceProxy_, DisableCloud(_)).WillOnce(Return(E_PERMISSION_DENIED));
442 auto res = CloudSyncManagerImpl::GetInstance().DisableCloud(accoutId);
443 EXPECT_EQ(res, E_PERMISSION_DENIED);
444 } catch (...) {
445 EXPECT_TRUE(false);
446 GTEST_LOG_(INFO) << " DisableCloudTest FAILED";
447 }
448 GTEST_LOG_(INFO) << "DisableCloudTest End";
449 }
450
451 /*
452 * @tc.name: CleanTest
453 * @tc.desc: Verify the Clean function.
454 * @tc.type: FUNC
455 * @tc.require: I6H5MH
456 */
457 HWTEST_F(CloudSyncManagerImplTest, CleanTest, TestSize.Level1)
458 {
459 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
460 try {
461 std::string accoutId = "accoutId";
462 CleanOptions cleanOptions;
463 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
464 EXPECT_CALL(*serviceProxy_, Clean(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
465 auto res = CloudSyncManagerImpl::GetInstance().Clean(accoutId, cleanOptions);
466 EXPECT_EQ(res, E_PERMISSION_DENIED);
467 } catch (...) {
468 EXPECT_TRUE(false);
469 GTEST_LOG_(INFO) << " CleanTest FAILED";
470 }
471 GTEST_LOG_(INFO) << "CleanTest End";
472 }
473
474 /*
475 * @tc.name: CleanCacheTest
476 * @tc.desc: Verify the CleanCache function.
477 * @tc.type: FUNC
478 * @tc.require: I6H5MH
479 */
480 HWTEST_F(CloudSyncManagerImplTest, CleanCacheTest, TestSize.Level1)
481 {
482 GTEST_LOG_(INFO) << "CleanCacheTest Start";
483 try {
484 string uri = "uri";
485 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
486 EXPECT_CALL(*serviceProxy_, CleanCacheInner(_)).WillOnce(Return(E_PERMISSION_DENIED));
487 auto res = CloudSyncManagerImpl::GetInstance().CleanCache(uri);
488 EXPECT_EQ(res, E_PERMISSION_DENIED);
489 } catch (...) {
490 EXPECT_TRUE(false);
491 GTEST_LOG_(INFO) << "CleanCacheTest FAILED";
492 }
493 GTEST_LOG_(INFO) << "CleanCacheTest End";
494 }
495
496 /*
497 * @tc.name: CleanFileCacheTest001
498 * @tc.desc: Verify the CleanFileCache function.
499 * @tc.type: FUNC
500 * @tc.require: ICK6VD
501 */
502 HWTEST_F(CloudSyncManagerImplTest, CleanFileCacheTest001, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "CleanFileCacheTest001 Start";
505 try {
506 string uri = "uri";
507 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
508 EXPECT_CALL(*serviceProxy_, CleanFileCacheInner(_)).WillOnce(Return(E_OK));
509 auto res = CloudSyncManagerImpl::GetInstance().CleanFileCache(uri);
510 EXPECT_EQ(res, E_OK);
511 } catch (...) {
512 EXPECT_TRUE(false);
513 GTEST_LOG_(INFO) << "CleanFileCacheTest001 FAILED";
514 }
515 GTEST_LOG_(INFO) << "CleanFileCacheTest001 End";
516 }
517
518 /*
519 * @tc.name: CleanFileCacheTest002
520 * @tc.desc: Verify the CleanFileCache function.
521 * @tc.type: FUNC
522 * @tc.require: ICK6VD
523 */
524 HWTEST_F(CloudSyncManagerImplTest, CleanFileCacheTest002, TestSize.Level1)
525 {
526 GTEST_LOG_(INFO) << "CleanFileCacheTest002 Start";
527 try {
528 string uri = "uri";
529 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
530 EXPECT_CALL(*serviceProxy_, CleanFileCacheInner(_)).WillOnce(Return(E_INVAL_ARG));
531 auto res = CloudSyncManagerImpl::GetInstance().CleanFileCache(uri);
532 EXPECT_EQ(res, E_INVAL_ARG);
533 } catch (...) {
534 EXPECT_TRUE(false);
535 GTEST_LOG_(INFO) << "CleanFileCacheTest002 FAILED";
536 }
537 GTEST_LOG_(INFO) << "CleanFileCacheTest002 End";
538 }
539
540 /*
541 * @tc.name: CleanFileCacheTest003
542 * @tc.desc: Verify the CleanFileCache function.
543 * @tc.type: FUNC
544 * @tc.require: ICK6VD
545 */
546 HWTEST_F(CloudSyncManagerImplTest, CleanFileCacheTest003, TestSize.Level1)
547 {
548 GTEST_LOG_(INFO) << "CleanFileCacheTest003 Start";
549 try {
550 string uri = "uri";
551 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
552 auto res = CloudSyncManagerImpl::GetInstance().CleanFileCache(uri);
553 EXPECT_EQ(res, E_SA_LOAD_FAILED);
554 } catch (...) {
555 EXPECT_TRUE(false);
556 GTEST_LOG_(INFO) << "CleanFileCacheTest003 FAILED";
557 }
558 GTEST_LOG_(INFO) << "CleanFileCacheTest003 End";
559 }
560
561 HWTEST_F(CloudSyncManagerImplTest, BatchCleanFileTest1, TestSize.Level1)
562 {
563 GTEST_LOG_(INFO) << "BatchCleanFileTest1 Start";
564 try {
565 CleanFileInfo cleanFileInfo;
566 std::vector<CleanFileInfo> fileInfo;
567 fileInfo.emplace_back(cleanFileInfo);
568 std::vector<std::string> failCloudId;
569 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
570 EXPECT_CALL(*serviceProxy_, BatchCleanFile(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
571 auto res = CloudSyncManagerImpl::GetInstance().BatchCleanFile(fileInfo, failCloudId);
572 EXPECT_EQ(res, E_PERMISSION_DENIED);
573 } catch (...) {
574 EXPECT_TRUE(false);
575 GTEST_LOG_(INFO) << "BatchCleanFileTest1 FAILED";
576 }
577 GTEST_LOG_(INFO) << "BatchCleanFileTest1 End";
578 }
579
580 HWTEST_F(CloudSyncManagerImplTest, ResetCursorTest, TestSize.Level1)
581 {
582 string bundleName = "com.ohos.photos";
583 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
584 EXPECT_CALL(*serviceProxy_, ResetCursor(_)).WillOnce(Return(E_PERMISSION_DENIED));
585 int res = CloudSyncManagerImpl::GetInstance().ResetCursor(bundleName);
586 EXPECT_EQ(res, E_PERMISSION_DENIED);
587 }
588
589 HWTEST_F(CloudSyncManagerImplTest, DownloadThumbTest, TestSize.Level1)
590 {
591 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
592 EXPECT_CALL(*serviceProxy_, DownloadThumb()).WillOnce(Return(E_PERMISSION_DENIED));
593 int32_t res = CloudSyncManagerImpl::GetInstance().DownloadThumb();
594 EXPECT_EQ(res, E_PERMISSION_DENIED);
595 }
596
597 /*
598 * @tc.name: BatchDentryFileInsertTest
599 * @tc.desc: Verify the BatchDentryFileInsert function.
600 * @tc.type: FUNC
601 * @tc.require: I6H5MH
602 */
603 HWTEST_F(CloudSyncManagerImplTest, BatchDentryFileInsertTest002, TestSize.Level1)
604 {
605 GTEST_LOG_(INFO) << "BatchDentryFileInsertTest002 Start";
606 try {
607 std::vector<DentryFileInfo> fileInfo(MAX_DENTRY_FILE_SIZE - 1);
608 std::vector<std::string> failCloudId;
609 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
610 EXPECT_CALL(*serviceProxy_, BatchDentryFileInsert(_, _)).WillOnce(Return(E_PERMISSION_DENIED));
611 int32_t result = CloudSyncManagerImpl::GetInstance().BatchDentryFileInsert(fileInfo, failCloudId);
612
613 EXPECT_EQ(result, E_PERMISSION_DENIED);
614 } catch (...) {
615 EXPECT_TRUE(false);
616 GTEST_LOG_(INFO) << " BatchDentryFileInsertTest002 FAILED";
617 }
618 GTEST_LOG_(INFO) << "BatchDentryFileInsertTest002 End";
619 }
620
621 /**
622 * @tc.name: StopFileCache
623 * @tc.desc: Verify the StopFileCache function.
624 * @tc.type: FUNC
625 * @tc.require: I6H5MH
626 **/
627 HWTEST_F(CloudSyncManagerImplTest, StopFileCacheTest1, TestSize.Level1)
628 {
629 GTEST_LOG_(INFO) << "StopFileCacheTest1 Start";
630 try {
631 int64_t downloadId = 1;
632 bool needClean = true;
633 int32_t timeout = 10;
634
635 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
636 EXPECT_CALL(*serviceProxy_, StopFileCache(_, _, _)).WillOnce(Return(E_PERMISSION_DENIED));
637 int32_t result = CloudSyncManagerImpl::GetInstance().StopFileCache(downloadId, needClean, timeout);
638
639 EXPECT_EQ(result, E_PERMISSION_DENIED);
640 } catch (...) {
641 EXPECT_TRUE(false);
642 GTEST_LOG_(INFO) << " StopFileCacheTest1 FAILED";
643 }
644 GTEST_LOG_(INFO) << "StopFileCacheTest1 End";
645 }
646
647 /**
648 * @tc.name: RegisterCallbackTest001
649 * @tc.desc: Verify the RegisterCallback function.
650 * @tc.type: FUNC
651 * @tc.require: I6H5MH
652 */
653 HWTEST_F(CloudSyncManagerImplTest, RegisterCallbackTest001, TestSize.Level1)
654 {
655 GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
656 try {
657 auto callback = nullptr;
658 int32_t res = CloudSyncManagerImpl::GetInstance().RegisterCallback(callback);
659 EXPECT_EQ(res, E_INVAL_ARG);
660 } catch (...) {
661 EXPECT_TRUE(false);
662 GTEST_LOG_(INFO) << "RegisterCallbackTest FAILED";
663 }
664 GTEST_LOG_(INFO) << "RegisterCallbackTest End";
665 }
666
667 /*
668 * @tc.name: NotifyDataChangeTest
669 * @tc.desc: Verify the NotifyDataChange function.
670 * @tc.type: FUNC
671 * @tc.require: I6H5MH
672 */
673 HWTEST_F(CloudSyncManagerImplTest, NotifyDataChangeTest, TestSize.Level1)
674 {
675 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
676 try {
677 std::string accoutId = "accoutId";
678 std::string bundleName = "bundleName";
679 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
680 EXPECT_CALL(*serviceProxy_, NotifyDataChange(_, _)).WillOnce(Return(E_OK));
681 auto res = CloudSyncManagerImpl::GetInstance().NotifyDataChange(accoutId, bundleName);
682 EXPECT_EQ(res, E_OK);
683 } catch (...) {
684 EXPECT_TRUE(false);
685 GTEST_LOG_(INFO) << " NotifyDataChangeTest FAILED";
686 }
687 GTEST_LOG_(INFO) << "NotifyDataChangeTest End";
688 }
689
690 /*
691 * @tc.name: SetDeathRecipientTest
692 * @tc.desc: Verify the SetDeathRecipient function.
693 * @tc.type: FUNC
694 * @tc.require: ICEU6Z
695 */
696 HWTEST_F(CloudSyncManagerImplTest, SetDeathRecipientTest, TestSize.Level1)
697 {
698 GTEST_LOG_(INFO) << "SetDeathRecipientTest Start";
699 try {
700 CloudSyncManagerImpl::GetInstance().SetDeathRecipient(serviceProxy_->AsObject());
701 EXPECT_TRUE(true);
702 } catch (...) {
703 EXPECT_TRUE(false);
704 GTEST_LOG_(INFO) << "SetDeathRecipientTest FAILED";
705 }
706 GTEST_LOG_(INFO) << "SetDeathRecipientTest End";
707 }
708
709 HWTEST_F(CloudSyncManagerImplTest, BatchCleanFileTest2, TestSize.Level1)
710 {
711 GTEST_LOG_(INFO) << "BatchCleanFileTest2 Start";
712 try {
713 CleanFileInfo cleanFileInfo;
714 std::vector<CleanFileInfo> fileInfo;
715 for (int i = 0; i < CLEAN_FILE_MAX_SIZE + 1; i++) {
716 cleanFileInfo.cloudId = to_string(i);
717 fileInfo.emplace_back(cleanFileInfo);
718 }
719 std::vector<std::string> failCloudId;
720 auto res = CloudSyncManagerImpl::GetInstance().BatchCleanFile(fileInfo, failCloudId);
721 EXPECT_EQ(res, E_INVAL_ARG);
722 } catch (...) {
723 EXPECT_TRUE(false);
724 GTEST_LOG_(INFO) << "BatchCleanFileTest2 FAILED";
725 }
726 GTEST_LOG_(INFO) << "BatchCleanFileTest2 End";
727 }
728
729 HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest001, TestSize.Level1)
730 {
731 std::vector<std::string> uriVec;
732 int64_t downloadId = 0;
733 int32_t res = CloudSyncManagerImpl::GetInstance().StartFileCache(uriVec, downloadId);
734 EXPECT_EQ(res, E_INVAL_ARG);
735 }
736
737 HWTEST_F(CloudSyncManagerImplTest, StartFileCacheTest002, TestSize.Level1)
738 {
739 std::vector<std::string> uriVec(MAX_FILE_CACHE_NUM + 1, "uri");
740 int64_t downloadId = 0;
741 int32_t res = CloudSyncManagerImpl::GetInstance().StartFileCache(uriVec, downloadId);
742 EXPECT_EQ(res, E_EXCEED_MAX_SIZE);
743 }
744
745 HWTEST_F(CloudSyncManagerImplTest, ResetProxyCallbackTest, TestSize.Level1)
746 {
747 uint32_t retryCount = 3;
748 string bundleName = "testBundle";
749 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
750 auto res = CloudSyncManagerImpl::GetInstance().ResetProxyCallback(retryCount, bundleName);
751 EXPECT_EQ(res, false);
752 }
753
754 /*
755 * @tc.name: BatchDentryFileInsertTest
756 * @tc.desc: Verify the BatchDentryFileInsert function.
757 * @tc.type: FUNC
758 * @tc.require: I6H5MH
759 */
760 HWTEST_F(CloudSyncManagerImplTest, BatchDentryFileInsertTest001, TestSize.Level1)
761 {
762 GTEST_LOG_(INFO) << "BatchDentryFileInsertTest001 Start";
763 try {
764 std::vector<DentryFileInfo> fileInfo(MAX_DENTRY_FILE_SIZE + 1);
765 std::vector<std::string> failCloudId;
766 int32_t result = CloudSyncManagerImpl::GetInstance().BatchDentryFileInsert(fileInfo, failCloudId);
767
768 EXPECT_EQ(result, E_INVAL_ARG);
769 } catch (...) {
770 EXPECT_TRUE(false);
771 GTEST_LOG_(INFO) << " BatchDentryFileInsertTest001 FAILED";
772 }
773 GTEST_LOG_(INFO) << "BatchDentryFileInsertTest001 End";
774 }
775
776 /*
777 * @tc.name: OnAddSystemAbilityTest
778 * @tc.desc: Verify the OnAddSystemAbility function.
779 * @tc.type: FUNC
780 * @tc.require: ICEU6Z
781 */
782 HWTEST_F(CloudSyncManagerImplTest, OnAddSystemAbilityTest001, TestSize.Level1)
783 {
784 GTEST_LOG_(INFO) << "OnAddSystemAbilityTest001 Start";
785 try {
786 string bundleName = "testbundleName";
787 CloudSyncManagerImpl::SystemAbilityStatusChange statusChange(bundleName);
788 int32_t systemAbilityId = 1;
789 std::string deviceId = "testDeviceId";
790 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr))
791 .WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
792 EXPECT_NO_THROW(statusChange.OnAddSystemAbility(systemAbilityId, deviceId));
793 } catch (...) {
794 EXPECT_TRUE(false);
795 GTEST_LOG_(INFO) << " OnAddSystemAbilityTest001 FAILED";
796 }
797 GTEST_LOG_(INFO) << "OnAddSystemAbilityTest001 End";
798 }
799
800 /*
801 * @tc.name: CleanGalleryDentryFile
802 * @tc.desc: Verify the CleanGalleryDentryFile function.
803 * @tc.type: FUNC
804 * @tc.require: ICEU6Z
805 */
806 HWTEST_F(CloudSyncManagerImplTest, CleanGalleryDentryFileTest001, TestSize.Level1)
807 {
808 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest001 Start";
809 try {
810 CloudSyncManagerImpl::GetInstance().CleanGalleryDentryFile();
811
812 EXPECT_FALSE(fs::exists("/storage/media/cloud/files/Photo"));
813 EXPECT_FALSE(fs::exists("/storage/media/cloud/files/.thumbs/Photo"));
814 } catch (...) {
815 EXPECT_TRUE(false);
816 GTEST_LOG_(INFO) << " CleanGalleryDentryFileTest001 FAILED";
817 }
818 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest001 End";
819 }
820
821 /*
822 * @tc.name: CleanGalleryDentryFile
823 * @tc.desc: Verify the CleanGalleryDentryFile function.
824 * @tc.type: FUNC
825 * @tc.require: I6H5MH
826 */
827 HWTEST_F(CloudSyncManagerImplTest, CleanGalleryDentryFileTest002, TestSize.Level1)
828 {
829 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest002 Start";
830 try {
831 fs::remove_all("/storage/media/cloud/files/Photo");
832 fs::remove_all("/storage/media/cloud/files/.thumbs/Photo");
833
834 CloudSyncManagerImpl::GetInstance().CleanGalleryDentryFile();
835
836 EXPECT_FALSE(fs::exists("/storage/media/cloud/files/Photo"));
837 EXPECT_FALSE(fs::exists("/storage/media/cloud/files/.thumbs/Photo"));
838 } catch (...) {
839 EXPECT_TRUE(false);
840 GTEST_LOG_(INFO) << " CleanGalleryDentryFileTest002 FAILED";
841 }
842 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest002 End";
843 }
844
845 /*
846 * @tc.name: CleanGalleryDentryFile
847 * @tc.desc: Verify the CleanGalleryDentryFile function.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(CloudSyncManagerImplTest, CleanGalleryDentryFileTest003, TestSize.Level1)
851 {
852 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest003 Start";
853 try {
854 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
855 fs::create_directories("/storage/media/cloud/files/Photo/1");
856 std::ofstream("/storage/media/cloud/files/Photo/1/666666.jpg");
857 std::string testDir = "/storage/cloud/files/Photo/1/666666.jpg";
858 CloudSyncManagerImpl::GetInstance().CleanGalleryDentryFile(testDir);
859 bool isExists = fs::exists("/storage/media/cloud/files/Photo/1/666666.jpg");
860 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
861 EXPECT_FALSE(isExists);
862 } catch (...) {
863 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
864 EXPECT_TRUE(false);
865 GTEST_LOG_(INFO) << " CleanGalleryDentryFileTest003 FAILED";
866 }
867 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest003 End";
868 }
869
870 /*
871 * @tc.name: CleanGalleryDentryFile
872 * @tc.desc: Verify the CleanGalleryDentryFile function.
873 * @tc.type: FUNC
874 */
875 HWTEST_F(CloudSyncManagerImplTest, CleanGalleryDentryFileTest004, TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest004 Start";
878 try {
879 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
880 fs::create_directories("/storage/media/cloud/files/Photo/1");
881 std::ofstream("/storage/media/cloud/files/Photo/1/666666.jpg");
882 std::string testDir = "/storage/666666.jpg";
883 CloudSyncManagerImpl::GetInstance().CleanGalleryDentryFile(testDir);
884 bool isExists = fs::exists("/storage/media/cloud/files/Photo/1/666666.jpg");
885 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
886 EXPECT_TRUE(isExists);
887 } catch (...) {
888 system("rm -rf /storage/media/cloud/files/Photo/1/666666.jpg");
889 EXPECT_TRUE(false);
890 GTEST_LOG_(INFO) << " CleanGalleryDentryFileTest004 FAILED";
891 }
892 GTEST_LOG_(INFO) << "CleanGalleryDentryFileTest004 End";
893 }
894
895 /*
896 * @tc.name: SubscribeListener
897 * @tc.desc: Verify the SubscribeListener function.
898 * @tc.type: FUNC
899 * @tc.require: I6H5MH
900 */
901 HWTEST_F(CloudSyncManagerImplTest, SubscribeListenerTest1, TestSize.Level1)
902 {
903 GTEST_LOG_(INFO) << "SubscribeListenerTest1 Start";
904 try {
905 CloudSyncManagerImpl::GetInstance().SubscribeListener("testBundleName");
906 CloudSyncManagerImpl::GetInstance().listener_ = nullptr;
907 EXPECT_EQ(CloudSyncManagerImpl::GetInstance().listener_, nullptr);
908 } catch (...) {
909 EXPECT_TRUE(false);
910 GTEST_LOG_(INFO) << " SubscribeListenerTest1 FAILED";
911 }
912 GTEST_LOG_(INFO) << "SubscribeListenerTest1 End";
913 }
914
915 /*
916 * @tc.name: StartDowngradeTest001
917 * @tc.desc: Verify the StartDowngrade function.
918 * @tc.type: FUNC
919 * @tc.require: I6H5MH
920 */
921 HWTEST_F(CloudSyncManagerImplTest, StartDowngradeTest001, TestSize.Level1)
922 {
923 GTEST_LOG_(INFO) << "StartDowngradeTest001 Start";
924 try {
925 std::string bundleName = "com.ohos.aaa";
926 shared_ptr<DowngradeDlCallback> downloadCallback = make_shared<DowngradeDlCallbackDerived>();
927 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
928 EXPECT_CALL(*serviceProxy_, StartDowngrade(_, _)).WillOnce(Return(E_OK));
929 auto res = CloudSyncManagerImpl::GetInstance().StartDowngrade(bundleName, downloadCallback);
930 EXPECT_EQ(res, E_OK);
931 } catch (...) {
932 EXPECT_TRUE(false);
933 GTEST_LOG_(INFO) << " StartDowngradeTest001 FAILED";
934 }
935 GTEST_LOG_(INFO) << "StartDowngradeTest001 End";
936 }
937
938 /*
939 * @tc.name: StartDowngradeTest002
940 * @tc.desc: Verify the StartDowngrade function.
941 * @tc.type: FUNC
942 * @tc.require: I6H5MH
943 */
944 HWTEST_F(CloudSyncManagerImplTest, StartDowngradeTest002, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "StartDowngradeTest002 Start";
947 try {
948 std::string bundleName = "";
949 shared_ptr<DowngradeDlCallback> downloadCallback = make_shared<DowngradeDlCallbackDerived>();
950 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
951 auto res = CloudSyncManagerImpl::GetInstance().StartDowngrade(bundleName, downloadCallback);
952 EXPECT_EQ(res, E_INVAL_ARG);
953 } catch (...) {
954 EXPECT_TRUE(false);
955 GTEST_LOG_(INFO) << " StartDowngradeTest002 FAILED";
956 }
957 GTEST_LOG_(INFO) << "StartDowngradeTest002 End";
958 }
959
960 /*
961 * @tc.name: StartDowngradeTest003
962 * @tc.desc: Verify the StartDowngrade function.
963 * @tc.type: FUNC
964 * @tc.require: I6H5MH
965 */
966 HWTEST_F(CloudSyncManagerImplTest, StartDowngradeTest003, TestSize.Level1)
967 {
968 GTEST_LOG_(INFO) << "StartDowngradeTest003 Start";
969 try {
970 std::string bundleName = "com.ohos.aaa";
971 shared_ptr<DowngradeDlCallback> downloadCallback = make_shared<DowngradeDlCallbackDerived>();
972 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
973 auto res = CloudSyncManagerImpl::GetInstance().StartDowngrade(bundleName, downloadCallback);
974 EXPECT_EQ(res, E_SA_LOAD_FAILED);
975 } catch (...) {
976 EXPECT_TRUE(false);
977 GTEST_LOG_(INFO) << " StartDowngradeTest003 FAILED";
978 }
979 GTEST_LOG_(INFO) << "StartDowngradeTest003 End";
980 }
981
982 /*
983 * @tc.name: StartDowngradeTest004
984 * @tc.desc: Verify the StartDowngrade function.
985 * @tc.type: FUNC
986 * @tc.require: I6H5MH
987 */
988 HWTEST_F(CloudSyncManagerImplTest, StartDowngradeTest004, TestSize.Level1)
989 {
990 GTEST_LOG_(INFO) << "StartDowngradeTest004 Start";
991 try {
992 std::string bundleName = "com.ohos.aaa";
993 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
994 auto res = CloudSyncManagerImpl::GetInstance().StartDowngrade(bundleName, nullptr);
995 EXPECT_EQ(res, E_INVAL_ARG);
996 } catch (...) {
997 EXPECT_TRUE(false);
998 GTEST_LOG_(INFO) << " StartDowngradeTest004 FAILED";
999 }
1000 GTEST_LOG_(INFO) << "StartDowngradeTest004 End";
1001 }
1002
1003 /*
1004 * @tc.name: StopDowngradeTest001
1005 * @tc.desc: Verify the StopDowngrade function.
1006 * @tc.type: FUNC
1007 * @tc.require: I6H5MH
1008 */
1009 HWTEST_F(CloudSyncManagerImplTest, StopDowngradeTest001, TestSize.Level1)
1010 {
1011 GTEST_LOG_(INFO) << "StopDowngradeTest001 Start";
1012 try {
1013 std::string bundleName = "com.ohos.aaa";
1014 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1015 EXPECT_CALL(*serviceProxy_, StopDowngrade(_)).WillOnce(Return(E_OK));
1016 auto res = CloudSyncManagerImpl::GetInstance().StopDowngrade(bundleName);
1017 EXPECT_EQ(res, E_OK);
1018 } catch (...) {
1019 EXPECT_TRUE(false);
1020 GTEST_LOG_(INFO) << " StopDowngradeTest001 FAILED";
1021 }
1022 GTEST_LOG_(INFO) << "StopDowngradeTest001 End";
1023 }
1024
1025 /*
1026 * @tc.name: StopDowngradeTest002
1027 * @tc.desc: Verify the StopDowngrade function.
1028 * @tc.type: FUNC
1029 * @tc.require: I6H5MH
1030 */
1031 HWTEST_F(CloudSyncManagerImplTest, StopDowngradeTest002, TestSize.Level1)
1032 {
1033 GTEST_LOG_(INFO) << "StopDowngradeTest002 Start";
1034 try {
1035 std::string bundleName = "";
1036 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1037 auto res = CloudSyncManagerImpl::GetInstance().StopDowngrade(bundleName);
1038 EXPECT_EQ(res, E_INVAL_ARG);
1039 } catch (...) {
1040 EXPECT_TRUE(false);
1041 GTEST_LOG_(INFO) << " StopDowngradeTest002 FAILED";
1042 }
1043 GTEST_LOG_(INFO) << "StopDowngradeTest002 End";
1044 }
1045
1046 /*
1047 * @tc.name: StopDowngradeTest003
1048 * @tc.desc: Verify the StopDowngrade function.
1049 * @tc.type: FUNC
1050 * @tc.require: I6H5MH
1051 */
1052 HWTEST_F(CloudSyncManagerImplTest, StopDowngradeTest003, TestSize.Level1)
1053 {
1054 GTEST_LOG_(INFO) << "StopDowngradeTest003 Start";
1055 try {
1056 std::string bundleName = "";
1057 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1058 auto res = CloudSyncManagerImpl::GetInstance().StopDowngrade(bundleName);
1059 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1060 } catch (...) {
1061 EXPECT_TRUE(false);
1062 GTEST_LOG_(INFO) << " StopDowngradeTest003 FAILED";
1063 }
1064 GTEST_LOG_(INFO) << "StopDowngradeTest003 End";
1065 }
1066
1067 /*
1068 * @tc.name: GetCloudFileInfoTest001
1069 * @tc.desc: Verify the GetCloudFileInfo function.
1070 * @tc.type: FUNC
1071 * @tc.require: I6H5MH
1072 */
1073 HWTEST_F(CloudSyncManagerImplTest, GetCloudFileInfoTest001, TestSize.Level1)
1074 {
1075 GTEST_LOG_(INFO) << "GetCloudFileInfoTest001 Start";
1076 try {
1077 std::string bundleName = "com.ohos.aaa";
1078 CloudFileInfo cloudFileInfo;
1079 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1080 EXPECT_CALL(*serviceProxy_, GetCloudFileInfo(_, _)).WillOnce(Return(E_OK));
1081 auto res = CloudSyncManagerImpl::GetInstance().GetCloudFileInfo(bundleName, cloudFileInfo);
1082 EXPECT_EQ(res, E_OK);
1083 } catch (...) {
1084 EXPECT_TRUE(false);
1085 GTEST_LOG_(INFO) << " GetCloudFileInfoTest001 FAILED";
1086 }
1087 GTEST_LOG_(INFO) << "GetCloudFileInfoTest001 End";
1088 }
1089
1090 /*
1091 * @tc.name: GetCloudFileInfoTest002
1092 * @tc.desc: Verify the StopDowngrade function.
1093 * @tc.type: FUNC
1094 * @tc.require: I6H5MH
1095 */
1096 HWTEST_F(CloudSyncManagerImplTest, GetCloudFileInfoTest002, TestSize.Level1)
1097 {
1098 GTEST_LOG_(INFO) << "GetCloudFileInfoTest002 Start";
1099 try {
1100 std::string bundleName = "";
1101 CloudFileInfo cloudFileInfo;
1102 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1103 auto res = CloudSyncManagerImpl::GetInstance().GetCloudFileInfo(bundleName, cloudFileInfo);
1104 EXPECT_EQ(res, E_INVAL_ARG);
1105 } catch (...) {
1106 EXPECT_TRUE(false);
1107 GTEST_LOG_(INFO) << " GetCloudFileInfoTest002 FAILED";
1108 }
1109 GTEST_LOG_(INFO) << "GetCloudFileInfoTest002 End";
1110 }
1111
1112 /*
1113 * @tc.name: GetCloudFileInfoTest003
1114 * @tc.desc: Verify the StopDowngrade function.
1115 * @tc.type: FUNC
1116 * @tc.require: I6H5MH
1117 */
1118 HWTEST_F(CloudSyncManagerImplTest, GetCloudFileInfoTest003, TestSize.Level1)
1119 {
1120 GTEST_LOG_(INFO) << "GetCloudFileInfoTest003 Start";
1121 try {
1122 std::string bundleName = "com.ohos.aaa";
1123 CloudFileInfo cloudFileInfo;
1124 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1125 auto res = CloudSyncManagerImpl::GetInstance().GetCloudFileInfo(bundleName, cloudFileInfo);
1126 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1127 } catch (...) {
1128 EXPECT_TRUE(false);
1129 GTEST_LOG_(INFO) << " GetCloudFileInfoTest003 FAILED";
1130 }
1131 GTEST_LOG_(INFO) << "GetCloudFileInfoTest003 End";
1132 }
1133
1134 /*
1135 * @tc.name: GetHistoryVersionList
1136 * @tc.desc: Verify the GetHistoryVersionList function, proxy is null.
1137 * @tc.type: FUNC
1138 * @tc.require: ICGORT
1139 */
1140 HWTEST_F(CloudSyncManagerImplTest, GetHistoryVersionListTest001, TestSize.Level1)
1141 {
1142 GTEST_LOG_(INFO) << "GetHistoryVersionListTest001 Start";
1143 try {
1144 string uri = "";
1145 int32_t numLimit = 0;
1146 vector<CloudSync::HistoryVersion> historyVersionList;
1147 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1148 auto res = CloudSyncManagerImpl::GetInstance().GetHistoryVersionList(uri, numLimit, historyVersionList);
1149 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1150
1151 uri = "";
1152 numLimit = 1;
1153 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1154 res = CloudSyncManagerImpl::GetInstance().GetHistoryVersionList(uri, numLimit, historyVersionList);
1155 EXPECT_EQ(res, E_ILLEGAL_URI);
1156 } catch (...) {
1157 EXPECT_TRUE(false);
1158 GTEST_LOG_(INFO) << " GetHistoryVersionListTest001 FAILED";
1159 }
1160 GTEST_LOG_(INFO) << "GetHistoryVersionListTest001 End";
1161 }
1162
1163 /*
1164 * @tc.name: GetHistoryVersionList
1165 * @tc.desc: Verify the GetHistoryVersionList function, uri empty or limit below zero.
1166 * @tc.type: FUNC
1167 * @tc.require: ICGORT
1168 */
1169 HWTEST_F(CloudSyncManagerImplTest, GetHistoryVersionListTest002, TestSize.Level1)
1170 {
1171 GTEST_LOG_(INFO) << "GetHistoryVersionListTest002 Start";
1172 try {
1173 string uri = "path/file/1.txt";
1174 int32_t numLimit = 0;
1175 vector<CloudSync::HistoryVersion> historyVersionList;
1176 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1177 auto res = CloudSyncManagerImpl::GetInstance().GetHistoryVersionList(uri, numLimit, historyVersionList);
1178 EXPECT_EQ(res, E_INVAL_ARG);
1179
1180 uri = "";
1181 numLimit = 0;
1182 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1183 res = CloudSyncManagerImpl::GetInstance().GetHistoryVersionList(uri, numLimit, historyVersionList);
1184 EXPECT_EQ(res, E_ILLEGAL_URI);
1185
1186 uri = "path/file/1.txt";
1187 numLimit = 1;
1188 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1189 EXPECT_CALL(*serviceProxy_, GetHistoryVersionList(_, _, _)).WillOnce(Return(E_OK));
1190 res = CloudSyncManagerImpl::GetInstance().GetHistoryVersionList(uri, numLimit, historyVersionList);
1191 EXPECT_EQ(res, E_OK);
1192 } catch (...) {
1193 EXPECT_TRUE(false);
1194 GTEST_LOG_(INFO) << " GetHistoryVersionListTest002 FAILED";
1195 }
1196 GTEST_LOG_(INFO) << "GetHistoryVersionListTest002 End";
1197 }
1198
1199 /*
1200 * @tc.name: DownloadHistoryVersion
1201 * @tc.desc: Verify the DownloadHistoryVersion function, proxy is null.
1202 * @tc.type: FUNC
1203 * @tc.require: ICGORT
1204 */
1205 HWTEST_F(CloudSyncManagerImplTest, DownloadHistoryVersionTest001, TestSize.Level1)
1206 {
1207 GTEST_LOG_(INFO) << "DownloadHistoryVersionTest001 Start";
1208 try {
1209 string uri = "";
1210 int64_t downloadId = 0;
1211 uint64_t versionId = 0;
1212 shared_ptr<CloudDownloadCallback> callback = nullptr;
1213 string versionUri;
1214 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1215 auto res = CloudSyncManagerImpl::GetInstance()
1216 .DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1217 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1218
1219 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1220 res = CloudSyncManagerImpl::GetInstance()
1221 .DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1222 EXPECT_EQ(res, E_ILLEGAL_URI);
1223
1224 uri = "path/file/1.txt";
1225 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1226 res = CloudSyncManagerImpl::GetInstance()
1227 .DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1228 EXPECT_EQ(res, E_INVAL_ARG);
1229 } catch (...) {
1230 EXPECT_TRUE(false);
1231 GTEST_LOG_(INFO) << " DownloadHistoryVersionTest001 FAILED";
1232 }
1233 GTEST_LOG_(INFO) << "DownloadHistoryVersionTest001 End";
1234 }
1235
1236 /*
1237 * @tc.name: DownloadHistoryVersion
1238 * @tc.desc: Verify the DownloadHistoryVersion function, uri or callback empty.
1239 * @tc.type: FUNC
1240 * @tc.require: ICGORT
1241 */
1242 HWTEST_F(CloudSyncManagerImplTest, DownloadHistoryVersionTest002, TestSize.Level1)
1243 {
1244 GTEST_LOG_(INFO) << "DownloadHistoryVersionTest002 Start";
1245 try {
1246 string uri = "";
1247 int64_t downloadId = 0;
1248 uint64_t versionId = 0;
1249 shared_ptr<CloudDownloadCallback> callback = make_shared<CloudDownloadCallbackDerived>();
1250 string versionUri;
1251 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1252 auto res = CloudSyncManagerImpl::GetInstance()
1253 .DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1254 EXPECT_EQ(res, E_ILLEGAL_URI);
1255
1256 uri = "path/file/1.txt";
1257 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1258 EXPECT_CALL(*serviceProxy_, DownloadHistoryVersion(_, _, _, _, _)).WillOnce(Return(E_OK));
1259 res = CloudSyncManagerImpl::GetInstance()
1260 .DownloadHistoryVersion(uri, downloadId, versionId, callback, versionUri);
1261 EXPECT_EQ(res, E_OK);
1262 } catch (...) {
1263 EXPECT_TRUE(false);
1264 GTEST_LOG_(INFO) << " DownloadHistoryVersionTest002 FAILED";
1265 }
1266 GTEST_LOG_(INFO) << "DownloadHistoryVersionTest002 End";
1267 }
1268
1269 /*
1270 * @tc.name: ReplaceFileWithHistoryVersion
1271 * @tc.desc: Verify the ReplaceFileWithHistoryVersion function, proxy is null.
1272 * @tc.type: FUNC
1273 * @tc.require: ICGORT
1274 */
1275 HWTEST_F(CloudSyncManagerImplTest, ReplaceFileWithHistoryVersionTest001, TestSize.Level1)
1276 {
1277 GTEST_LOG_(INFO) << "ReplaceFileWithHistoryVersionTest001 Start";
1278 try {
1279 string oriUri = "";
1280 string uri = "";
1281 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1282 auto res = CloudSyncManagerImpl::GetInstance().ReplaceFileWithHistoryVersion(oriUri, uri);
1283 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1284
1285 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1286 res = CloudSyncManagerImpl::GetInstance().ReplaceFileWithHistoryVersion(oriUri, uri);
1287 EXPECT_EQ(res, E_ILLEGAL_URI);
1288
1289 oriUri = "path/file/1.txt";
1290 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1291 res = CloudSyncManagerImpl::GetInstance().ReplaceFileWithHistoryVersion(oriUri, uri);
1292 EXPECT_EQ(res, E_ILLEGAL_URI);
1293
1294 oriUri = "";
1295 uri = "path/file/1.txt";
1296 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1297 res = CloudSyncManagerImpl::GetInstance().ReplaceFileWithHistoryVersion(oriUri, uri);
1298 EXPECT_EQ(res, E_ILLEGAL_URI);
1299
1300 oriUri = "path/file/1.txt";
1301 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1302 EXPECT_CALL(*serviceProxy_, ReplaceFileWithHistoryVersion(_, _)).WillOnce(Return(E_OK));
1303 res = CloudSyncManagerImpl::GetInstance().ReplaceFileWithHistoryVersion(oriUri, uri);
1304 EXPECT_EQ(res, E_OK);
1305 } catch (...) {
1306 EXPECT_TRUE(false);
1307 GTEST_LOG_(INFO) << " ReplaceFileWithHistoryVersionTest001 FAILED";
1308 }
1309 GTEST_LOG_(INFO) << "ReplaceFileWithHistoryVersionTest001 End";
1310 }
1311
1312 /*
1313 * @tc.name: IsFileConflict
1314 * @tc.desc: Verify the IsFileConflict function, proxy is null.
1315 * @tc.type: FUNC
1316 * @tc.require: ICGORT
1317 */
1318 HWTEST_F(CloudSyncManagerImplTest, IsFileConflictTest001, TestSize.Level1)
1319 {
1320 GTEST_LOG_(INFO) << "IsFileConflictTest001 Start";
1321 try {
1322 string uri = "";
1323 bool isConflict;
1324 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1325 auto res = CloudSyncManagerImpl::GetInstance().IsFileConflict(uri, isConflict);
1326 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1327
1328 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1329 res = CloudSyncManagerImpl::GetInstance().IsFileConflict(uri, isConflict);
1330 EXPECT_EQ(res, E_ILLEGAL_URI);
1331
1332 uri = "path/file/1.txt";
1333 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1334 EXPECT_CALL(*serviceProxy_, IsFileConflict(_, _)).WillOnce(Return(E_OK));
1335 res = CloudSyncManagerImpl::GetInstance().IsFileConflict(uri, isConflict);
1336 EXPECT_EQ(res, E_OK);
1337 } catch (...) {
1338 EXPECT_TRUE(false);
1339 GTEST_LOG_(INFO) << " IsFileConflictTest001 FAILED";
1340 }
1341 GTEST_LOG_(INFO) << "IsFileConflictTest001 End";
1342 }
1343
1344 /*
1345 * @tc.name: ClearFileConflict
1346 * @tc.desc: Verify the ClearFileConflict function, proxy is null.
1347 * @tc.type: FUNC
1348 * @tc.require: ICGORT
1349 */
1350 HWTEST_F(CloudSyncManagerImplTest, ClearFileConflictTest001, TestSize.Level1)
1351 {
1352 GTEST_LOG_(INFO) << "ClearFileConflictTest001 Start";
1353 try {
1354 string uri = "";
1355 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
1356 auto res = CloudSyncManagerImpl::GetInstance().ClearFileConflict(uri);
1357 EXPECT_EQ(res, E_SA_LOAD_FAILED);
1358
1359 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1360 res = CloudSyncManagerImpl::GetInstance().ClearFileConflict(uri);
1361 EXPECT_EQ(res, E_ILLEGAL_URI);
1362
1363 uri = "path/file/1.txt";
1364 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(serviceProxy_));
1365 EXPECT_CALL(*serviceProxy_, ClearFileConflict(_)).WillOnce(Return(E_OK));
1366 res = CloudSyncManagerImpl::GetInstance().ClearFileConflict(uri);
1367 EXPECT_EQ(res, E_OK);
1368 } catch (...) {
1369 EXPECT_TRUE(false);
1370 GTEST_LOG_(INFO) << " ClearFileConflictTest001 FAILED";
1371 }
1372 GTEST_LOG_(INFO) << "ClearFileConflictTest001 End";
1373 }
1374 } // namespace FileManagement::CloudSync
1375 } // namespace OHOS