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