1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "cloud_sync_service.h"
19 #include "cloud_sync_common.h"
20 #include "dfs_error.h"
21 #include "service_callback_mock.h"
22 #include "utils_log.h"
23 #include "i_cloud_download_callback_mock.h"
24
25 namespace OHOS {
26 namespace FileManagement::CloudSync {
27 namespace Test {
28 using namespace testing::ext;
29 using namespace std;
30
31 std::shared_ptr<CloudSyncService> g_servicePtr_;
32
33 class CloudSyncServiceTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase(void)41 void CloudSyncServiceTest::SetUpTestCase(void)
42 {
43 if (g_servicePtr_ == nullptr) {
44 int32_t saId = 5204;
45 g_servicePtr_ = std::make_shared<CloudSyncService>(saId);
46 ASSERT_TRUE(g_servicePtr_ != nullptr) << "SystemAbility failed";
47 }
48 std::cout << "SetUpTestCase" << std::endl;
49 }
50
TearDownTestCase(void)51 void CloudSyncServiceTest::TearDownTestCase(void)
52 {
53 std::cout << "TearDownTestCase" << std::endl;
54 }
55
SetUp(void)56 void CloudSyncServiceTest::SetUp(void)
57 {
58 std::cout << "SetUp" << std::endl;
59 }
60
TearDown(void)61 void CloudSyncServiceTest::TearDown(void)
62 {
63 std::cout << "TearDown" << std::endl;
64 }
65
66 /**
67 * @tc.name:GetHmdfsPathTest001
68 * @tc.desc:Verify the GetHmdfsPath function.
69 * @tc.type:FUNC
70 * @tc.require: I6H5MH
71 */
72 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest001, TestSize.Level1)
73 {
74 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 start";
75 try {
76 std::string uri = "";
77 int32_t userId = 100;
78 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
79 EXPECT_EQ(ret, "");
80 } catch (...) {
81 EXPECT_TRUE(false);
82 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 FAILED";
83 }
84 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 end";
85 }
86
87 /**
88 * @tc.name:GetHmdfsPathTest002
89 * @tc.desc:Verify the GetHmdfsPath function.
90 * @tc.type:FUNC
91 * @tc.require: I6H5MH
92 */
93 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest002, TestSize.Level1)
94 {
95 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 start";
96 try {
97 std::string uri = "invaild_uri";
98 int32_t userId = 100;
99 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
100 EXPECT_EQ(ret, "");
101 } catch (...) {
102 EXPECT_TRUE(false);
103 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 FAILED";
104 }
105 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 end";
106 }
107
108 /**
109 * @tc.name:GetHmdfsPathTest003
110 * @tc.desc:Verify the GetHmdfsPath function.
111 * @tc.type:FUNC
112 * @tc.require: I6H5MH
113 */
114 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest003, TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 start";
117 try {
118 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
119 int32_t userId = 100;
120 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
121 std::string out = "/mnt/hmdfs/100/account/device_view/local/data/com.hmos.notepad/dir/1.txt";
122 EXPECT_EQ(ret, out);
123 } catch (...) {
124 EXPECT_TRUE(false);
125 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 FAILED";
126 }
127 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 end";
128 }
129
130 /**
131 * @tc.name: OnStartTest
132 * @tc.desc: Verify the OnStart function.
133 * @tc.type: FUNC
134 * @tc.require: I6H5MH
135 */
136 HWTEST_F(CloudSyncServiceTest, OnStartTest, TestSize.Level1)
137 {
138 GTEST_LOG_(INFO) << "OnStart start";
139 try {
140 g_servicePtr_->OnStart();
141 } catch (...) {
142 EXPECT_TRUE(false);
143 GTEST_LOG_(INFO) << "OnStart FAILED";
144 }
145 GTEST_LOG_(INFO) << "OnStart end";
146 }
147
148 /**
149 * @tc.name: OnStopTest
150 * @tc.desc: Verify the OnStop function.
151 * @tc.type: FUNC
152 * @tc.require: I6H5MH
153 */
154 HWTEST_F(CloudSyncServiceTest, OnStopTest, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "OnStop start";
157 try {
158 g_servicePtr_->OnStop();
159 } catch (...) {
160 EXPECT_TRUE(false);
161 GTEST_LOG_(INFO) << "OnStop FAILED";
162 }
163 GTEST_LOG_(INFO) << "OnStop end";
164 }
165
166 /**
167 * @tc.name:RegisterCallbackInnerTest
168 * @tc.desc:Verify the RegisterCallbackInner function.
169 * @tc.type:FUNC
170 * @tc.require: I6H5MH
171 */
172 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "RegisterCallbackInner start";
175 try {
176 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
177 int ret = g_servicePtr_->RegisterCallbackInner(callback);
178 EXPECT_EQ(ret, E_OK);
179 } catch (...) {
180 EXPECT_TRUE(false);
181 GTEST_LOG_(INFO) << "RegisterCallbackInner FAILED";
182 }
183 GTEST_LOG_(INFO) << "RegisterCallbackInner end";
184 }
185
186 /**
187 * @tc.name:RegisterCallbackInnerTest002
188 * @tc.desc:Verify the RegisterCallbackInner function.
189 * @tc.type:FUNC
190 * @tc.require: I6H5MH
191 */
192 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest002, TestSize.Level1)
193 {
194 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch start";
195 try {
196 sptr<CloudSyncCallbackMock> callback = nullptr;
197 int ret = g_servicePtr_->RegisterCallbackInner(callback);
198 EXPECT_EQ(ret, E_INVAL_ARG);
199 } catch (...) {
200 EXPECT_TRUE(false);
201 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch FAILED";
202 }
203 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch end";
204 }
205
206 /**
207 * @tc.name:StopSyncInnerTest
208 * @tc.desc:Verify the StopSyncInner function.
209 * @tc.type:FUNC
210 * @tc.require: I6H5MH
211 */
212 HWTEST_F(CloudSyncServiceTest, StopSyncInnerTest, TestSize.Level1)
213 {
214 GTEST_LOG_(INFO) << "StopSyncInner Start";
215 try {
216 string bundleName = "com.ohos.photos";
217 int32_t callerUserId = 100;
218 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
219 int ret = dataSyncManager->TriggerStopSync(bundleName, callerUserId, SyncTriggerType::APP_TRIGGER);
220 EXPECT_EQ(ret, E_OK);
221 } catch (...) {
222 EXPECT_TRUE(false);
223 GTEST_LOG_(INFO) << "StopSyncInner FAILED";
224 }
225 GTEST_LOG_(INFO) << "StopSyncInner End";
226 }
227
228 /**
229 * @tc.name:UnRegisterCallbackInnerTest
230 * @tc.desc:Verify the UnRegisterCallbackInner function.
231 * @tc.type:FUNC
232 * @tc.require: I6H5MH
233 */
234 HWTEST_F(CloudSyncServiceTest, UnRegisterCallbackInnerTest, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "UnRegisterCallbackInner Start";
237 try {
238 int ret = g_servicePtr_->UnRegisterCallbackInner();
239 EXPECT_EQ(ret, E_OK);
240 } catch (...) {
241 EXPECT_TRUE(false);
242 GTEST_LOG_(INFO) << "UnRegisterCallbackInner FAILED";
243 }
244 GTEST_LOG_(INFO) << "UnRegisterCallbackInner End";
245 }
246
247 /**
248 * @tc.name:StartSyncInnerTest
249 * @tc.desc:Verify the StartSyncInner function.
250 * @tc.type:FUNC
251 * @tc.require: I6H5MH
252 */
253 HWTEST_F(CloudSyncServiceTest, StartSyncInnerTest, TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "StartSyncInner Start";
256 try {
257 string bundleName = "com.ohos.photos";
258 int32_t callerUserId = 100;
259 bool forceFlag = true;
260 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
261 int ret = dataSyncManager->TriggerStartSync(bundleName, callerUserId, forceFlag, SyncTriggerType::APP_TRIGGER);
262 EXPECT_EQ(ret, E_OK);
263 } catch (...) {
264 EXPECT_TRUE(false);
265 GTEST_LOG_(INFO) << "StartSyncInner FAILED";
266 }
267 GTEST_LOG_(INFO) << "StartSyncInner End";
268 }
269
270 /**
271 * @tc.name:DisableCloudTest
272 * @tc.desc:Verify the DisableCloud function.
273 * @tc.type:FUNC
274 * @tc.require: I6H5MH
275 */
276 HWTEST_F(CloudSyncServiceTest, DisableCloudTest, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "DisableCloud start";
279 try {
280 std::string accountId = "testId";
281 int ret = g_servicePtr_->DisableCloud(accountId);
282 EXPECT_EQ(ret, E_OK);
283 } catch (...) {
284 EXPECT_TRUE(false);
285 GTEST_LOG_(INFO) << "DisableCloud FAILED";
286 }
287 GTEST_LOG_(INFO) << "DisableCloud end";
288 }
289
290 /**
291 * @tc.name:EnableCloudTest
292 * @tc.desc:Verify the EnableCloud function.
293 * @tc.type:FUNC
294 * @tc.require: I6H5MH
295 */
296 HWTEST_F(CloudSyncServiceTest, EnableCloudTest, TestSize.Level1)
297 {
298 GTEST_LOG_(INFO) << "EnableCloud start";
299 try {
300 std::string accountId = "testId";
301 SwitchDataObj switchData;
302 int ret = g_servicePtr_->EnableCloud(accountId, switchData);
303 EXPECT_EQ(ret, E_OK);
304 } catch (...) {
305 EXPECT_TRUE(false);
306 GTEST_LOG_(INFO) << "EnableCloud FAILED";
307 }
308 GTEST_LOG_(INFO) << "EnableCloud end";
309 }
310
311 /**
312 * @tc.name:CleanTest
313 * @tc.desc:Verify the Clean function.
314 * @tc.type:FUNC
315 * @tc.require: I6H5MH
316 */
317 HWTEST_F(CloudSyncServiceTest, CleanTest, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO) << "DisableCloud start";
320 try {
321 std::string accountId = "testId";
322 CleanOptions cleanOptions;
323 int ret = g_servicePtr_->Clean(accountId, cleanOptions);
324 EXPECT_EQ(ret, E_OK);
325 } catch (...) {
326 EXPECT_TRUE(false);
327 GTEST_LOG_(INFO) << "Clean FAILED";
328 }
329 GTEST_LOG_(INFO) << "Clean end";
330 }
331
332 /**
333 * @tc.name:StartDownloadFileTest
334 * @tc.desc:Verify the StartDownloadFile function.
335 * @tc.type:FUNC
336 * @tc.require: I6H5MH
337 */
338 HWTEST_F(CloudSyncServiceTest, StartDownloadFileTest, TestSize.Level1)
339 {
340 GTEST_LOG_(INFO) << "StartDownloadFile start";
341 try {
342 string bundleName = "com.ohos.photos";
343 int32_t callerUserId = 100;
344 std::string path;
345 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
346 int ret = dataSyncManager->StartDownloadFile(bundleName, callerUserId, path);
347 EXPECT_EQ(ret, E_OK);
348 } catch (...) {
349 EXPECT_TRUE(false);
350 GTEST_LOG_(INFO) << "StartDownloadFile FAILED";
351 }
352 GTEST_LOG_(INFO) << "StartDownloadFile end";
353 }
354
355 /**
356 * @tc.name:StopDownloadFileTest
357 * @tc.desc:Verify the StopDownloadFile function.
358 * @tc.type:FUNC
359 * @tc.require: I6H5MH
360 */
361 HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest, TestSize.Level1)
362 {
363 GTEST_LOG_(INFO) << "StopDownloadFile start";
364 try {
365 string bundleName = "com.ohos.photos";
366 int32_t callerUserId = 100;
367 std::string path;
368 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
369 int ret = dataSyncManager->StopDownloadFile(bundleName, callerUserId, path);
370 EXPECT_EQ(ret, E_OK);
371 } catch (...) {
372 EXPECT_TRUE(false);
373 GTEST_LOG_(INFO) << "StopDownloadFile FAILED";
374 }
375 GTEST_LOG_(INFO) << "StopDownloadFile end";
376 }
377
378 /**
379 * @tc.name:RegisterDownloadFileCallbackTest
380 * @tc.desc:Verify the RegisterDownloadFileCallback function.
381 * @tc.type:FUNC
382 * @tc.require: I6H5MH
383 */
384 HWTEST_F(CloudSyncServiceTest, RegisterDownloadFileCallbackTest, TestSize.Level1)
385 {
386 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback start";
387 try {
388 string bundleName = "com.ohos.photos";
389 int32_t callerUserId = 100;
390 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
391 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
392 int ret = dataSyncManager->RegisterDownloadFileCallback(bundleName, callerUserId, downloadCallback);
393 EXPECT_EQ(ret, E_OK);
394 } catch (...) {
395 EXPECT_TRUE(false);
396 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback FAILED";
397 }
398 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback end";
399 }
400
401 /**
402 * @tc.name:UnregisterDownloadFileCallbackTest
403 * @tc.desc:Verify the UnregisterDownloadFileCallback function.
404 * @tc.type:FUNC
405 * @tc.require: I6H5MH
406 */
407 HWTEST_F(CloudSyncServiceTest, UnregisterDownloadFileCallbackTest, TestSize.Level1)
408 {
409 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback start";
410 try {
411 string bundleName = "com.ohos.photos";
412 int32_t callerUserId = 100;
413 auto dataSyncManager = g_servicePtr_->dataSyncManager_;
414 int ret = dataSyncManager->UnregisterDownloadFileCallback(bundleName, callerUserId);
415 EXPECT_EQ(ret, E_OK);
416 } catch (...) {
417 EXPECT_TRUE(false);
418 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback FAILED";
419 }
420 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback end";
421 }
422
423 /**
424 * @tc.name:UploadAssetTest
425 * @tc.desc:Verify the UploadAsset function.
426 * @tc.type:FUNC
427 * @tc.require: I6H5MH
428 */
429 HWTEST_F(CloudSyncServiceTest, UploadAssetTest, TestSize.Level1)
430 {
431 GTEST_LOG_(INFO) << "UploadAsset start";
432 try {
433 int32_t userId = 100;
434 std::string request = "testReq";
435 std::string result = "expRes";
436 int ret = g_servicePtr_->UploadAsset(userId, request, result);
437 EXPECT_EQ(ret, E_OK);
438 } catch (...) {
439 EXPECT_TRUE(false);
440 GTEST_LOG_(INFO) << "UploadAsset FAILED";
441 }
442 GTEST_LOG_(INFO) << "UploadAsset end";
443 }
444
445 /**
446 * @tc.name:DownloadFileTest001
447 * @tc.desc:Verify the DownloadFile function.
448 * @tc.type:FUNC
449 * @tc.require: I6H5MH
450 */
451 HWTEST_F(CloudSyncServiceTest, DownloadFileTest001, TestSize.Level1)
452 {
453 GTEST_LOG_(INFO) << "DownloadFileTest001 start";
454 try {
455 int32_t userId = 100;
456 std::string bundleName = "com.ohos.photos";
457 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
458 AssetInfoObj assetInfoObj;
459 assetInfoObj.uri = uri;
460 int ret = g_servicePtr_->DownloadFile(userId, bundleName, assetInfoObj);
461 EXPECT_EQ(ret, E_OK);
462 } catch (...) {
463 EXPECT_TRUE(false);
464 GTEST_LOG_(INFO) << "DownloadFileTest001 FAILED";
465 }
466 GTEST_LOG_(INFO) << "DownloadFileTest001 end";
467 }
468
469 /**
470 * @tc.name:DownloadFileTest002
471 * @tc.desc:Verify the DownloadFile function.
472 * @tc.type:FUNC
473 * @tc.require: I6H5MH
474 */
475 HWTEST_F(CloudSyncServiceTest, DownloadFileTest002, TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "DownloadFileTest002 start";
478 try {
479 int32_t userId = 100;
480 std::string bundleName = "com.ohos.photos";
481 AssetInfoObj assetInfoObj;
482 int ret = g_servicePtr_->DownloadFile(userId, bundleName, assetInfoObj);
483 EXPECT_EQ(ret, E_INVAL_ARG);
484 } catch (...) {
485 EXPECT_TRUE(false);
486 GTEST_LOG_(INFO) << "DownloadFileTest002 FAILED";
487 }
488 GTEST_LOG_(INFO) << "DownloadFileTest002 end";
489 }
490
491 } // namespace Test
492 } // namespace FileManagement::CloudSync
493 } // namespace OHOS
494