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 <fstream>
17 #include <filesystem>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include <iostream>
21 #include <memory>
22 #include <sys/stat.h>
23
24 #include "abs_shared_result_set_mock.h"
25 #include "dfs_error.h"
26 #include "file_data_handler.h"
27 #include "gallery_file_const.h"
28 #include "rdb_helper.h"
29 #include "rdb_open_callback.h"
30 #include "rdb_store_config.h"
31 #include "rdb_store_mock.h"
32 #include "result_set_mock.h"
33 #include "sync_rule/cloud_status.h"
34
35 namespace OHOS::FileManagement::CloudSync::Test {
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace std;
39 using namespace NativeRdb;
40 using namespace DriveKit;
41 const int USER_ID = 0;
42 const std::string BUND_NAME = "com.ohos.photos";
43 class FileDataHandlerTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase(void)51 void FileDataHandlerTest::SetUpTestCase(void)
52 {
53 GTEST_LOG_(INFO) << "SetUpTestCase";
54 }
55
TearDownTestCase(void)56 void FileDataHandlerTest::TearDownTestCase(void)
57 {
58 GTEST_LOG_(INFO) << "TearDownTestCase";
59 }
60
SetUp(void)61 void FileDataHandlerTest::SetUp(void)
62 {
63 GTEST_LOG_(INFO) << "SetUp";
64 }
65
TearDown(void)66 void FileDataHandlerTest::TearDown(void)
67 {
68 GTEST_LOG_(INFO) << "TearDown";
69 }
70
71 #include "file_data_handler_two_test.cpp"
72 #include "file_data_handler_three_test.cpp"
73 #include "file_data_handler_four_test.cpp"
74
75 /**
76 * @tc.name: GetFetchCondition001
77 * @tc.desc: Verify the GetFetchCondition function
78 * @tc.type: FUNC
79 * @tc.require: I6JPKG
80 */
81 HWTEST_F(FileDataHandlerTest, GetFetchCondition001, TestSize.Level1)
82 {
83 GTEST_LOG_(INFO) << "GetFetchCondition001 Begin";
84 try {
85 FetchCondition cond;
86 auto rdb = std::make_shared<RdbStoreMock>();
87 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
88 fileDataHandler->isChecking_ = true;
89 fileDataHandler->GetFetchCondition(cond);
90 fileDataHandler->isChecking_ = false;
91 fileDataHandler->GetFetchCondition(cond);
92 EXPECT_TRUE(true);
93 } catch (...) {
94 EXPECT_TRUE(false);
95 GTEST_LOG_(INFO) << " GetFetchCondition001 ERROR";
96 }
97
98 GTEST_LOG_(INFO) << "GetFetchCondition001 End";
99 }
100
101 /**
102 * @tc.name: GetRetryRecords001
103 * @tc.desc: Verify the GetRetryRecords function
104 * @tc.type: FUNC
105 * @tc.require: I6JPKG
106 */
107 HWTEST_F(FileDataHandlerTest, GetRetryRecords001, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "GetRetryRecords001 Begin";
110 try {
111 auto rdb = std::make_shared<RdbStoreMock>();
112 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
113
114 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
115 std::vector<DriveKit::DKRecordId> records;
116 int32_t ret = fileDataHandler->GetRetryRecords(records);
117 EXPECT_EQ(E_RDB, ret);
118 } catch (...) {
119 EXPECT_TRUE(false);
120 GTEST_LOG_(INFO) << " GetRetryRecords001 ERROR";
121 }
122
123 GTEST_LOG_(INFO) << "GetRetryRecords001 End";
124 }
125
126 /**
127 * @tc.name: GetRetryRecords002
128 * @tc.desc: Verify the GetRetryRecords function
129 * @tc.type: FUNC
130 * @tc.require: I6JPKG
131 */
132 HWTEST_F(FileDataHandlerTest, GetRetryRecords002, TestSize.Level1)
133 {
134 GTEST_LOG_(INFO) << "GetRetryRecords002 Begin";
135 try {
136 auto rdb = std::make_shared<RdbStoreMock>();
137 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
138
139 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
140
141 const int count = 3;
142 EXPECT_CALL(*rset, GoToNextRow())
143 .Times(count)
144 .WillOnce(Return(0))
145 .WillOnce(Return(0))
146 .WillRepeatedly(Return(1));
147
148 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
149
150 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
151
152 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
153
154 std::vector<DriveKit::DKRecordId> records;
155 int32_t ret = fileDataHandler->GetRetryRecords(records);
156 EXPECT_EQ(E_OK, ret);
157 } catch (...) {
158 EXPECT_TRUE(false);
159 GTEST_LOG_(INFO) << " GetRetryRecords002 ERROR";
160 }
161
162 GTEST_LOG_(INFO) << "GetRetryRecords002 End";
163 }
164
165 /**
166 * @tc.name: GetDownloadAsset001
167 * @tc.desc: Verify the GetDownloadAsset function
168 * @tc.type: FUNC
169 * @tc.require: I6JPKG
170 */
171 HWTEST_F(FileDataHandlerTest, GetDownloadAsset001, TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "GetDownloadAsset001 Begin";
174 try {
175 auto rdb = std::make_shared<RdbStoreMock>();
176 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
177
178 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
179
180 std::string cloudId = "cloudId";
181 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
182 int32_t ret = fileDataHandler->GetDownloadAsset(cloudId, outAssetsToDownload);
183 EXPECT_EQ(E_RDB, ret);
184 } catch (...) {
185 EXPECT_TRUE(false);
186 GTEST_LOG_(INFO) << " GetDownloadAsset001 ERROR";
187 }
188
189 GTEST_LOG_(INFO) << "GetDownloadAsset001 End";
190 }
191
192 /**
193 * @tc.name: GetDownloadAsset002
194 * @tc.desc: Verify the GetDownloadAsset function
195 * @tc.type: FUNC
196 * @tc.require: I6JPKG
197 */
198 HWTEST_F(FileDataHandlerTest, GetDownloadAsset002, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "GetDownloadAsset002 Begin";
201 try {
202 auto rdb = std::make_shared<RdbStoreMock>();
203 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
204
205 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
206
207 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(Return(1));
208 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
209 std::string cloudId = "cloudId";
210 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
211 int32_t ret = fileDataHandler->GetDownloadAsset(cloudId, outAssetsToDownload);
212 EXPECT_EQ(E_RDB, ret);
213 } catch (...) {
214 EXPECT_TRUE(false);
215 GTEST_LOG_(INFO) << " GetDownloadAsset002 ERROR";
216 }
217
218 GTEST_LOG_(INFO) << "GetDownloadAsset002 End";
219 }
220
221 /**
222 * @tc.name: GetDownloadAsset003
223 * @tc.desc: Verify the GetDownloadAsset function
224 * @tc.type: FUNC
225 * @tc.require: I6JPKG
226 */
227 HWTEST_F(FileDataHandlerTest, GetDownloadAsset003, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "GetDownloadAsset003 Begin";
230 try {
231 const int rowCount = 3;
232 auto rdb = std::make_shared<RdbStoreMock>();
233 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
234
235 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
236
237 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
238 EXPECT_CALL(*rset, GoToNextRow())
239 .Times(rowCount)
240 .WillOnce(Return(0))
241 .WillOnce(Return(0))
242 .WillRepeatedly(Return(1));
243 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
244 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
245 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
246 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
247 EXPECT_CALL(*rset, GetDouble(_, _)).WillRepeatedly(Return(0));
248 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
249 std::string cloudId = "cloudId";
250 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
251 int32_t ret = fileDataHandler->GetDownloadAsset(cloudId, outAssetsToDownload);
252 EXPECT_EQ(E_OK, ret);
253 } catch (...) {
254 EXPECT_TRUE(false);
255 GTEST_LOG_(INFO) << " GetDownloadAsset003 ERROR";
256 }
257
258 GTEST_LOG_(INFO) << "GetDownloadAsset003 End";
259 }
260
261 /**
262 * @tc.name: PullRecordInsert001
263 * @tc.desc: Verify the PullRecordInsert function
264 * @tc.type: FUNC
265 * @tc.require: I6JPKG
266 */
267 HWTEST_F(FileDataHandlerTest, PullRecordInsert001, TestSize.Level1)
268 {
269 GTEST_LOG_(INFO) << "PullRecordInsert001 Begin";
270 try {
271 auto rdb = std::make_shared<RdbStoreMock>();
272 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
273 DKRecord record;
274 OnFetchParams onFetchParams{true};
275 int32_t ret = fileDataHandler->PullRecordInsert(record, onFetchParams);
276 EXPECT_NE(E_OK, ret);
277 } catch (...) {
278 EXPECT_TRUE(false);
279 GTEST_LOG_(INFO) << " PullRecordInsert001 ERROR";
280 }
281
282 GTEST_LOG_(INFO) << "PullRecordInsert001 End";
283 }
284
285 /**
286 * @tc.name: PullRecordInsert002
287 * @tc.desc: Verify the PullRecordInsert function
288 * @tc.type: FUNC
289 * @tc.require: I6JPKG
290 */
291 HWTEST_F(FileDataHandlerTest, PullRecordInsert002, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "PullRecordInsert002 Begin";
294 try {
295 auto rdb = std::make_shared<RdbStoreMock>();
296 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
297 DKRecord record;
298 OnFetchParams onFetchParams{false};
299 int32_t ret = fileDataHandler->PullRecordInsert(record, onFetchParams);
300 EXPECT_NE(E_OK, ret);
301 } catch (...) {
302 EXPECT_TRUE(false);
303 GTEST_LOG_(INFO) << " PullRecordInsert002 ERROR";
304 }
305
306 GTEST_LOG_(INFO) << "PullRecordInsert002 End";
307 }
308
309 /**
310 * @tc.name: SetRetry001
311 * @tc.desc: Verify the SetRetry function
312 * @tc.type: FUNC
313 * @tc.require: I6JPKG
314 */
315 HWTEST_F(FileDataHandlerTest, SetRetry001, TestSize.Level1)
316 {
317 GTEST_LOG_(INFO) << "SetRetry001 Begin";
318 try {
319 auto rdb = std::make_shared<RdbStoreMock>();
320 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
321 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
322
323 std::string recordId = "recordId";
324 int32_t ret = fileDataHandler->SetRetry(recordId);
325 EXPECT_NE(E_OK, ret);
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << " SetRetry001 ERROR";
329 }
330
331 GTEST_LOG_(INFO) << "SetRetry001 End";
332 }
333
334 /**
335 * @tc.name: SetRetry002
336 * @tc.desc: Verify the SetRetry function
337 * @tc.type: FUNC
338 * @tc.require: I6JPKG
339 */
340 HWTEST_F(FileDataHandlerTest, SetRetry002, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "SetRetry002 Begin";
343 try {
344 auto rdb = std::make_shared<RdbStoreMock>();
345 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
346 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
347
348 std::string recordId = "recordId";
349 int32_t ret = fileDataHandler->SetRetry(recordId);
350 EXPECT_EQ(E_OK, ret);
351 } catch (...) {
352 EXPECT_TRUE(false);
353 GTEST_LOG_(INFO) << " SetRetry002 ERROR";
354 }
355
356 GTEST_LOG_(INFO) << "SetRetry002 End";
357 }
358
359 /**
360 * @tc.name: RecycleFile001
361 * @tc.desc: Verify the RecycleFile function
362 * @tc.type: FUNC
363 * @tc.require: I6JPKG
364 */
365 HWTEST_F(FileDataHandlerTest, RecycleFile001, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO) << "RecycleFile001 Begin";
368 try {
369 auto rdb = std::make_shared<RdbStoreMock>();
370 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
371 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
372
373 std::string recordId;
374 int32_t ret = fileDataHandler->RecycleFile(recordId);
375 EXPECT_NE(E_OK, ret);
376 } catch (...) {
377 EXPECT_TRUE(false);
378 GTEST_LOG_(INFO) << " RecycleFile001 ERROR";
379 }
380
381 GTEST_LOG_(INFO) << "RecycleFile001 End";
382 }
383
384 /**
385 * @tc.name: RecycleFile002
386 * @tc.desc: Verify the RecycleFile function
387 * @tc.type: FUNC
388 * @tc.require: I6JPKG
389 */
390 HWTEST_F(FileDataHandlerTest, RecycleFile002, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "RecycleFile002 Begin";
393 try {
394 auto rdb = std::make_shared<RdbStoreMock>();
395 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
396 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
397
398 std::string recordId;
399 int32_t ret = fileDataHandler->RecycleFile(recordId);
400 EXPECT_EQ(E_OK, ret);
401 } catch (...) {
402 EXPECT_TRUE(false);
403 GTEST_LOG_(INFO) << " RecycleFile002 ERROR";
404 }
405
406 GTEST_LOG_(INFO) << "RecycleFile002 End";
407 }
408
409 /**
410 * @tc.name: GetFileModifiedRecords001
411 * @tc.desc: Verify the GetFileModifiedRecords function
412 * @tc.type: FUNC
413 * @tc.require: I6JPKG
414 */
415 HWTEST_F(FileDataHandlerTest, GetFileModifiedRecords001, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "GetFileModifiedRecords001 Begin";
418 try {
419 auto rdb = std::make_shared<RdbStoreMock>();
420 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
421
422 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
423 vector<DKRecord> records;
424 int32_t ret = fileDataHandler->GetFileModifiedRecords(records);
425 EXPECT_NE(E_OK, ret);
426 } catch (...) {
427 EXPECT_TRUE(false);
428 GTEST_LOG_(INFO) << " GetFileModifiedRecords001 ERROR";
429 }
430
431 GTEST_LOG_(INFO) << "GetFileModifiedRecords001 End";
432 }
433
434 /**
435 * @tc.name: GetFileModifiedRecords002
436 * @tc.desc: Verify the GetFileModifiedRecords function
437 * @tc.type: FUNC
438 * @tc.require: I6JPKG
439 */
440 HWTEST_F(FileDataHandlerTest, GetFileModifiedRecords002, TestSize.Level1)
441 {
442 GTEST_LOG_(INFO) << "GetFileModifiedRecords002 Begin";
443 try {
444 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
445 auto rdb = std::make_shared<RdbStoreMock>();
446 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
447
448 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(Return(1));
449 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
450 vector<DKRecord> records;
451 int32_t ret = fileDataHandler->GetFileModifiedRecords(records);
452 EXPECT_NE(E_OK, ret);
453 } catch (...) {
454 EXPECT_TRUE(false);
455 GTEST_LOG_(INFO) << " GetFileModifiedRecords002 ERROR";
456 }
457
458 GTEST_LOG_(INFO) << "GetFileModifiedRecords002 End";
459 }
460
461 /**
462 * @tc.name: IsTimeChanged001
463 * @tc.desc: Verify the IsTimeChanged function
464 * @tc.type: FUNC
465 * @tc.require: I6JPKG
466 */
467 HWTEST_F(FileDataHandlerTest, IsTimeChanged001, TestSize.Level1)
468 {
469 GTEST_LOG_(INFO) << "IsTimeChanged001 Begin";
470 try {
471 auto rdb = std::make_shared<RdbStoreMock>();
472 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
473 DriveKit::DKRecord record;
474 std::unordered_map<std::string, LocalInfo> localMap;
475 std::string path = "";
476 std::string type = "hh";
477 bool ret = fileDataHandler->IsTimeChanged(record, localMap, path, type);
478 EXPECT_EQ(ret, true);
479 } catch (...) {
480 EXPECT_TRUE(false);
481 GTEST_LOG_(INFO) << " IsTimeChanged001 ERROR";
482 }
483 GTEST_LOG_(INFO) << "IsTimeChanged001 End";
484 }
485
486 /**
487 * @tc.name: IsTimeChanged002
488 * @tc.desc: Verify the IsTimeChanged function
489 * @tc.type: FUNC
490 * @tc.require: I6JPKG
491 */
492 HWTEST_F(FileDataHandlerTest, IsTimeChanged002, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "IsTimeChanged002 Begin";
495 try {
496 auto rdb = std::make_shared<RdbStoreMock>();
497 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
498 DriveKit::DKRecordData data;
499 DriveKit::DKRecord record;
500 std::unordered_map<std::string, LocalInfo> localMap;
501 std::string path = "";
502 std::string type = "hh";
503 DriveKit::DKRecordFieldMap prop;
504 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("123")));
505 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
506 record.SetRecordData(data);
507 bool ret = fileDataHandler->IsTimeChanged(record, localMap, path, type);
508 EXPECT_EQ(ret, true);
509 } catch (...) {
510 EXPECT_TRUE(false);
511 GTEST_LOG_(INFO) << " IsTimeChanged002 ERROR";
512 }
513 GTEST_LOG_(INFO) << "IsTimeChanged002 End";
514 }
515
516 /**
517 * @tc.name: IsTimeChanged003
518 * @tc.desc: Verify the IsTimeChanged function
519 * @tc.type: FUNC
520 * @tc.require: I6JPKG
521 */
522 HWTEST_F(FileDataHandlerTest, IsTimeChanged003, TestSize.Level1)
523 {
524 GTEST_LOG_(INFO) << "IsTimeChanged003 Begin";
525 try {
526 auto rdb = std::make_shared<RdbStoreMock>();
527 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
528 DriveKit::DKRecordData data;
529 DriveKit::DKRecord record;
530 std::unordered_map<std::string, LocalInfo> localMap;
531 std::string path = "";
532 std::string type = Media::PhotoColumn::PHOTO_META_DATE_MODIFIED;
533 DriveKit::DKRecordFieldMap prop;
534 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
535 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
536 record.SetRecordData(data);
537 bool ret = fileDataHandler->IsTimeChanged(record, localMap, path, type);
538 EXPECT_EQ(ret, true);
539 } catch (...) {
540 EXPECT_TRUE(false);
541 GTEST_LOG_(INFO) << " IsTimeChanged003 ERROR";
542 }
543 GTEST_LOG_(INFO) << "IsTimeChanged003 End";
544 }
545
546 /**
547 * @tc.name: IsTimeChanged004
548 * @tc.desc: Verify the IsTimeChanged function
549 * @tc.type: FUNC
550 * @tc.require: I6JPKG
551 */
552 HWTEST_F(FileDataHandlerTest, IsTimeChanged004, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "IsTimeChanged004 Begin";
555 try {
556 auto rdb = std::make_shared<RdbStoreMock>();
557 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
558 DriveKit::DKRecordData data;
559 DriveKit::DKRecord record;
560 std::unordered_map<std::string, LocalInfo> localMap;
561 std::string path = "hh";
562 std::string type = Media::PhotoColumn::PHOTO_META_DATE_MODIFIED;
563 localMap[path] = { 1111, 1111 };
564 DriveKit::DKRecordFieldMap prop;
565 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
566 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
567 record.SetEditedTime(1111000);
568 record.SetRecordData(data);
569 bool ret = fileDataHandler->IsTimeChanged(record, localMap, path, type);
570 EXPECT_EQ(ret, false);
571 } catch (...) {
572 EXPECT_TRUE(false);
573 GTEST_LOG_(INFO) << " IsTimeChanged004 ERROR";
574 }
575 GTEST_LOG_(INFO) << "IsTimeChanged004 End";
576 }
577
578 /**
579 * @tc.name: IsTimeChanged005
580 * @tc.desc: Verify the IsTimeChanged function
581 * @tc.type: FUNC
582 * @tc.require: I6JPKG
583 */
584 HWTEST_F(FileDataHandlerTest, IsTimeChanged005, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "IsTimeChanged005 Begin";
587 try {
588 auto rdb = std::make_shared<RdbStoreMock>();
589 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
590
591 DriveKit::DKRecordData data;
592 DriveKit::DKRecord record;
593 std::unordered_map<std::string, LocalInfo> localMap;
594 std::string path = "hh";
595 std::string type = Media::PhotoColumn::MEDIA_DATE_MODIFIED;
596
597 localMap[path] = { 11, 11 };
598 bool ret = fileDataHandler->IsTimeChanged(record, localMap, path, type);
599 EXPECT_EQ(ret, false);
600 } catch (...) {
601 EXPECT_TRUE(false);
602 GTEST_LOG_(INFO) << "IsTimeChanged005 ERROR";
603 }
604 GTEST_LOG_(INFO) << "IsTimeChanged005 End";
605 }
606
607 /**
608 * @tc.name: GetLocalInfo001
609 * @tc.desc: Verify the GetLocalInfo function
610 * @tc.type: FUNC
611 * @tc.require: I6JPKG
612 */
613 HWTEST_F(FileDataHandlerTest, GetLocalInfo001, TestSize.Level1)
614 {
615 GTEST_LOG_(INFO) << "GetLocalInfo001 Begin";
616 try {
617 auto rdb = std::make_shared<RdbStoreMock>();
618 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
619 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> map;
620 std::unordered_map<std::string, LocalInfo> cloudMap;
621 auto result = std::make_shared<std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult>>();
622 DriveKit::DKRecordData data2;
623 DriveKit::DKRecord record;
624 DriveKit::DKRecordOperResult operResult;
625 DriveKit::DKRecordId recordId = "1";
626 record.SetRecordData(data2);
627 operResult.SetDKRecord(std::move(record));
628 (*result)[recordId] = operResult;
629 fileDataHandler->GetLocalInfo(*result, cloudMap, "hh");
630 } catch (...) {
631 EXPECT_TRUE(false);
632 GTEST_LOG_(INFO) << " GetLocalInfo001 ERROR";
633 }
634 GTEST_LOG_(INFO) << "GetLocalInfo001 End";
635 }
636
637 /**
638 * @tc.name: GetLocalInfo002
639 * @tc.desc: Verify the GetLocalInfo function
640 * @tc.type: FUNC
641 * @tc.require: I6JPKG
642 */
643 HWTEST_F(FileDataHandlerTest, GetLocalInfo002, TestSize.Level1)
644 {
645 GTEST_LOG_(INFO) << "GetLocalInfo002 Begin";
646 try {
647 auto rdb = std::make_shared<RdbStoreMock>();
648 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
649 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> map;
650 std::unordered_map<std::string, LocalInfo> cloudMap;
651 auto result = std::make_shared<std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult>>();
652 DriveKit::DKRecordData data2;
653 DriveKit::DKRecordOperResult operResult;
654 DriveKit::DKRecord record;
655 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
656 DriveKit::DKRecordId recordId = "1";
657 record.SetRecordData(data2);
658 operResult.SetDKRecord(std::move(record));
659 (*result)[recordId] = operResult;
660 fileDataHandler->GetLocalInfo(*result, cloudMap, "cloud_id");
661 } catch (...) {
662 EXPECT_TRUE(false);
663 GTEST_LOG_(INFO) << " GetLocalInfo002 ERROR";
664 }
665 GTEST_LOG_(INFO) << "GetLocalInfo002 End";
666 }
667
668 /**
669 * @tc.name: GetLocalInfo003
670 * @tc.desc: Verify the GetLocalInfo function
671 * @tc.type: FUNC
672 * @tc.require: I6JPKG
673 */
674 HWTEST_F(FileDataHandlerTest, GetLocalInfo003, TestSize.Level1)
675 {
676 GTEST_LOG_(INFO) << "GetLocalInfo003 Begin";
677 try {
678 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> map;
679 std::unordered_map<std::string, LocalInfo> cloudMap;
680 auto rdb = std::make_shared<RdbStoreMock>();
681 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
682 auto result = std::make_shared<std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult>>();
683 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
684 DriveKit::DKRecordData data2;
685 DriveKit::DKRecordFieldMap prop;
686 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("123")));
687 data2.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
688 DriveKit::DKRecord record;
689 DriveKit::DKRecordOperResult operResult;
690 DriveKit::DKRecordId recordId = "1";
691 record.SetRecordData(data2);
692 operResult.SetDKRecord(std::move(record));
693 (*result)[recordId] = operResult;
694 fileDataHandler->GetLocalInfo(*result, cloudMap, "hh");
695 } catch (...) {
696 EXPECT_TRUE(false);
697 GTEST_LOG_(INFO) << " GetLocalInfo003 ERROR";
698 }
699 GTEST_LOG_(INFO) << "GetLocalInfo003 End";
700 }
701
702 /**
703 * @tc.name: GetLocalInfo004
704 * @tc.desc: Verify the GetLocalInfo function
705 * @tc.type: FUNC
706 * @tc.require: I6JPKG
707 */
708 HWTEST_F(FileDataHandlerTest, GetLocalInfo004, TestSize.Level1)
709 {
710 GTEST_LOG_(INFO) << "GetLocalInfo004 Begin";
711 try {
712 auto rdb = std::make_shared<RdbStoreMock>();
713 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
714 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> map;
715 std::unordered_map<std::string, LocalInfo> cloudMap;
716 auto result = std::make_shared<std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult>>();
717 DriveKit::DKRecordData data2;
718 DriveKit::DKRecordFieldMap prop;
719 data2.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
720 DriveKit::DKRecord record;
721 DriveKit::DKRecordOperResult operResult;
722 DriveKit::DKRecordId recordId = "1";
723 record.SetRecordData(data2);
724 operResult.SetDKRecord(std::move(record));
725 (*result)[recordId] = operResult;
726 fileDataHandler->GetLocalInfo(*result, cloudMap, "hh");
727 } catch (...) {
728 EXPECT_TRUE(false);
729 GTEST_LOG_(INFO) << " GetLocalInfo004 ERROR";
730 }
731 GTEST_LOG_(INFO) << "GetLocalInfo004 End";
732 }
733
734 /**
735 * @tc.name: GetLocalInfo005
736 * @tc.desc: Verify the GetLocalInfo function
737 * @tc.type: FUNC
738 * @tc.require: I6JPKG
739 */
740 HWTEST_F(FileDataHandlerTest, GetLocalInfo005, TestSize.Level1)
741 {
742 GTEST_LOG_(INFO) << "GetLocalInfo005 Begin";
743 try {
744 auto rdb = std::make_shared<RdbStoreMock>();
745 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
746 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> map;
747 std::unordered_map<std::string, LocalInfo> cloudMap;
748 auto result = std::make_shared<std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult>>();
749 DriveKit::DKRecordData data2;
750 DriveKit::DKRecordFieldMap prop;
751 data2.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
752 DriveKit::DKRecord record;
753 DriveKit::DKRecordOperResult operResult;
754 DriveKit::DKRecordId recordId = "1";
755 record.SetRecordData(data2);
756 operResult.SetDKRecord(std::move(record));
757 (*result)[recordId] = operResult;
758 fileDataHandler->GetLocalInfo(*result, cloudMap, "hh");
759 } catch (...) {
760 EXPECT_TRUE(false);
761 GTEST_LOG_(INFO) << " GetLocalInfo005 ERROR";
762 }
763 GTEST_LOG_(INFO) << "GetLocalInfo005 End";
764 }
765
766 /**
767 * @tc.name: BuildInfoMap001
768 * @tc.desc: Verify the BuildInfoMap function
769 * @tc.type: FUNC
770 * @tc.require: I6JPKG
771 */
772 HWTEST_F(FileDataHandlerTest, BuildInfoMap001, TestSize.Level1)
773 {
774 GTEST_LOG_(INFO) << "BuildInfoMap Begin";
775 try {
776 auto rdb = std::make_shared<RdbStoreMock>();
777 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
778 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
779 std::unordered_map<std::string, LocalInfo> cloudMap;
780 const int count = 3;
781 EXPECT_CALL(*rset, GoToNextRow())
782 .Times(count)
783 .WillOnce(Return(0))
784 .WillOnce(Return(0))
785 .WillRepeatedly(Return(1));
786 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
787 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
788 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
789 fileDataHandler->BuildInfoMap(move(rset), cloudMap, Media::PhotoColumn::PHOTO_CLOUD_ID);
790 } catch (...) {
791 EXPECT_TRUE(false);
792 GTEST_LOG_(INFO) << " BuildInfoMap001 ERROR";
793 }
794 GTEST_LOG_(INFO) << "BuildInfoMap001 End";
795 }
796
797 /**
798 * @tc.name: Reset001
799 * @tc.desc: Verify the Reset function
800 * @tc.type: FUNC
801 * @tc.require: I6JPKG
802 */
803 HWTEST_F(FileDataHandlerTest, Reset001, TestSize.Level1)
804 {
805 GTEST_LOG_(INFO) << "Reset001 Begin";
806 try {
807 auto rdb = std::make_shared<RdbStoreMock>();
808 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
809 fileDataHandler->modifyFailSet_.push_back("1");
810 fileDataHandler->createFailSet_.push_back("3");
811 fileDataHandler->Reset();
812 EXPECT_TRUE(fileDataHandler->modifyFailSet_.empty());
813 EXPECT_TRUE(fileDataHandler->createFailSet_.empty());
814 } catch (...) {
815 EXPECT_TRUE(false);
816 GTEST_LOG_(INFO) << " Reset001 ERROR";
817 }
818 GTEST_LOG_(INFO) << "Reset001 End";
819 }
820
821 /**
822 * @tc.name: OnCreateRecordSuccess001
823 * @tc.desc: Verify the OnCreateRecordSuccess function
824 * @tc.type: FUNC
825 * @tc.require: I6JPKG
826 */
827 HWTEST_F(FileDataHandlerTest, OnCreateRecordSuccess001, TestSize.Level1)
828 {
829 GTEST_LOG_(INFO) << "OnCreateRecordSuccess Begin";
830 try {
831 auto rdb = std::make_shared<RdbStoreMock>();
832 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
833 std::unordered_map<std::string, LocalInfo> localMap;
834 DriveKit::DKRecordData data2;
835 DriveKit::DKRecord record;
836 DriveKit::DKRecordOperResult operResult;
837 DriveKit::DKRecordId recordId = "1";
838 record.SetRecordData(data2);
839 operResult.SetDKRecord(std::move(record));
840 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
841 int32_t ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
842 EXPECT_EQ(static_cast<int32_t>(E_INVAL_ARG), ret);
843 } catch (...) {
844 EXPECT_TRUE(false);
845 GTEST_LOG_(INFO) << " OnCreateRecordSuccess001 ERROR";
846 }
847 GTEST_LOG_(INFO) << "OnCreateRecordSuccess001 End";
848 }
849
850 /**
851 * @tc.name: OnCreateRecordSuccess002
852 * @tc.desc: Verify the OnCreateRecordSuccess function
853 * @tc.type: FUNC
854 * @tc.require: I6JPKG
855 */
856 HWTEST_F(FileDataHandlerTest, OnCreateRecordSuccess002, TestSize.Level1)
857 {
858 GTEST_LOG_(INFO) << "OnCreateRecordSuccess002 Begin";
859 try {
860 auto rdb = std::make_shared<RdbStoreMock>();
861 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
862 std::unordered_map<std::string, LocalInfo> localMap;
863 DriveKit::DKRecordData data;
864 DriveKit::DKRecord record;
865 DriveKit::DKRecordOperResult operResult;
866 DriveKit::DKRecordId recordId = "1";
867 DriveKit::DKRecordFieldMap prop;
868 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
869 record.SetRecordData(data);
870 operResult.SetDKRecord(std::move(record));
871 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
872 int32_t ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
873 EXPECT_EQ(static_cast<int32_t>(E_INVAL_ARG), ret);
874 } catch (...) {
875 EXPECT_TRUE(false);
876 GTEST_LOG_(INFO) << " OnCreateRecordSuccess002 ERROR";
877 }
878 GTEST_LOG_(INFO) << "OnCreateRecordSuccess002 End";
879 }
880
881 /**
882 * @tc.name: OnCreateRecordSuccess003
883 * @tc.desc: Verify the OnCreateRecordSuccess function
884 * @tc.type: FUNC
885 * @tc.require: I6JPKG
886 */
887 HWTEST_F(FileDataHandlerTest, OnCreateRecordSuccess003, TestSize.Level1)
888 {
889 GTEST_LOG_(INFO) << "OnCreateRecordSuccess003 Begin";
890 try {
891 auto rdb = std::make_shared<RdbStoreMock>();
892 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
893 std::unordered_map<std::string, LocalInfo> localMap;
894 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>()))
895 .WillOnce(Return(0))
896 .WillOnce(Return(1))
897 .WillOnce(Return(0))
898 .WillOnce(Return(0));
899 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
900 DriveKit::DKRecordData data;
901 DriveKit::DKRecord record;
902 DriveKit::DKRecordOperResult operResult;
903 DriveKit::DKRecordId recordId = "hh";
904 std::string path = "hh";
905 DriveKit::DKRecordFieldMap prop;
906 localMap[path] = { 1111, 1111 };
907 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("hh")));
908 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
909 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
910 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
911 record.SetRecordData(data);
912 operResult.SetDKRecord(std::move(record));
913 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
914 int32_t ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
915 EXPECT_EQ(E_OK, ret);
916 ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
917 EXPECT_EQ(ret, 1);
918 localMap[path] = { 11, 1111 };
919 ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
920 EXPECT_EQ(E_OK, ret);
921 localMap[path] = { 1111, 11 };
922 ret = fileDataHandler->OnCreateRecordSuccess(entry, localMap);
923 EXPECT_EQ(E_OK, ret);
924 } catch (...) {
925 EXPECT_TRUE(false);
926 GTEST_LOG_(INFO) << " OnCreateRecordSuccess003 ERROR";
927 }
928 GTEST_LOG_(INFO) << "OnCreateRecordSuccess003 End";
929 }
930
931 /**
932 * @tc.name: OnMdirtyRecordSuccess001
933 * @tc.desc: Verify the OnMdirtyRecordSuccess function
934 * @tc.type: FUNC
935 * @tc.require: I6JPKG
936 */
937 HWTEST_F(FileDataHandlerTest, OnMdirtyRecordSuccess001, TestSize.Level1)
938 {
939 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess001 Begin";
940 try {
941 auto rdb = std::make_shared<RdbStoreMock>();
942 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
943 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(1));
944 std::unordered_map<std::string, LocalInfo> localMap;
945 DriveKit::DKRecord record;
946 DriveKit::DKRecordOperResult operResult;
947 DriveKit::DKRecordId recordId = "1";
948 operResult.SetDKRecord(std::move(record));
949 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
950 int32_t ret = fileDataHandler->OnMdirtyRecordSuccess(entry, localMap);
951 EXPECT_EQ(ret, 1);
952 } catch (...) {
953 EXPECT_TRUE(false);
954 GTEST_LOG_(INFO) << " OnMdirtyRecordSuccess001 ERROR";
955 }
956 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccesss001 End";
957 }
958
959 /**
960 * @tc.name: OnMdirtyRecordSuccess002
961 * @tc.desc: Verify the OnMdirtyRecordSuccess function
962 * @tc.type: FUNC
963 * @tc.require: I6JPKG
964 */
965 HWTEST_F(FileDataHandlerTest, OnMdirtyRecordSuccess002, TestSize.Level1)
966 {
967 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess002 Begin";
968 try {
969 auto rdb = std::make_shared<RdbStoreMock>();
970 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
971 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
972 std::unordered_map<std::string, LocalInfo> localMap;
973 DriveKit::DKRecord record;
974 DriveKit::DKRecordOperResult operResult;
975 DriveKit::DKRecordId recordId = "hh";
976 operResult.SetDKRecord(std::move(record));
977 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
978 int32_t ret = fileDataHandler->OnMdirtyRecordSuccess(entry, localMap);
979 EXPECT_EQ(E_INVAL_ARG, ret);
980 } catch (...) {
981 EXPECT_TRUE(false);
982 GTEST_LOG_(INFO) << " OnMdirtyRecordSuccess002 ERROR";
983 }
984 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess002 End";
985 }
986
987 /**
988 * @tc.name: OnMdirtyRecordSuccess003
989 * @tc.desc: Verify the OnMdirtyRecordSuccess function
990 * @tc.type: FUNC
991 * @tc.require: I6JPKG
992 */
993 HWTEST_F(FileDataHandlerTest, OnMdirtyRecordSuccess003, TestSize.Level1)
994 {
995 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess003 Begin";
996 try {
997 auto rdb = std::make_shared<RdbStoreMock>();
998 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
999 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
1000 std::unordered_map<std::string, LocalInfo> localMap;
1001 DriveKit::DKRecordData data;
1002 DriveKit::DKRecord record;
1003 DriveKit::DKRecordOperResult operResult;
1004 DriveKit::DKRecordId recordId = "hh";
1005 DriveKit::DKRecordFieldMap prop;
1006 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1007 record.SetRecordData(data);
1008 operResult.SetDKRecord(std::move(record));
1009 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
1010 int32_t ret = fileDataHandler->OnMdirtyRecordSuccess(entry, localMap);
1011 EXPECT_EQ(E_INVAL_ARG, ret);
1012 } catch (...) {
1013 EXPECT_TRUE(false);
1014 GTEST_LOG_(INFO) << " OnMdirtyRecordSuccess003 ERROR";
1015 }
1016 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess003 End";
1017 }
1018
1019 /**
1020 * @tc.name: OnMdirtyRecordSuccess004
1021 * @tc.desc: Verify the OnMdirtyRecordSuccess function
1022 * @tc.type: FUNC
1023 * @tc.require: I6JPKG
1024 */
1025 HWTEST_F(FileDataHandlerTest, OnMdirtyRecordSuccess004, TestSize.Level1)
1026 {
1027 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess004 Begin";
1028 try {
1029 auto rdb = std::make_shared<RdbStoreMock>();
1030 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1031 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1)).WillOnce(Return(1));
1032 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
1033 std::unordered_map<std::string, LocalInfo> localMap;
1034 DriveKit::DKRecordData data;
1035 DriveKit::DKRecord record;
1036 DriveKit::DKRecordOperResult operResult;
1037 DriveKit::DKRecordId recordId = "hh";
1038 DriveKit::DKRecordFieldMap prop;
1039 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
1040 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
1041 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1042 record.SetRecordData(data);
1043 operResult.SetDKRecord(std::move(record));
1044 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
1045 int32_t ret = fileDataHandler->OnMdirtyRecordSuccess(entry, localMap);
1046 EXPECT_EQ(1, ret);
1047 } catch (...) {
1048 EXPECT_TRUE(false);
1049 GTEST_LOG_(INFO) << " OnMdirtyRecordSuccess004 ERROR";
1050 }
1051 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess004 End";
1052 }
1053
1054 /**
1055 * @tc.name: OnMdirtyRecordSuccess005
1056 * @tc.desc: Verify the OnMdirtyRecordSuccess function
1057 * @tc.type: FUNC
1058 * @tc.require: I6JPKG
1059 */
1060 HWTEST_F(FileDataHandlerTest, OnMdirtyRecordSuccess005, TestSize.Level1)
1061 {
1062 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess005 Begin";
1063 try {
1064 auto rdb = std::make_shared<RdbStoreMock>();
1065 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1066 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1)).WillOnce(Return(0));
1067 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
1068 std::unordered_map<std::string, LocalInfo> localMap;
1069 DriveKit::DKRecordData data;
1070 DriveKit::DKRecord record;
1071 DriveKit::DKRecordOperResult operResult;
1072 DriveKit::DKRecordId recordId = "hh";
1073 DriveKit::DKRecordFieldMap prop;
1074 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
1075 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1111)));
1076 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1077 record.SetRecordData(data);
1078 operResult.SetDKRecord(std::move(record));
1079 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
1080 int32_t ret = fileDataHandler->OnMdirtyRecordSuccess(entry, localMap);
1081 EXPECT_EQ(E_OK, ret);
1082 } catch (...) {
1083 EXPECT_TRUE(false);
1084 GTEST_LOG_(INFO) << " OnMdirtyRecordSuccess005 ERROR";
1085 }
1086 GTEST_LOG_(INFO) << "OnMdirtyRecordSuccess005 End";
1087 }
1088
1089 /**
1090 * @tc.name: OnDeleteRecordSuccess001
1091 * @tc.desc: Verify the OnDeleteRecordSuccess function
1092 * @tc.type: FUNC
1093 * @tc.require: I6JPKG
1094 */
1095 HWTEST_F(FileDataHandlerTest, OnDeleteRecordSuccess001, TestSize.Level1)
1096 {
1097 GTEST_LOG_(INFO) << "OnDeleteRecordSuccess001 Begin";
1098 try {
1099 auto rdb = std::make_shared<RdbStoreMock>();
1100 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1101 EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillOnce(Return(0)).WillOnce(Return(1));
1102 DriveKit::DKRecordOperResult operResult;
1103 DriveKit::DKRecordId recordId = "1";
1104 std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> entry(recordId, operResult);
1105 int32_t ret = fileDataHandler->OnDeleteRecordSuccess(entry);
1106 EXPECT_EQ(0, ret);
1107 ret = fileDataHandler->OnDeleteRecordSuccess(entry);
1108 EXPECT_EQ(1, ret);
1109 } catch (...) {
1110 EXPECT_TRUE(false);
1111 GTEST_LOG_(INFO) << "OnDeleteRecordSuccess001 ERROR";
1112 }
1113 GTEST_LOG_(INFO) << "OnDeleteRecordSuccess001 End";
1114 }
1115
1116 /**
1117 * @tc.name: OnModifyFdirtyRecords001
1118 * @tc.desc: Verify the OnModifyFdirtyRecords function
1119 * @tc.type: FUNC
1120 * @tc.require: I6JPKG
1121 */
1122 HWTEST_F(FileDataHandlerTest, OnModifyFdirtyRecords001, TestSize.Level1)
1123 {
1124 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords001 Begin";
1125 try {
1126 auto rdb = std::make_shared<RdbStoreMock>();
1127 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1128 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1129
1130 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1131 int32_t ret = fileDataHandler->OnModifyFdirtyRecords(myMap);
1132 EXPECT_EQ(E_RDB, ret);
1133 } catch (...) {
1134 EXPECT_TRUE(false);
1135 GTEST_LOG_(INFO) << " OnModifyFdirtyRecords001 ERROR";
1136 }
1137 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords001 End";
1138 }
1139
1140 /**
1141 * @tc.name: OnModifyFdirtyRecords002
1142 * @tc.desc: Verify the OnModifyFdirtyRecords function
1143 * @tc.type: FUNC
1144 * @tc.require: I6JPKG
1145 */
1146 HWTEST_F(FileDataHandlerTest, OnModifyFdirtyRecords002, TestSize.Level1)
1147 {
1148 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords002 Begin";
1149 try {
1150 auto rdb = std::make_shared<RdbStoreMock>();
1151 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1152 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1153 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1154 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1155 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1156 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
1157
1158 DriveKit::DKRecord record;
1159 DriveKit::DKRecordData data;
1160 DriveKit::DKRecordFieldMap prop;
1161 DriveKit::DKRecordId recordId = "hh";
1162 DriveKit::DKRecordOperResult operResult;
1163 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1164
1165 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("filePath")));
1166 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1167 record.SetRecordData(data);
1168 operResult.SetDKRecord(std::move(record));
1169 myMap.insert(std::make_pair(recordId, operResult));
1170 int32_t ret = fileDataHandler->OnModifyFdirtyRecords(myMap);
1171 EXPECT_EQ(E_OK, ret);
1172 } catch (...) {
1173 EXPECT_TRUE(false);
1174 GTEST_LOG_(INFO) << " OnModifyFdirtyRecords002 ERROR";
1175 }
1176 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords002 End";
1177 }
1178
1179 /**
1180 * @tc.name: OnModifyFdirtyRecords003
1181 * @tc.desc: Verify the OnModifyFdirtyRecords function
1182 * @tc.type: FUNC
1183 * @tc.require: I6JPKG
1184 */
1185 HWTEST_F(FileDataHandlerTest, OnModifyFdirtyRecords003, TestSize.Level1)
1186 {
1187 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords003 Begin";
1188 try {
1189 auto rdb = std::make_shared<RdbStoreMock>();
1190 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1191 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1192 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1193 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1194 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1195 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(0));
1196
1197 DriveKit::DKError error_;
1198 DriveKit::DKRecord record;
1199 DriveKit::DKRecordData data;
1200 DriveKit::DKRecordFieldMap prop;
1201 DriveKit::DKRecordId recordId = "hh";
1202 DriveKit::DKRecordOperResult operResult;
1203 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1204
1205 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("filePath")));
1206 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1207 record.SetRecordData(data);
1208 operResult.SetDKRecord(std::move(record));
1209 error_.isLocalError = false;
1210 operResult.SetDKError(error_);
1211 myMap.insert(std::make_pair(recordId, operResult));
1212 int32_t ret = fileDataHandler->OnModifyFdirtyRecords(myMap);
1213 EXPECT_EQ(E_OK, ret);
1214 } catch (...) {
1215 EXPECT_TRUE(false);
1216 GTEST_LOG_(INFO) << " OnModifyFdirtyRecords003 ERROR";
1217 }
1218 GTEST_LOG_(INFO) << "OnModifyFdirtyRecords003 End";
1219 }
1220
1221 /**
1222 * @tc.name: OnDeleteRecords001
1223 * @tc.desc: Verify the OnDeleteRecords function
1224 * @tc.type: FUNC
1225 * @tc.require: I6JPKG
1226 */
1227 HWTEST_F(FileDataHandlerTest, OnDeleteRecords001, TestSize.Level1)
1228 {
1229 GTEST_LOG_(INFO) << "OnDeleteRecords001 Begin";
1230 try {
1231 auto rdb = std::make_shared<RdbStoreMock>();
1232 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1233 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1234 EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillOnce(Return(0));
1235 DriveKit::DKRecordData data;
1236 DriveKit::DKRecord record;
1237 DriveKit::DKRecordOperResult operResult;
1238 DriveKit::DKRecordId recordId = "hh";
1239 record.SetRecordData(data);
1240 operResult.SetDKRecord(std::move(record));
1241 DriveKit::DKError error_;
1242 error_.isLocalError = false;
1243 error_.SetServerError(static_cast<int32_t>(DriveKit::DKServerErrorCode::UID_EMPTY));
1244 DriveKit::DKErrorDetail errorDetail;
1245 errorDetail.detailCode = static_cast<int32_t>(DriveKit::DKDetailErrorCode::PARAM_INVALID);
1246 error_.errorDetails.push_back(errorDetail);
1247 operResult.SetDKError(error_);
1248 myMap.insert(std::make_pair(recordId, operResult));
1249 int32_t ret = fileDataHandler->OnDeleteRecords(myMap);
1250 EXPECT_EQ(E_STOP, ret);
1251
1252 myMap.clear();
1253 error_.isServerError = false;
1254 operResult.SetDKError(error_);
1255 myMap.insert(std::make_pair(recordId, operResult));
1256 ret = fileDataHandler->OnDeleteRecords(myMap);
1257 EXPECT_EQ(E_OK, ret);
1258 } catch (...) {
1259 EXPECT_TRUE(false);
1260 GTEST_LOG_(INFO) << " OnDeleteRecords001 ERROR";
1261 }
1262 GTEST_LOG_(INFO) << "OnDeleteRecords001 End";
1263 }
1264
1265 /**
1266 * @tc.name: OnCreateRecords001
1267 * @tc.desc: Verify the OnCreateRecords function
1268 * @tc.type: FUNC
1269 * @tc.require: I6JPKG
1270 */
1271 HWTEST_F(FileDataHandlerTest, OnCreateRecords001, TestSize.Level1)
1272 {
1273 GTEST_LOG_(INFO) << "OnCreateRecords001 Begin";
1274 try {
1275 auto rdb = std::make_shared<RdbStoreMock>();
1276 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1277 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1278
1279 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1280 int32_t ret = fileDataHandler->OnCreateRecords(myMap);
1281 EXPECT_EQ(E_RDB, ret);
1282 } catch (...) {
1283 EXPECT_TRUE(false);
1284 GTEST_LOG_(INFO) << " OnCreateRecords001 ERROR";
1285 }
1286 GTEST_LOG_(INFO) << "OnCreateRecords001 End";
1287 }
1288
1289 /**
1290 * @tc.name: OnCreateRecords002
1291 * @tc.desc: Verify the OnCreateRecords function
1292 * @tc.type: FUNC
1293 * @tc.require: I6JPKG
1294 */
1295 HWTEST_F(FileDataHandlerTest, OnCreateRecords002, TestSize.Level1)
1296 {
1297 GTEST_LOG_(INFO) << "OnCreateRecords002 Begin";
1298 try {
1299 auto rdb = std::make_shared<RdbStoreMock>();
1300 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1301 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1302 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1303 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1304 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1305
1306 DriveKit::DKRecord record;
1307 DriveKit::DKRecordData data;
1308 DriveKit::DKRecordFieldMap prop;
1309 DriveKit::DKRecordId recordId = "hh";
1310 DriveKit::DKRecordOperResult operResult;
1311 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1312
1313 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("filePath")));
1314 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1315 record.SetRecordData(data);
1316 operResult.SetDKRecord(std::move(record));
1317 myMap.insert(std::make_pair(recordId, operResult));
1318 int32_t ret = fileDataHandler->OnCreateRecords(myMap);
1319 EXPECT_EQ(E_OK, ret);
1320 } catch (...) {
1321 EXPECT_TRUE(false);
1322 GTEST_LOG_(INFO) << " OnCreateRecords002 ERROR";
1323 }
1324 GTEST_LOG_(INFO) << "OnCreateRecords002 End";
1325 }
1326
1327 /**
1328 * @tc.name: OnCreateRecords003
1329 * @tc.desc: Verify the OnCreateRecords function
1330 * @tc.type: FUNC
1331 * @tc.require: I6JPKG
1332 */
1333 HWTEST_F(FileDataHandlerTest, OnCreateRecords003, TestSize.Level1)
1334 {
1335 GTEST_LOG_(INFO) << "OnCreateRecords003 Begin";
1336 try {
1337 auto rdb = std::make_shared<RdbStoreMock>();
1338 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1339 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1340 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1341 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1));
1342 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1343
1344 DriveKit::DKError error_;
1345 DriveKit::DKRecord record;
1346 DriveKit::DKRecordData data;
1347 DriveKit::DKRecordFieldMap prop;
1348 DriveKit::DKRecordId recordId = "hh";
1349 DriveKit::DKRecordOperResult operResult;
1350 std::map<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> myMap;
1351
1352 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("filePath")));
1353 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop));
1354 record.SetRecordData(data);
1355 operResult.SetDKRecord(std::move(record));
1356 error_.isLocalError = false;
1357 operResult.SetDKError(error_);
1358 myMap.insert(std::make_pair(recordId, operResult));
1359 int32_t ret = fileDataHandler->OnCreateRecords(myMap);
1360 EXPECT_EQ(E_OK, ret);
1361 } catch (...) {
1362 EXPECT_TRUE(false);
1363 GTEST_LOG_(INFO) << " OnCreateRecords003 ERROR";
1364 }
1365 GTEST_LOG_(INFO) << "OnCreateRecords003 End";
1366 }
1367
1368 /**
1369 * @tc.name: OnFetchRecords001
1370 * @tc.desc: Verify the OnFetchRecords function
1371 * @tc.type: FUNC
1372 * @tc.require: I6JPKG
1373 */
1374 HWTEST_F(FileDataHandlerTest, OnFetchRecords001, TestSize.Level1)
1375 {
1376 GTEST_LOG_(INFO) << "OnFetchRecords001 Begin";
1377 try {
1378 auto rdb = std::make_shared<RdbStoreMock>();
1379 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1380 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1381
1382 shared_ptr<vector<DKRecord>> records = make_shared<vector<DKRecord>>();
1383 OnFetchParams onFetchParams;
1384 int32_t ret = fileDataHandler->OnFetchRecords(records, onFetchParams);
1385 EXPECT_EQ(E_RDB, ret);
1386 } catch (...) {
1387 EXPECT_TRUE(false);
1388 GTEST_LOG_(INFO) << "OnFetchRecords001 ERROR";
1389 }
1390
1391 GTEST_LOG_(INFO) << "OnFetchRecords001 End";
1392 }
1393
1394 /**
1395 * @tc.name: OnFetchRecords002
1396 * @tc.desc: Verify the OnFetchRecords function
1397 * @tc.type: FUNC
1398 * @tc.require: I6JPKG
1399 */
1400 HWTEST_F(FileDataHandlerTest, OnFetchRecords002, TestSize.Level1)
1401 {
1402 GTEST_LOG_(INFO) << "OnFetchRecords002 Begin";
1403 try {
1404 const int rowCount = 0;
1405 auto rdb = std::make_shared<RdbStoreMock>();
1406 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1407 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1408 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1409 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1410 EXPECT_CALL(*rdb, Query(_, _))
1411 .WillOnce(Return(ByMove(std::move(rset))))
1412 .WillOnce(Return(ByMove(nullptr)))
1413 .WillOnce(Return(ByMove(nullptr)));
1414
1415 shared_ptr<vector<DKRecord>> records = make_shared<vector<DKRecord>>();
1416 OnFetchParams onFetchParams;
1417 int32_t ret = fileDataHandler->OnFetchRecords(records, onFetchParams);
1418 EXPECT_EQ(E_OK, ret);
1419 } catch (...) {
1420 EXPECT_TRUE(false);
1421 GTEST_LOG_(INFO) << "OnFetchRecords002 ERROR";
1422 }
1423
1424 GTEST_LOG_(INFO) << "OnFetchRecords002 End";
1425 }
1426
1427 /**
1428 * @tc.name: OnFetchRecords003
1429 * @tc.desc: Verify the OnFetchRecords function
1430 * @tc.type: FUNC
1431 * @tc.require: I6JPKG
1432 */
1433 HWTEST_F(FileDataHandlerTest, OnFetchRecords003, TestSize.Level1)
1434 {
1435 GTEST_LOG_(INFO) << "OnFetchRecords003 Begin";
1436 try {
1437 int rowCount = 1;
1438 auto rdb = std::make_shared<RdbStoreMock>();
1439 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1440
1441 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1442 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0));
1443 EXPECT_CALL(*rset, GoToRow(_)).WillOnce(Return(0));
1444 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
1445 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
1446 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1447 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1448 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0)));
1449 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
1450 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))).WillRepeatedly(Return(nullptr));
1451 DKRecord record;
1452 record.SetRecordId("1");
1453 shared_ptr<vector<DKRecord>> records = make_shared<vector<DKRecord>>();
1454 records->push_back(record);
1455 OnFetchParams onFetchParams;
1456 int32_t ret = fileDataHandler->OnFetchRecords(records, onFetchParams);
1457 EXPECT_EQ(E_OK, ret);
1458 } catch (...) {
1459 EXPECT_TRUE(false);
1460 GTEST_LOG_(INFO) << "OnFetchRecords003 ERROR";
1461 }
1462
1463 GTEST_LOG_(INFO) << "OnFetchRecords003 End";
1464 }
1465
1466 /**
1467 * @tc.name: PullRecordUpdate001
1468 * @tc.desc: Verify the PullRecordUpdate function
1469 * @tc.type: FUNC
1470 * @tc.require: I6JPKG
1471 */
1472 HWTEST_F(FileDataHandlerTest, PullRecordUpdate001, TestSize.Level1)
1473 {
1474 GTEST_LOG_(INFO) << "PullRecordUpdate001 Begin";
1475 try {
1476 auto rdb = std::make_shared<RdbStoreMock>();
1477 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1478 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1479 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1480 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
1481 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
1482 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
1483
1484 DKRecord record;
1485 OnFetchParams onFetchParams;
1486 int32_t ret = fileDataHandler->PullRecordUpdate(record, *rset, onFetchParams);
1487 EXPECT_NE(E_RDB, ret);
1488 } catch (...) {
1489 EXPECT_TRUE(false);
1490 GTEST_LOG_(INFO) << "PullRecordUpdate001 ERROR";
1491 }
1492
1493 GTEST_LOG_(INFO) << "PullRecordUpdate001 End";
1494 }
1495
1496 /**
1497 * @tc.name: PullRecordDelete001
1498 * @tc.desc: Verify the PullRecordDelete function
1499 * @tc.type: FUNC
1500 * @tc.require: I6JPKG
1501 */
1502 HWTEST_F(FileDataHandlerTest, PullRecordDelete001, TestSize.Level1)
1503 {
1504 GTEST_LOG_(INFO) << "PullRecordDelete001 Begin";
1505 try {
1506 auto rdb = std::make_shared<RdbStoreMock>();
1507 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1508 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1509 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1510 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
1511 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
1512 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1513
1514 DKRecord record;
1515 int32_t ret = fileDataHandler->PullRecordDelete(record, *rset);
1516 EXPECT_NE(E_RDB, ret);
1517 } catch (...) {
1518 EXPECT_TRUE(false);
1519 GTEST_LOG_(INFO) << "PullRecordDelete001 ERROR";
1520 }
1521
1522 GTEST_LOG_(INFO) << "PullRecordDelete001 End";
1523 }
1524
1525 /**
1526 * @tc.name: ClearCloudInfo001
1527 * @tc.desc: Verify the ClearCloudInfo function
1528 * @tc.type: FUNC
1529 * @tc.require: I6JPKG
1530 */
1531 HWTEST_F(FileDataHandlerTest, ClearCloudInfo001, TestSize.Level1)
1532 {
1533 GTEST_LOG_(INFO) << "ClearCloudInfo001 Begin";
1534 try {
1535 auto rdb = std::make_shared<RdbStoreMock>();
1536 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1537 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
1538
1539 std::string cloudId;
1540 int32_t ret = fileDataHandler->ClearCloudInfo(cloudId);
1541 EXPECT_NE(E_OK, ret);
1542 } catch (...) {
1543 EXPECT_TRUE(false);
1544 GTEST_LOG_(INFO) << " ClearCloudInfo001 ERROR";
1545 }
1546
1547 GTEST_LOG_(INFO) << "ClearCloudInfo001 End";
1548 }
1549
1550 /**
1551 * @tc.name: ClearCloudInfo002
1552 * @tc.desc: Verify the ClearCloudInfo function
1553 * @tc.type: FUNC
1554 * @tc.require: I6JPKG
1555 */
1556 HWTEST_F(FileDataHandlerTest, ClearCloudInfo002, TestSize.Level1)
1557 {
1558 GTEST_LOG_(INFO) << "ClearCloudInfo002 Begin";
1559 try {
1560 auto rdb = std::make_shared<RdbStoreMock>();
1561 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1562 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
1563
1564 std::string cloudId;
1565 int32_t ret = fileDataHandler->ClearCloudInfo(cloudId);
1566 EXPECT_EQ(E_OK, ret);
1567 } catch (...) {
1568 EXPECT_TRUE(false);
1569 GTEST_LOG_(INFO) << " ClearCloudInfo002 ERROR";
1570 }
1571
1572 GTEST_LOG_(INFO) << "ClearCloudInfo002 End";
1573 }
1574
1575 /**
1576 * @tc.name: DeleteDentryFile001
1577 * @tc.desc: Verify the DeleteDentryFile function
1578 * @tc.type: FUNC
1579 * @tc.require: I6JPKG
1580 */
1581 HWTEST_F(FileDataHandlerTest, DeleteDentryFile001, TestSize.Level1)
1582 {
1583 GTEST_LOG_(INFO) << "DeleteDentryFile001 Begin";
1584 try {
1585 auto rdb = std::make_shared<RdbStoreMock>();
1586 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1587 int32_t ret = fileDataHandler->DeleteDentryFile();
1588 EXPECT_EQ(E_OK, ret);
1589 } catch (...) {
1590 EXPECT_TRUE(false);
1591 GTEST_LOG_(INFO) << " DeleteDentryFile001 ERROR";
1592 }
1593
1594 GTEST_LOG_(INFO) << "DeleteDentryFile001 End";
1595 }
1596
1597 /**
1598 * @tc.name: CleanNotDirtyData001
1599 * @tc.desc: Verify the CleanNotDirtyData function
1600 * @tc.type: FUNC
1601 * @tc.require: I6JPKG
1602 */
1603 HWTEST_F(FileDataHandlerTest, CleanNotDirtyData001, TestSize.Level1)
1604 {
1605 GTEST_LOG_(INFO) << "CleanNotDirtyData001 Begin";
1606 try {
1607 auto rdb = std::make_shared<RdbStoreMock>();
1608 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1609 EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillRepeatedly(Return(0));
1610 int32_t ret = fileDataHandler->CleanNotDirtyData();
1611 EXPECT_TRUE(E_OK == ret || E_RDB == ret);
1612 } catch (...) {
1613 EXPECT_TRUE(false);
1614 GTEST_LOG_(INFO) << " CleanNotDirtyData001 ERROR";
1615 }
1616
1617 GTEST_LOG_(INFO) << "CleanNotDirtyData001 End";
1618 }
1619
1620 /**
1621 * @tc.name: CleanPureCloudRecord001
1622 * @tc.desc: Verify the CleanPureCloudRecord function
1623 * @tc.type: FUNC
1624 * @tc.require: I6JPKG
1625 */
1626 HWTEST_F(FileDataHandlerTest, CleanPureCloudRecord001, TestSize.Level1)
1627 {
1628 GTEST_LOG_(INFO) << "CleanPureCloudRecord001 Begin";
1629 try {
1630 auto rdb = std::make_shared<RdbStoreMock>();
1631 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1632 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1633 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1634
1635 string filePath = "/test/pareantPath/thumbPpath";
1636 int32_t ret = fileDataHandler->CleanPureCloudRecord();
1637 EXPECT_TRUE(E_OK == ret || E_RDB == ret);
1638 } catch (...) {
1639 EXPECT_TRUE(false);
1640 GTEST_LOG_(INFO) << " CleanPureCloudRecord001 ERROR";
1641 }
1642
1643 GTEST_LOG_(INFO) << "CleanPureCloudRecord001 End";
1644 }
1645
1646 /**
1647 * @tc.name: CleanNotPureCloudRecord001
1648 * @tc.desc: Verify the CleanNotPureCloudRecord function
1649 * @tc.type: FUNC
1650 * @tc.require: I6JPKG
1651 */
1652 HWTEST_F(FileDataHandlerTest, CleanNotPureCloudRecord001, TestSize.Level1)
1653 {
1654 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord001 Begin";
1655 try {
1656 auto rdb = std::make_shared<RdbStoreMock>();
1657 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1658 string filePath = "/test/pareantPath/thumbPpath";
1659 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1660 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1661 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(1));
1662
1663 int32_t ret = fileDataHandler->CleanNotPureCloudRecord(CleanAction::RETAIN_DATA);
1664 EXPECT_TRUE(E_OK == ret || E_RDB == ret);
1665 } catch (...) {
1666 EXPECT_TRUE(false);
1667 GTEST_LOG_(INFO) << " CleanNotPureCloudRecord001 ERROR";
1668 }
1669
1670 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord001 End";
1671 }
1672
1673 /**
1674 * @tc.name: CleanNotPureCloudRecord002
1675 * @tc.desc: Verify the CleanNotPureCloudRecord function
1676 * @tc.type: FUNC
1677 * @tc.require: I6JPKG
1678 */
1679 HWTEST_F(FileDataHandlerTest, CleanNotPureCloudRecord002, TestSize.Level1)
1680 {
1681 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord002 Begin";
1682 try {
1683 auto rdb = std::make_shared<RdbStoreMock>();
1684 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1685 string filePath = "/test/pareantPath/thumbPpath";
1686 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1687 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1688 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1689
1690 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
1691
1692 int32_t ret = fileDataHandler->CleanNotPureCloudRecord(CleanAction::RETAIN_DATA);
1693 EXPECT_NE(E_OK, ret);
1694 } catch (...) {
1695 EXPECT_TRUE(false);
1696 GTEST_LOG_(INFO) << " CleanNotPureCloudRecord002 ERROR";
1697 }
1698
1699 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord002 End";
1700 }
1701
1702 /**
1703 * @tc.name: CleanNotPureCloudRecord003
1704 * @tc.desc: Verify the CleanNotPureCloudRecord function
1705 * @tc.type: FUNC
1706 * @tc.require: I6JPKG
1707 */
1708 HWTEST_F(FileDataHandlerTest, CleanNotPureCloudRecord003, TestSize.Level1)
1709 {
1710 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord003 Begin";
1711 try {
1712 auto rdb = std::make_shared<RdbStoreMock>();
1713 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1714 string filePath = "/test/pareantPath/thumbPpath";
1715 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1716 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1717 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1718
1719 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0));
1720
1721 int32_t ret = fileDataHandler->CleanNotPureCloudRecord(CleanAction::RETAIN_DATA);
1722 EXPECT_EQ(E_OK, ret);
1723 } catch (...) {
1724 EXPECT_TRUE(false);
1725 GTEST_LOG_(INFO) << " CleanNotPureCloudRecord003 ERROR";
1726 }
1727
1728 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord003 End";
1729 }
1730
1731 /**
1732 * @tc.name: CleanNotPureCloudRecord004
1733 * @tc.desc: Verify the CleanNotPureCloudRecord function
1734 * @tc.type: FUNC
1735 * @tc.require: I6JPKG
1736 */
1737 HWTEST_F(FileDataHandlerTest, CleanNotPureCloudRecord004, TestSize.Level1)
1738 {
1739 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord004 Begin";
1740 try {
1741 auto rdb = std::make_shared<RdbStoreMock>();
1742 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1743 string filePath = "/test/pareantPath/thumbPpath";
1744 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1745 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1746 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1747 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(1));
1748 EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillRepeatedly(Return(0));
1749
1750 int32_t ret = fileDataHandler->CleanNotPureCloudRecord(CleanAction::RETAIN_DATA);
1751 EXPECT_EQ(E_OK, ret);
1752 } catch (...) {
1753 EXPECT_TRUE(false);
1754 GTEST_LOG_(INFO) << " CleanNotPureCloudRecord004 ERROR";
1755 }
1756
1757 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord004 End";
1758 }
1759
1760 /**
1761 * @tc.name: CleanNotPureCloudRecord005
1762 * @tc.desc: Verify the CleanNotPureCloudRecord function
1763 * @tc.type: FUNC
1764 * @tc.require: I6JPKG
1765 */
1766 HWTEST_F(FileDataHandlerTest, CleanNotPureCloudRecord005, TestSize.Level1)
1767 {
1768 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord005 Begin";
1769 try {
1770 auto rdb = std::make_shared<RdbStoreMock>();
1771 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1772 string filePath = "/test/pareantPath/thumbPpath";
1773 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>();
1774 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1775 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1776
1777 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(2), Return(0)));
1778
1779 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1));
1780
1781 int32_t ret = fileDataHandler->CleanNotPureCloudRecord(CleanAction::RETAIN_DATA);
1782 EXPECT_NE(E_OK, ret);
1783 } catch (...) {
1784 EXPECT_TRUE(false);
1785 GTEST_LOG_(INFO) << " CleanNotPureCloudRecord005 ERROR";
1786 }
1787
1788 GTEST_LOG_(INFO) << "CleanNotPureCloudRecord005 End";
1789 }
1790
1791 /**
1792 * @tc.name: AppendToDownload
1793 * @tc.desc: Verify the AppendToDownload function
1794 * @tc.type: FUNC
1795 * @tc.require: I6JPKG
1796 */
1797 HWTEST_F(FileDataHandlerTest, AppendToDownload, TestSize.Level1)
1798 {
1799 GTEST_LOG_(INFO) << "AppendToDownload Begin";
1800 try {
1801 auto rdb = std::make_shared<RdbStoreMock>();
1802 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1803 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1804 DKRecord record;
1805 std::string fieldKey;
1806 std::vector<DKDownloadAsset> assetsToDownload;
1807 fileDataHandler->AppendToDownload(record, fieldKey, assetsToDownload);
1808 EXPECT_TRUE(true);
1809 DKFieldValue fieldValue = 1;
1810 DKRecordField recordField(fieldValue);
1811 record.fields_.insert(std::pair<DKFieldKey, DKRecordField>("properties", recordField));
1812 fileDataHandler->AppendToDownload(record, fieldKey, assetsToDownload);
1813 EXPECT_TRUE(true);
1814 } catch (...) {
1815 EXPECT_TRUE(false);
1816 GTEST_LOG_(INFO) << " AppendToDownload ERROR";
1817 }
1818
1819 GTEST_LOG_(INFO) << "AppendToDownload End";
1820 }
1821
1822 /**
1823 * @tc.name: GetAssetsToDownload001
1824 * @tc.desc: Verify the GetAssetsToDownload function
1825 * @tc.type: FUNC
1826 * @tc.require: issueI7UYAL
1827 */
1828 HWTEST_F(FileDataHandlerTest, GetAssetsToDownload001, TestSize.Level1)
1829 {
1830 GTEST_LOG_(INFO) << "GetAssetsToDownload001 Begin";
1831 try {
1832 auto rdb = std::make_shared<RdbStoreMock>();
1833 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1834 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1835 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
1836 int32_t ret = fileDataHandler->GetAssetsToDownload(outAssetsToDownload);
1837 EXPECT_EQ(ret, E_RDB);
1838 } catch (...) {
1839 EXPECT_TRUE(false);
1840 GTEST_LOG_(INFO) << " GetAssetsToDownload001 ERROR";
1841 }
1842
1843 GTEST_LOG_(INFO) << "GetAssetsToDownload001 End";
1844 }
1845
1846 /**
1847 * @tc.name: GetAssetsToDownload002
1848 * @tc.desc: Verify the GetAssetsToDownload function
1849 * @tc.type: FUNC
1850 * @tc.require: issueI7UYAL
1851 */
1852 HWTEST_F(FileDataHandlerTest, GetAssetsToDownload002, TestSize.Level1)
1853 {
1854 GTEST_LOG_(INFO) << "GetAssetsToDownload002 Begin";
1855 try {
1856 auto rdb = std::make_shared<RdbStoreMock>();
1857 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1858 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1859
1860 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(1));
1861 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1862 vector<DriveKit::DKDownloadAsset> outAssetsToDownload;
1863 int32_t ret = fileDataHandler->GetAssetsToDownload(outAssetsToDownload);
1864 EXPECT_EQ(ret, E_OK);
1865 } catch (...) {
1866 EXPECT_TRUE(false);
1867 GTEST_LOG_(INFO) << " GetAssetsToDownload002 ERROR";
1868 }
1869
1870 GTEST_LOG_(INFO) << "GetAssetsToDownload002 End";
1871 }
1872
1873 /**
1874 * @tc.name: QueryLocalByCloudId
1875 * @tc.desc: Verify the QueryLocalByCloudId function
1876 * @tc.type: FUNC
1877 * @tc.require: issueI7UYAL
1878 */
1879 HWTEST_F(FileDataHandlerTest, QueryLocalByCloudId, TestSize.Level1)
1880 {
1881 GTEST_LOG_(INFO) << "QueryLocalByCloudId Begin";
1882 try {
1883 const string recordId = "1";
1884 std::vector<std::string> recordIds;
1885 recordIds.push_back(recordId);
1886 auto rdb = std::make_shared<RdbStoreMock>();
1887 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1888 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1889 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillOnce(Return(0));
1890 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
1891 auto [db, mp] = fileDataHandler->QueryLocalByCloudId(recordIds);
1892 EXPECT_EQ(db, NULL);
1893
1894 const int count = 0;
1895 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(count), Return(0)));
1896 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1897 auto [ptr, ret] = fileDataHandler->QueryLocalByCloudId(recordIds);
1898 EXPECT_EQ(static_cast<int>(ret.size()), E_OK);
1899 } catch (...) {
1900 EXPECT_TRUE(false);
1901 GTEST_LOG_(INFO) << " QueryLocalByCloudId ERROR";
1902 }
1903
1904 GTEST_LOG_(INFO) << "QueryLocalByCloudId End";
1905 }
1906
1907 /**
1908 * @tc.name: GetCreatedRecords001
1909 * @tc.desc: Verify the GetCreatedRecords001 function
1910 * @tc.type: FUNC
1911 * @tc.require: I6JPKG
1912 */
1913 HWTEST_F(FileDataHandlerTest, GetCreatedRecords001, TestSize.Level1)
1914 {
1915 GTEST_LOG_(INFO) << "GetCreatedRecords001 Begin";
1916 try {
1917 auto rdb = std::make_shared<RdbStoreMock>();
1918 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1919 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1920 std::vector<DKRecord> records;
1921 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(Return(1));
1922 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1923 int32_t ret = fileDataHandler->GetCreatedRecords(records);
1924 EXPECT_EQ(E_RDB, ret);
1925 } catch (...) {
1926 EXPECT_TRUE(false);
1927 GTEST_LOG_(INFO) << " GetCreatedRecords001 ERROR";
1928 }
1929
1930 GTEST_LOG_(INFO) << "GetCreatedRecords001 End";
1931 }
1932
1933 /**
1934 * @tc.name: GetCreatedRecords002
1935 * @tc.desc: Verify the GetCreatedRecords002 function
1936 * @tc.type: FUNC
1937 * @tc.require: I6JPKG
1938 */
1939 HWTEST_F(FileDataHandlerTest, GetCreatedRecords002, TestSize.Level1)
1940 {
1941 GTEST_LOG_(INFO) << "GetCreatedRecords002 Begin";
1942 try {
1943 const int rowCount = 3;
1944 auto rdb = std::make_shared<RdbStoreMock>();
1945 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1946 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1947 std::vector<DKRecord> records;
1948 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
1949 EXPECT_CALL(*rset, GoToNextRow())
1950 .Times(rowCount)
1951 .WillOnce(Return(0))
1952 .WillOnce(Return(0))
1953 .WillRepeatedly(Return(1));
1954 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
1955 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
1956 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
1957 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
1958 EXPECT_CALL(*rdb, Query(_, _))
1959 .WillOnce(Return(ByMove(std::move(rset))))
1960 .WillOnce(Return(nullptr));
1961 int32_t ret = fileDataHandler->GetCreatedRecords(records);
1962 EXPECT_EQ(E_RDB, ret);
1963 } catch (...) {
1964 EXPECT_TRUE(false);
1965 GTEST_LOG_(INFO) << " GetCreatedRecords002 ERROR";
1966 }
1967
1968 GTEST_LOG_(INFO) << "GetCreatedRecords002 End";
1969 }
1970
1971 /**
1972 * @tc.name: GetDeletedRecords001
1973 * @tc.desc: Verify the GetDeletedRecords001 function
1974 * @tc.type: FUNC
1975 * @tc.require: I6JPKG
1976 */
1977 HWTEST_F(FileDataHandlerTest, GetDeletedRecords001, TestSize.Level1)
1978 {
1979 GTEST_LOG_(INFO) << "GetDeletedRecords001 Begin";
1980 try {
1981 auto rdb = std::make_shared<RdbStoreMock>();
1982 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
1983 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
1984 std::vector<DKRecord> records;
1985 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(Return(1));
1986 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
1987 int32_t ret = fileDataHandler->GetDeletedRecords(records);
1988 EXPECT_EQ(E_RDB, ret);
1989 } catch (...) {
1990 EXPECT_TRUE(false);
1991 GTEST_LOG_(INFO) << " GetDeletedRecords001 ERROR";
1992 }
1993
1994 GTEST_LOG_(INFO) << "GetDeletedRecords001 End";
1995 }
1996
1997 /**
1998 * @tc.name: GetDeletedRecords002
1999 * @tc.desc: Verify the GetDeletedRecords002 function
2000 * @tc.type: FUNC
2001 * @tc.require: I6JPKG
2002 */
2003 HWTEST_F(FileDataHandlerTest, GetDeletedRecords002, TestSize.Level1)
2004 {
2005 GTEST_LOG_(INFO) << "GetDeletedRecords002 Begin";
2006 try {
2007 const int rowCount = 3;
2008 auto rdb = std::make_shared<RdbStoreMock>();
2009 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2010 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
2011 std::vector<DKRecord> records;
2012 EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(0)));
2013 EXPECT_CALL(*rset, GoToNextRow())
2014 .Times(rowCount)
2015 .WillOnce(Return(0))
2016 .WillOnce(Return(0))
2017 .WillRepeatedly(Return(1));
2018 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0));
2019 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0));
2020 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0));
2021 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0));
2022 EXPECT_CALL(*rset, GetDouble(_, _)).WillRepeatedly(Return(0));
2023 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
2024 int32_t ret = fileDataHandler->GetDeletedRecords(records);
2025 EXPECT_EQ(E_OK, ret);
2026 } catch (...) {
2027 EXPECT_TRUE(false);
2028 GTEST_LOG_(INFO) << " GetDeletedRecords002 ERROR";
2029 }
2030
2031 GTEST_LOG_(INFO) << "GetDeletedRecords002 End";
2032 }
2033
2034 /**
2035 * @tc.name: GetMetaModifiedRecords001
2036 * @tc.desc: Verify the GetMetaModifiedRecords001 function
2037 * @tc.type: FUNC
2038 * @tc.require: I6JPKG
2039 */
2040 HWTEST_F(FileDataHandlerTest, GetMetaModifiedRecords001, TestSize.Level1)
2041 {
2042 GTEST_LOG_(INFO) << "GetMetaModifiedRecords001 Begin";
2043 try {
2044 auto rdb = std::make_shared<RdbStoreMock>();
2045 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2046 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
2047 vector<DKRecord> records;
2048 int32_t ret = fileDataHandler->GetMetaModifiedRecords(records);
2049 EXPECT_NE(E_OK, ret);
2050 } catch (...) {
2051 EXPECT_TRUE(false);
2052 GTEST_LOG_(INFO) << " GetMetaModifiedRecords001 ERROR";
2053 }
2054
2055 GTEST_LOG_(INFO) << "GetMetaModifiedRecords001 End";
2056 }
2057
2058 /**
2059 * @tc.name: GetMetaModifiedRecords002
2060 * @tc.desc: Verify the GetMetaModifiedRecords002 function
2061 * @tc.type: FUNC
2062 * @tc.require: I6JPKG
2063 */
2064 HWTEST_F(FileDataHandlerTest, GetMetaModifiedRecords002, TestSize.Level1)
2065 {
2066 GTEST_LOG_(INFO) << "GetMetaModifiedRecords002 Begin";
2067 try {
2068 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
2069 auto rdb = std::make_shared<RdbStoreMock>();
2070 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2071 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(Return(1));
2072 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset))));
2073 vector<DKRecord> records;
2074 int32_t ret = fileDataHandler->GetMetaModifiedRecords(records);
2075 EXPECT_NE(E_OK, ret);
2076 } catch (...) {
2077 EXPECT_TRUE(false);
2078 GTEST_LOG_(INFO) << " GetMetaModifiedRecords002 ERROR";
2079 }
2080
2081 GTEST_LOG_(INFO) << "GetMetaModifiedRecords002 End";
2082 }
2083
2084 /**
2085 * @tc.name: InsertTest
2086 * @tc.desc: Verify the Insert function
2087 * @tc.type: FUNC
2088 * @tc.require: I6JPKG
2089 */
2090 HWTEST_F(FileDataHandlerTest, InsertTest, TestSize.Level1)
2091 {
2092 GTEST_LOG_(INFO) << "InsertTest Begin";
2093 try {
2094 auto rdb = std::make_shared<RdbStoreMock>();
2095 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2096 EXPECT_CALL(*rdb, Insert(_, _, _)).WillRepeatedly(Return(0));
2097
2098 int64_t outRowId;
2099 NativeRdb::ValuesBucket initiavalues;
2100 int32_t ret = fileDataHandler->Insert(outRowId, initiavalues);
2101 EXPECT_EQ(E_OK, ret);
2102 } catch (...) {
2103 EXPECT_TRUE(false);
2104 GTEST_LOG_(INFO) << "InsertTest ERROR";
2105 }
2106
2107 GTEST_LOG_(INFO) << "InsertTest End";
2108 }
2109
2110 /**
2111 * @tc.name: UpdateTest
2112 * @tc.desc: Verify the Update function
2113 * @tc.type: FUNC
2114 * @tc.require: I6JPKG
2115 */
2116 HWTEST_F(FileDataHandlerTest, UpdateTest, TestSize.Level1)
2117 {
2118 GTEST_LOG_(INFO) << "UpdateTest Begin";
2119 try {
2120 auto rdb = std::make_shared<RdbStoreMock>();
2121 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2122 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillRepeatedly(Return(0));
2123
2124 int changedRows;
2125 NativeRdb::ValuesBucket values;
2126 int32_t ret = fileDataHandler->Update(changedRows, values, "", {""});
2127 EXPECT_EQ(E_OK, ret);
2128 } catch (...) {
2129 EXPECT_TRUE(false);
2130 GTEST_LOG_(INFO) << "UpdateTest ERROR";
2131 }
2132
2133 GTEST_LOG_(INFO) << "UpdateTest End";
2134 }
2135
2136 /**
2137 * @tc.name: DeleteTest
2138 * @tc.desc: Verify the Delete function
2139 * @tc.type: FUNC
2140 * @tc.require: I6JPKG
2141 */
2142 HWTEST_F(FileDataHandlerTest, DeleteTest, TestSize.Level1)
2143 {
2144 GTEST_LOG_(INFO) << "DeleteTest Begin";
2145 try {
2146 auto rdb = std::make_shared<RdbStoreMock>();
2147 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2148 EXPECT_CALL(*rdb, Delete(_, _, _, A<const vector<string> &>())).WillRepeatedly(Return(0));
2149
2150 int deletedRows;
2151 int32_t ret = fileDataHandler->Delete(deletedRows, "", {""});
2152 EXPECT_EQ(E_OK, ret);
2153 } catch (...) {
2154 EXPECT_TRUE(false);
2155 GTEST_LOG_(INFO) << "DeleteTest ERROR";
2156 }
2157
2158 GTEST_LOG_(INFO) << "DeleteTest End";
2159 }
2160
2161 /**
2162 * @tc.name: QueryTest
2163 * @tc.desc: Verify the Query function
2164 * @tc.type: FUNC
2165 * @tc.require: I6JPKG
2166 */
2167 HWTEST_F(FileDataHandlerTest, QueryTest, TestSize.Level1)
2168 {
2169 GTEST_LOG_(INFO) << "QueryTest Begin";
2170 try {
2171 auto rdb = std::make_shared<RdbStoreMock>();
2172 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false));
2173 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr)));
2174
2175 std::string tableName = "test_name";
2176 NativeRdb::AbsRdbPredicates predicates(tableName);
2177 std::vector<std::string> columns;
2178 auto ret = fileDataHandler->Query(predicates, columns);
2179 EXPECT_EQ(ret, nullptr);
2180 } catch (...) {
2181 EXPECT_TRUE(false);
2182 GTEST_LOG_(INFO) << "QueryTest ERROR";
2183 }
2184
2185 GTEST_LOG_(INFO) << "QueryTest End";
2186 }
2187
2188 } // namespace OHOS::FileManagement::CloudSync::Test
2189