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