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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "cloud_file_sync_service_interface_code.h"
20 #include "cloud_sync_service_stub.h"
21 #include "dfsu_access_token_helper_mock.h"
22 #include "i_cloud_sync_service.h"
23 #include "service_callback_mock.h"
24 
25 namespace OHOS {
26 namespace FileManagement::CloudSync {
27 namespace Test {
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace std;
31 
32 class MockService final : public CloudSyncServiceStub {
33 public:
34     MOCK_METHOD2(RegisterCallbackInner,
35                  int32_t(const sptr<IRemoteObject> &remoteObject, const std::string &bundleName));
36     MOCK_METHOD1(UnRegisterCallbackInner, int32_t(const std::string &bundleName));
37     MOCK_METHOD2(StartSyncInner, int32_t(bool forceFlag, const std::string &bundleName));
38     MOCK_METHOD2(TriggerSyncInner, int32_t(const std::string &bundleName, const int32_t &userId));
39     MOCK_METHOD2(StopSyncInner, int32_t(const std::string &bundleName, bool forceFlag));
40     MOCK_METHOD1(ResetCursor, int32_t(const std::string &bundleName));
41     MOCK_METHOD3(ChangeAppSwitch, int32_t(const std::string &accoutId, const std::string &bundleName, bool status));
42     MOCK_METHOD2(Clean, int32_t(const std::string &accountId, const CleanOptions &cleanOptions));
43     MOCK_METHOD2(NotifyDataChange, int32_t(const std::string &accoutId, const std::string &bundleName));
44     MOCK_METHOD3(NotifyEventChange, int32_t(int32_t userId, const std::string &eventId, const std::string &extraData));
45     MOCK_METHOD2(EnableCloud, int32_t(const std::string &accoutId, const SwitchDataObj &switchData));
46     MOCK_METHOD1(DisableCloud, int32_t(const std::string &accoutId));
47     MOCK_METHOD1(StartDownloadFile, int32_t(const std::string &path));
48     MOCK_METHOD5(StartFileCache, int32_t(const std::vector<std::string> &pathVec, int64_t &downloadId,
49                                          std::bitset<FIELD_KEY_MAX_SIZE> fieldkey,
50                                          bool isCallbackValid,
51                                          const sptr<IRemoteObject> &downloadCallback));
52     MOCK_METHOD2(StopDownloadFile, int32_t(const std::string &path, bool needClean));
53     MOCK_METHOD2(StopFileCache, int32_t(const int64_t &downloadId, bool needClean));
54     MOCK_METHOD1(RegisterDownloadFileCallback, int32_t(const sptr<IRemoteObject> &downloadCallback));
55     MOCK_METHOD0(UnregisterDownloadFileCallback, int32_t());
56     MOCK_METHOD3(UploadAsset, int32_t(const int32_t userId, const std::string &request, std::string &result));
57     MOCK_METHOD3(DownloadFile,
58                  int32_t(const int32_t userId, const std::string &bundleName, AssetInfoObj &assetInfoObj));
59     MOCK_METHOD4(DownloadFiles,
60                  int32_t(const int32_t userId,
61                          const std::string &bundleName,
62                          const std::vector<AssetInfoObj> &assetInfoObj,
63                          std::vector<bool> &assetResultMap));
64     MOCK_METHOD5(DownloadAsset,
65                  int32_t(const uint64_t taskId,
66                          const int32_t userId,
67                          const std::string &bundleName,
68                          const std::string &networkId,
69                          AssetInfoObj &assetInfoObj));
70     MOCK_METHOD1(RegisterDownloadAssetCallback, int32_t(const sptr<IRemoteObject> &remoteObject));
71     MOCK_METHOD2(DeleteAsset, int32_t(const int32_t userId, const std::string &uri));
72     MOCK_METHOD2(GetSyncTimeInner, int32_t(int64_t &syncTime, const std::string &bundleName));
73     MOCK_METHOD1(CleanCacheInner, int32_t(const std::string &uri));
74 };
75 
76 class CloudSyncServiceStubTest : public testing::Test {
77 public:
78     static void SetUpTestCase(void);
79     static void TearDownTestCase(void);
80     void SetUp();
81     void TearDown();
82     static inline shared_ptr<DfsuAccessTokenMock> dfsuAccessToken_ = nullptr;
83 };
84 
SetUpTestCase(void)85 void CloudSyncServiceStubTest::SetUpTestCase(void)
86 {
87     dfsuAccessToken_ = make_shared<DfsuAccessTokenMock>();
88     DfsuAccessTokenMock::dfsuAccessToken = dfsuAccessToken_;
89     std::cout << "SetUpTestCase" << std::endl;
90 }
91 
TearDownTestCase(void)92 void CloudSyncServiceStubTest::TearDownTestCase(void)
93 {
94     DfsuAccessTokenMock::dfsuAccessToken = nullptr;
95     dfsuAccessToken_ = nullptr;
96     std::cout << "TearDownTestCase" << std::endl;
97 }
98 
SetUp(void)99 void CloudSyncServiceStubTest::SetUp(void)
100 {
101     std::cout << "SetUp" << std::endl;
102 }
103 
TearDown(void)104 void CloudSyncServiceStubTest::TearDown(void)
105 {
106     std::cout << "TearDown" << std::endl;
107 }
108 
109 /**
110  * @tc.name: HandleUnRegisterCallbackInnerTest
111  * @tc.desc: Verify the HandleUnRegisterCallbackInner function.
112  * @tc.type: FUNC
113  * @tc.require: I6H5MH
114  */
115 HWTEST_F(CloudSyncServiceStubTest, HandleUnRegisterCallbackInnerTest, TestSize.Level1)
116 {
117     GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner Start";
118     try {
119         string bundleName = "";
120         MockService service;
121         EXPECT_CALL(service, UnRegisterCallbackInner(bundleName)).WillOnce(Return(E_OK));
122         MessageParcel data;
123         MessageParcel reply;
124         MessageOption option;
125         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
126         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
127         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
128 
129         sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
130         EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
131 
132         EXPECT_TRUE(data.WriteString(bundleName));
133 
134         EXPECT_EQ(E_OK, service.OnRemoteRequest(
135                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK),
136                             data, reply, option));
137         remote = nullptr;
138     } catch (...) {
139         EXPECT_TRUE(false);
140         GTEST_LOG_(INFO) << " HandleUnRegisterCallbackInner ERROR";
141     }
142     GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner End";
143 }
144 
145 /**
146  * @tc.name: HandleRegisterCallbackInnerTest
147  * @tc.desc: Verify the HandleRegisterCallbackInner function.
148  * @tc.type: FUNC
149  * @tc.require: I6H5MH
150  */
151 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterCallbackInnerTest, TestSize.Level1)
152 {
153     GTEST_LOG_(INFO) << "HandleRegisterCallbackInner Start";
154     try {
155         string bundleName = "";
156         MockService service;
157         EXPECT_CALL(service, RegisterCallbackInner(_, bundleName)).WillOnce(Return(E_OK));
158         MessageParcel data;
159         MessageParcel reply;
160         MessageOption option;
161         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
162         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
163         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
164 
165         sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
166         EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
167 
168         EXPECT_TRUE(data.WriteString(bundleName));
169 
170         EXPECT_EQ(E_OK, service.OnRemoteRequest(
171                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK),
172                             data, reply, option));
173         remote = nullptr;
174     } catch (...) {
175         EXPECT_TRUE(false);
176         GTEST_LOG_(INFO) << " HandleRegisterCallbackInner ERROR";
177     }
178     GTEST_LOG_(INFO) << "HandleRegisterCallbackInner End";
179 }
180 
181 /**
182  * @tc.name: HandleStartSyncInnerTest
183  * @tc.desc: Verify the HandleStartSyncInner function.
184  * @tc.type: FUNC
185  * @tc.require: I6H5MH
186  */
187 HWTEST_F(CloudSyncServiceStubTest, HandleStartSyncInnerTest, TestSize.Level1)
188 {
189     GTEST_LOG_(INFO) << "HandleStartSyncInner Start";
190     try {
191         string bundleName = "";
192         MockService service;
193         EXPECT_CALL(service, StartSyncInner(_, bundleName)).WillOnce(Return(E_OK));
194         MessageParcel data;
195         MessageParcel reply;
196         MessageOption option;
197         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
198         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
199         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
200 
201         bool forceFlag = true;
202         EXPECT_TRUE(data.WriteBool(forceFlag));
203 
204         EXPECT_TRUE(data.WriteString(bundleName));
205 
206         EXPECT_EQ(E_OK, service.OnRemoteRequest(
207                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC), data,
208                             reply, option));
209     } catch (...) {
210         EXPECT_TRUE(false);
211         GTEST_LOG_(INFO) << " HandleStartSyncInner ERROR";
212     }
213     GTEST_LOG_(INFO) << "HandleStartSyncInner End";
214 }
215 
216 /**
217  * @tc.name: HandleTriggerSyncInnerTest
218  * @tc.desc: Verify the HandleStartSyncInner function.
219  * @tc.type: FUNC
220  * @tc.require: I6H5MH
221  */
222 HWTEST_F(CloudSyncServiceStubTest, HandleTriggerSyncInnerTest, TestSize.Level1)
223 {
224     GTEST_LOG_(INFO) << "HandleTriggerSyncInner Start";
225     try {
226         MockService service;
227         EXPECT_CALL(service, TriggerSyncInner(_, _)).WillOnce(Return(E_OK));
228         MessageParcel data;
229         MessageParcel reply;
230         MessageOption option;
231         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
232         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
233         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
234 
235         EXPECT_EQ(E_OK, service.OnRemoteRequest(
236                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC), data,
237                             reply, option));
238     } catch (...) {
239         EXPECT_TRUE(false);
240         GTEST_LOG_(INFO) << " HandleTriggerSyncInner ERROR";
241     }
242     GTEST_LOG_(INFO) << "HandleTriggerSyncInner End";
243 }
244 
245 /**
246  * @tc.name: HandleStopSyncInnerTest
247  * @tc.desc: Verify the HandleStopSyncInner function.
248  * @tc.type: FUNC
249  * @tc.require: I6H5MH
250  */
251 HWTEST_F(CloudSyncServiceStubTest, HandleStopSyncInnerTest, TestSize.Level1)
252 {
253     GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
254     try {
255         string bundleName = "";
256         bool forceFlag = false;
257         MockService service;
258         EXPECT_CALL(service, StopSyncInner(bundleName, forceFlag)).WillOnce(Return(E_OK));
259         MessageParcel data;
260         MessageParcel reply;
261         MessageOption option;
262         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
263         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
264         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
265 
266         EXPECT_TRUE(data.WriteString(bundleName));
267 
268         EXPECT_TRUE(data.WriteBool(forceFlag));
269 
270         EXPECT_EQ(E_OK, service.OnRemoteRequest(
271                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC), data,
272                             reply, option));
273     } catch (...) {
274         EXPECT_TRUE(false);
275         GTEST_LOG_(INFO) << " HandleStopSyncInner ERROR";
276     }
277     GTEST_LOG_(INFO) << "HandleStopSyncInner End";
278 }
279 
280 /**
281  * @tc.name: HandleChangeAppSwitchTest
282  * @tc.desc: Verify the HandleChangeAppSwitch function.
283  * @tc.type: FUNC
284  * @tc.require: I6H5MH
285  */
286 HWTEST_F(CloudSyncServiceStubTest, HandleChangeAppSwitchTest, TestSize.Level1)
287 {
288     GTEST_LOG_(INFO) << "HandleChangeAppSwitch Start";
289     try {
290         MockService service;
291         EXPECT_CALL(service, ChangeAppSwitch(_, _, _)).WillOnce(Return(E_OK));
292         MessageParcel data;
293         MessageParcel reply;
294         MessageOption option;
295         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
296         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
297         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
298 
299         EXPECT_EQ(E_OK, service.OnRemoteRequest(
300                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH),
301                             data, reply, option));
302     } catch (...) {
303         EXPECT_TRUE(false);
304         GTEST_LOG_(INFO) << " HandleChangeAppSwitch ERROR";
305     }
306     GTEST_LOG_(INFO) << "HandleChangeAppSwitch End";
307 }
308 
309 /**
310  * @tc.name: HandleCleanTest
311  * @tc.desc: Verify the HandleClean function.
312  * @tc.type: FUNC
313  * @tc.require: I6H5MH
314  */
315 HWTEST_F(CloudSyncServiceStubTest, HandleCleandTest, TestSize.Level1)
316 {
317     GTEST_LOG_(INFO) << "HandleClean Start";
318     try {
319         MockService service;
320         MessageParcel data;
321         MessageParcel reply;
322         MessageOption option;
323         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
324         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
325         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
326 
327         EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
328                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN), data,
329                             reply, option));
330     } catch (...) {
331         EXPECT_TRUE(false);
332         GTEST_LOG_(INFO) << " HandleClean ERROR";
333     }
334     GTEST_LOG_(INFO) << "HandleClean End";
335 }
336 
337 /**
338  * @tc.name: HandleNotifyDataChangeTest
339  * @tc.desc: Verify the HandleNotifyDataChange function.
340  * @tc.type: FUNC
341  * @tc.require: I6H5MH
342  */
343 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyDataChangeTest, TestSize.Level1)
344 {
345     GTEST_LOG_(INFO) << "HandleNotifyDataChange Start";
346     try {
347         MockService service;
348         EXPECT_CALL(service, NotifyDataChange(_, _)).WillOnce(Return(E_OK));
349         MessageParcel data;
350         MessageParcel reply;
351         MessageOption option;
352         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
353         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
354         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
355 
356         EXPECT_EQ(E_OK, service.OnRemoteRequest(
357                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE),
358                             data, reply, option));
359     } catch (...) {
360         EXPECT_TRUE(false);
361         GTEST_LOG_(INFO) << " HandleNotifyDataChange ERROR";
362     }
363     GTEST_LOG_(INFO) << "HandleNotifyDataChange End";
364 }
365 
366 /**
367  * @tc.name: HandleNotifyEventChangeTest
368  * @tc.desc: Verify the HandleNotifyEventChange function.
369  * @tc.type: FUNC
370  * @tc.require: I6H5MH
371  */
372 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyEventChangeTest, TestSize.Level1)
373 {
374     GTEST_LOG_(INFO) << "HandleNotifyEventChange Start";
375     try {
376         MockService service;
377         EXPECT_CALL(service, NotifyEventChange(_, _, _)).WillOnce(Return(E_OK));
378         MessageParcel data;
379         MessageParcel reply;
380         MessageOption option;
381         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
382         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
383         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
384 
385         EXPECT_EQ(E_OK, service.OnRemoteRequest(
386                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE),
387                             data, reply, option));
388     } catch (...) {
389         EXPECT_TRUE(false);
390         GTEST_LOG_(INFO) << " HandleNotifyEventChange ERROR";
391     }
392     GTEST_LOG_(INFO) << "HandleNotifyEventChange End";
393 }
394 
395 /**
396  * @tc.name: HandleDisableCloudTest
397  * @tc.desc: Verify the HandleDisableCloud function.
398  * @tc.type: FUNC
399  * @tc.require: I6H5MH
400  */
401 HWTEST_F(CloudSyncServiceStubTest, HandleDisableCloudTest, TestSize.Level1)
402 {
403     GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
404     try {
405         MockService service;
406         EXPECT_CALL(service, DisableCloud(_)).WillOnce(Return(E_OK));
407         MessageParcel data;
408         MessageParcel reply;
409         MessageOption option;
410         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
411         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
412         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
413 
414         EXPECT_EQ(E_OK, service.OnRemoteRequest(
415                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD), data,
416                             reply, option));
417     } catch (...) {
418         EXPECT_TRUE(false);
419         GTEST_LOG_(INFO) << " HandleDisableCloud ERROR";
420     }
421     GTEST_LOG_(INFO) << "HandleDisableCloud End";
422 }
423 
424 /**
425  * @tc.name: HandleEnableCloudTest
426  * @tc.desc: Verify the HandleEnableCloud function.
427  * @tc.type: FUNC
428  * @tc.require: I6H5MH
429  */
430 HWTEST_F(CloudSyncServiceStubTest, HandleEnableCloudTest, TestSize.Level1)
431 {
432     GTEST_LOG_(INFO) << "HandleEnableCloudFile Start";
433     try {
434         MockService service;
435         MessageParcel data;
436         MessageParcel reply;
437         MessageOption option;
438         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
439         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
440         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
441 
442         EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
443                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_ENABLE_CLOUD), data,
444                             reply, option));
445     } catch (...) {
446         EXPECT_TRUE(false);
447         GTEST_LOG_(INFO) << " HandleEnableCloud ERROR";
448     }
449     GTEST_LOG_(INFO) << "HandleEnableCloud End";
450 }
451 
452 /**
453  * @tc.name: HandleStartDownloadFileTest
454  * @tc.desc: Verify the HandleStartDownloadFile function.
455  * @tc.type: FUNC
456  * @tc.require: I6H5MH
457  */
458 HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest, TestSize.Level1)
459 {
460     GTEST_LOG_(INFO) << "HandleStartDownloadFile Start";
461     try {
462         MockService service;
463         EXPECT_CALL(service, StartDownloadFile(_)).WillOnce(Return(E_OK));
464         MessageParcel data;
465         MessageParcel reply;
466         MessageOption option;
467         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
468         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
469         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
470 
471         EXPECT_EQ(E_OK, service.OnRemoteRequest(
472                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE),
473                             data, reply, option));
474     } catch (...) {
475         EXPECT_TRUE(false);
476         GTEST_LOG_(INFO) << " HandleStartDownloadFile ERROR";
477     }
478     GTEST_LOG_(INFO) << "HandleStartDownloadFile End";
479 }
480 
481 /**
482  * @tc.name: HandleStopDownloadFileTest
483  * @tc.desc: Verify the HandleStopDownloadFile function.
484  * @tc.type: FUNC
485  * @tc.require: I6H5MH
486  */
487 HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest, TestSize.Level1)
488 {
489     GTEST_LOG_(INFO) << "HandleStopDownloadFile Start";
490     try {
491         MockService service;
492         EXPECT_CALL(service, StopDownloadFile(_, _)).WillOnce(Return(E_OK));
493         MessageParcel data;
494         MessageParcel reply;
495         MessageOption option;
496         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
497         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
498         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
499 
500         EXPECT_EQ(E_OK, service.OnRemoteRequest(
501                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE),
502                             data, reply, option));
503     } catch (...) {
504         EXPECT_TRUE(false);
505         GTEST_LOG_(INFO) << " HandleStopDownloadFile ERROR";
506     }
507     GTEST_LOG_(INFO) << "HandleStopDownloadFile End";
508 }
509 
510 /**
511  * @tc.name: HandleRegisterDownloadFileCallbackTest
512  * @tc.desc: Verify the HandleRegisterDownloadFileCallback function.
513  * @tc.type: FUNC
514  * @tc.require: I6H5MH
515  */
516 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest, TestSize.Level1)
517 {
518     GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback Start";
519     try {
520         MockService service;
521         EXPECT_CALL(service, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK));
522         MessageParcel data;
523         MessageParcel reply;
524         MessageOption option;
525         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
526         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
527 
528         EXPECT_EQ(E_OK, service.OnRemoteRequest(
529                             static_cast<uint32_t>(
530                                 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK),
531                             data, reply, option));
532     } catch (...) {
533         EXPECT_TRUE(false);
534         GTEST_LOG_(INFO) << " HandleRegisterDownloadFileCallback ERROR";
535     }
536     GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback End";
537 }
538 
539 /**
540  * @tc.name: HandleUnregisterDownloadFileCallbackTest
541  * @tc.desc: Verify the HandleUnregisterDownloadFileCallback function.
542  * @tc.type: FUNC
543  * @tc.require: I6H5MH
544  */
545 HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest, TestSize.Level1)
546 {
547     GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback Start";
548     try {
549         MockService service;
550         EXPECT_CALL(service, UnregisterDownloadFileCallback()).WillOnce(Return(E_OK));
551         MessageParcel data;
552         MessageParcel reply;
553         MessageOption option;
554         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
555         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
556 
557         EXPECT_EQ(E_OK, service.OnRemoteRequest(
558                             static_cast<uint32_t>(
559                                 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK),
560                             data, reply, option));
561     } catch (...) {
562         EXPECT_TRUE(false);
563         GTEST_LOG_(INFO) << " HandleUnregisterDownloadFileCallback ERROR";
564     }
565     GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback End";
566 }
567 
568 /**
569  * @tc.name: HandleUploadAssetTest
570  * @tc.desc: Verify the HandleUploadAsset function.
571  * @tc.type: FUNC
572  * @tc.require: I6H5MH
573  */
574 HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest, TestSize.Level1)
575 {
576     GTEST_LOG_(INFO) << "HandleUploadAsset Start";
577     try {
578         MockService service;
579         EXPECT_CALL(service, UploadAsset(_, _, _)).WillOnce(Return(E_OK));
580         MessageParcel data;
581         MessageParcel reply;
582         MessageOption option;
583         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
584         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
585         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
586 
587         EXPECT_EQ(E_OK, service.OnRemoteRequest(
588                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET), data,
589                             reply, option));
590     } catch (...) {
591         EXPECT_TRUE(false);
592         GTEST_LOG_(INFO) << " HandleUploadAsset ERROR";
593     }
594     GTEST_LOG_(INFO) << "HandleUploadAsset End";
595 }
596 
597 /**
598  * @tc.name: HandleDownloadFileTest
599  * @tc.desc: Verify the HandleDownloadFile function.
600  * @tc.type: FUNC
601  * @tc.require: I6H5MH
602  */
603 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFileTest, TestSize.Level1)
604 {
605     GTEST_LOG_(INFO) << "HandleDownloadFile Start";
606     try {
607         MockService service;
608         MessageParcel data;
609         MessageParcel reply;
610         MessageOption option;
611         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
612         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
613         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
614 
615         EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
616                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE), data,
617                             reply, option));
618     } catch (...) {
619         EXPECT_TRUE(false);
620         GTEST_LOG_(INFO) << " HandleDownloadFile ERROR";
621     }
622     GTEST_LOG_(INFO) << "HandleDownloadFile End";
623 }
624 
625 /**
626  * @tc.name: HandleDownloadAssetTest
627  * @tc.desc: Verify the HandleDownloadAsset function.
628  * @tc.type: FUNC
629  * @tc.require: I6H5MH
630  */
631 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadAssetTest, TestSize.Level1)
632 {
633     GTEST_LOG_(INFO) << "HandleDownloadAsset Start";
634     try {
635         MockService service;
636         MessageParcel data;
637         MessageParcel reply;
638         MessageOption option;
639         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
640         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
641         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
642 
643         EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
644                             static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET), data,
645                             reply, option));
646     } catch (...) {
647         EXPECT_TRUE(false);
648         GTEST_LOG_(INFO) << " HandleDownloadAsset ERROR";
649     }
650     GTEST_LOG_(INFO) << "HandleDownloadAsset End";
651 }
652 
653 /**
654  * @tc.name: HandleRegisterDownloadAssetCallbackTest
655  * @tc.desc: Verify the HandleRegisterDownloadAssetCallback function.
656  * @tc.type: FUNC
657  * @tc.require: I6H5MH
658  */
659 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadAssetCallbackTest, TestSize.Level1)
660 {
661     GTEST_LOG_(INFO) << "HandleRegisterDownloadAssetCallback Start";
662     try {
663         MockService service;
664         MessageParcel data;
665         MessageParcel reply;
666         MessageOption option;
667         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
668         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
669         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
670 
671         EXPECT_EQ(E_OK, service.OnRemoteRequest(
672               static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK),
673               data, reply, option));
674     } catch (...) {
675         EXPECT_TRUE(false);
676         GTEST_LOG_(INFO) << " HandleRegisterDownloadAssetCallback ERROR";
677     }
678     GTEST_LOG_(INFO) << "HandleRegisterDownloadAssetCallback End";
679 }
680 
681 /**
682  * @tc.name: HandleDeleteAssetTest
683  * @tc.desc: Verify the HandleDeleteAsset function.
684  * @tc.type: FUNC
685  * @tc.require: I6H5MH
686  */
687 HWTEST_F(CloudSyncServiceStubTest, HandleDeleteAssetTest, TestSize.Level1)
688 {
689     GTEST_LOG_(INFO) << "HandleDeleteAsset Start";
690     try {
691         MockService service;
692         EXPECT_CALL(service, DeleteAsset(_, _)).WillOnce(Return(E_OK));
693         MessageParcel data;
694         MessageParcel reply;
695         MessageOption option;
696         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
697         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
698         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
699 
700         EXPECT_EQ(E_OK, service.OnRemoteRequest(
701               static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DELETE_ASSET),
702               data, reply, option));
703     } catch (...) {
704         EXPECT_TRUE(false);
705         GTEST_LOG_(INFO) << "HandleDeleteAsset ERROR";
706     }
707     GTEST_LOG_(INFO) << "HandleDeleteAsset End";
708 }
709 
710 /**
711  * @tc.name: HandleGetSyncTimeTest
712  * @tc.desc: Verify the HandleGetSyncTime function.
713  * @tc.type: FUNC
714  * @tc.require: I6H5MH
715  */
716 HWTEST_F(CloudSyncServiceStubTest, HandleGetSyncTimeTest, TestSize.Level1)
717 {
718     GTEST_LOG_(INFO) << "HandleGetSyncTime Start";
719     try {
720         string bundleName = "";
721         MockService service;
722         EXPECT_CALL(service, GetSyncTimeInner(_, bundleName)).WillOnce(Return(E_OK));
723         MessageParcel data;
724         MessageParcel reply;
725         MessageOption option;
726         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
727         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
728         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
729 
730         EXPECT_TRUE(data.WriteString(bundleName));
731 
732         EXPECT_EQ(E_OK, service.OnRemoteRequest(
733               static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME),
734               data, reply, option));
735     } catch (...) {
736         EXPECT_TRUE(false);
737         GTEST_LOG_(INFO) << "HandleGetSyncTime ERROR";
738     }
739     GTEST_LOG_(INFO) << "HandleGetSyncTime End";
740 }
741 
742 /**
743  * @tc.name: HandleCleanCacheTest
744  * @tc.desc: Verify the HandleCleanCache function.
745  * @tc.type: FUNC
746  * @tc.require: I6H5MH
747  */
748 HWTEST_F(CloudSyncServiceStubTest, HandleCleanCacheTest, TestSize.Level1)
749 {
750     GTEST_LOG_(INFO) << "HandleCleanCache Start";
751     try {
752         MockService service;
753         EXPECT_CALL(service, CleanCacheInner(_)).WillOnce(Return(E_OK));
754         MessageParcel data;
755         MessageParcel reply;
756         MessageOption option;
757         EXPECT_CALL(*dfsuAccessToken_, CheckCallerPermission(_)).WillOnce(Return(true));
758         EXPECT_CALL(*dfsuAccessToken_, IsSystemApp()).WillOnce(Return(true));
759         EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
760 
761         EXPECT_EQ(E_OK, service.OnRemoteRequest(
762               static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE),
763               data, reply, option));
764     } catch (...) {
765         EXPECT_TRUE(false);
766         GTEST_LOG_(INFO) << "HandleCleanCache ERROR";
767     }
768     GTEST_LOG_(INFO) << "HandleCleanCache End";
769 }
770 } // namespace Test
771 } // namespace FileManagement::CloudSync
772 } // namespace OHOS
773