1 /*
2 * Copyright (C) 2024 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 "cloud_file_utils.h"
17 #include "cloud_status.h"
18 #include "clouddisk_rdb_utils.h"
19 #include "clouddisk_rdbstore.h"
20 #include "dfs_error.h"
21 #include "rdb_assistant.h"
22 #include "result_set_mock.h"
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25 #include <memory>
26 #include "transaction_mock.cpp"
27
28 namespace OHOS::FileManagement::CloudDisk::Test {
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace std;
32 using namespace NativeRdb;
33
34 static const string BUNDLE_NAME = "com.ohos.photos";
35 static const int32_t USER_ID = 100;
36 class CloudDiskRdbStoreTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 static inline shared_ptr<CloudDiskRdbStore> clouddiskrdbStore_ = nullptr;
43 static inline shared_ptr<AssistantMock> insMock = nullptr;
44 };
45
SetUpTestCase(void)46 void CloudDiskRdbStoreTest::SetUpTestCase(void)
47 {
48 GTEST_LOG_(INFO) << "SetUpTestCase";
49 insMock = make_shared<AssistantMock>();
50 Assistant::ins = insMock;
51 clouddiskrdbStore_ = make_shared<CloudDiskRdbStore>(BUNDLE_NAME, USER_ID);
52 }
53
TearDownTestCase(void)54 void CloudDiskRdbStoreTest::TearDownTestCase(void)
55 {
56 Assistant::ins = nullptr;
57 insMock = nullptr;
58 clouddiskrdbStore_ = nullptr;
59 GTEST_LOG_(INFO) << "TearDownTestCase";
60 }
61
SetUp(void)62 void CloudDiskRdbStoreTest::SetUp(void)
63 {
64 GTEST_LOG_(INFO) << "SetUp";
65 }
66
TearDown(void)67 void CloudDiskRdbStoreTest::TearDown(void)
68 {
69 GTEST_LOG_(INFO) << "TearDown";
70 }
71
72 /**
73 * @tc.name: ReBuildDatabase
74 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
75 * @tc.type: FUNC
76 * @tc.require: SR000HRKKA
77 */
78 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest1, TestSize.Level1)
79 {
80 string databasePath = "/data";
81 auto rdb = make_shared<RdbStoreMock>();
82 clouddiskrdbStore_->rdbStore_ = rdb;
83 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_RDB));
84
85 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
86 EXPECT_EQ(ret, E_RDB);
87 }
88
89 /**
90 * @tc.name: ReBuildDatabase
91 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
92 * @tc.type: FUNC
93 * @tc.require: SR000HRKKA
94 */
95 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest2, TestSize.Level1)
96 {
97 string databasePath = "/data";
98 auto rdb = make_shared<RdbStoreMock>();
99 clouddiskrdbStore_->rdbStore_ = rdb;
100 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_OK));
101 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(nullptr));
102
103 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
104 EXPECT_EQ(ret, E_OK);
105 }
106
107 /**
108 * @tc.name: ReBuildDatabase
109 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
110 * @tc.type: FUNC
111 * @tc.require: SR000HRKKA
112 */
113 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest3, TestSize.Level1)
114 {
115 string databasePath = "/data";
116 auto rdb = make_shared<RdbStoreMock>();
117 clouddiskrdbStore_->rdbStore_ = rdb;
118 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_OK));
119 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(rdb));
120
121 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
122 EXPECT_EQ(ret, E_OK);
123 }
124
125 /**
126 * @tc.name: RdbInit
127 * @tc.desc: Verify the CloudDiskRdbStore::RdbInit function
128 * @tc.type: FUNC
129 * @tc.require: SR000HRKKA
130 */
131 HWTEST_F(CloudDiskRdbStoreTest, RdbInitTest1, TestSize.Level1)
132 {
133 auto rdb = make_shared<RdbStoreMock>();
134 clouddiskrdbStore_->rdbStore_ = rdb;
135 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(nullptr));
136
137 int32_t ret = clouddiskrdbStore_->RdbInit();
138 EXPECT_NE(ret, E_RDB);
139 }
140
141 /**
142 * @tc.name: RdbInit
143 * @tc.desc: Verify the CloudDiskRdbStore::RdbInit function
144 * @tc.type: FUNC
145 * @tc.require: SR000HRKKA
146 */
147 HWTEST_F(CloudDiskRdbStoreTest, RdbInitTest2, TestSize.Level1)
148 {
149 auto rdb = make_shared<RdbStoreMock>();
150 clouddiskrdbStore_->rdbStore_ = rdb;
151 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(rdb));
152
153 int32_t ret = clouddiskrdbStore_->RdbInit();
154 EXPECT_NE(ret, E_RDB);
155 }
156
157 /**
158 * @tc.name: LookUp
159 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
160 * @tc.type: FUNC
161 * @tc.require: SR000HRKKA
162 */
163 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest1, TestSize.Level1)
164 {
165 const std::string parentCloudId = "";
166 const std::string fileName = "";
167 CloudDiskFileInfo info;
168 auto rdb = make_shared<RdbStoreMock>();
169 clouddiskrdbStore_->rdbStore_ = rdb;
170 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
171 EXPECT_EQ(ret, E_INVAL_ARG);
172 }
173
174 /**
175 * @tc.name: LookUp
176 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
177 * @tc.type: FUNC
178 * @tc.require: SR000HRKKA
179 */
180 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest2, TestSize.Level1)
181 {
182 const std::string parentCloudId = "rootId";
183 const std::string fileName = "test";
184 CloudDiskFileInfo info;
185 info.name = "mock";
186 auto rdb = make_shared<RdbStoreMock>();
187 clouddiskrdbStore_->rdbStore_ = rdb;
188 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
189 EXPECT_EQ(ret, E_RDB);
190 }
191
192 /**
193 * @tc.name: LookUp
194 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
195 * @tc.type: FUNC
196 * @tc.require: SR000HRKKA
197 */
198 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest3, TestSize.Level1)
199 {
200 const std::string parentCloudId = "rootId";
201 const std::string fileName = "test";
202 CloudDiskFileInfo info;
203 auto rdb = make_shared<RdbStoreMock>();
204 clouddiskrdbStore_->rdbStore_ = rdb;
205 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
206 EXPECT_EQ(ret, E_OK);
207 }
208
209 /**
210 * @tc.name: GetAttr
211 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
212 * @tc.type: FUNC
213 * @tc.require: SR000HRKKA
214 */
215 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest1, TestSize.Level1)
216 {
217 const std::string cloudId = "";
218 const std::string fileName = "test";
219 CloudDiskFileInfo info;
220 auto rdb = make_shared<RdbStoreMock>();
221 clouddiskrdbStore_->rdbStore_ = rdb;
222 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
223 EXPECT_EQ(ret, E_INVAL_ARG);
224 }
225
226 /**
227 * @tc.name: GetAttr
228 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
229 * @tc.type: FUNC
230 * @tc.require: SR000HRKKA
231 */
232 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest2, TestSize.Level1)
233 {
234 const std::string cloudId = "100";
235 CloudDiskFileInfo info;
236 info.name = "mock";
237 auto rdb = make_shared<RdbStoreMock>();
238 clouddiskrdbStore_->rdbStore_ = rdb;
239 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
240 EXPECT_EQ(ret, E_RDB);
241 }
242
243 /**
244 * @tc.name: GetAttr
245 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
246 * @tc.type: FUNC
247 * @tc.require: SR000HRKKA
248 */
249 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest3, TestSize.Level1)
250 {
251 const std::string cloudId = "100";
252 CloudDiskFileInfo info;
253 auto rdb = make_shared<RdbStoreMock>();
254 clouddiskrdbStore_->rdbStore_ = rdb;
255 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
256 EXPECT_EQ(ret, E_OK);
257 }
258
259 /**
260 * @tc.name: SetAttr
261 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
262 * @tc.type: FUNC
263 * @tc.require: SR000HRKKA
264 */
265 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest1, TestSize.Level1)
266 {
267 const std::string fileName = "Test";
268 const std::string parentCloudId = "100";
269 const std::string cloudId = "";
270 const unsigned long long size = 0;
271 auto rdb = make_shared<RdbStoreMock>();
272 clouddiskrdbStore_->rdbStore_ = rdb;
273 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
274 EXPECT_EQ(ret, E_INVAL_ARG);
275 }
276
277 /**
278 * @tc.name: SetAttr
279 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
280 * @tc.type: FUNC
281 * @tc.require: SR000HRKKA
282 */
283 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest2, TestSize.Level1)
284 {
285 const std::string fileName = "Test";
286 const std::string parentCloudId = "100";
287 const std::string cloudId = "rootId";
288 const unsigned long long size = 0;
289 auto rdb = make_shared<RdbStoreMock>();
290 clouddiskrdbStore_->rdbStore_ = rdb;
291 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
292 EXPECT_EQ(ret, E_INVAL_ARG);
293 }
294
295 /**
296 * @tc.name: SetAttr
297 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
298 * @tc.type: FUNC
299 * @tc.require: SR000HRKKA
300 */
301 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest3, TestSize.Level1)
302 {
303 const std::string fileName = "mock";
304 const std::string parentCloudId = "100";
305 const std::string cloudId = "100";
306 const unsigned long long size = 0;
307 auto rdb = make_shared<RdbStoreMock>();
308 clouddiskrdbStore_->rdbStore_ = rdb;
309
310 auto transaction = make_shared<TransactionMock>();
311 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
312 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
313
314 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
315 EXPECT_EQ(ret, E_RDB);
316 }
317
318 /**
319 * @tc.name: SetAttr
320 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
321 * @tc.type: FUNC
322 * @tc.require: SR000HRKKA
323 */
324 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest4, TestSize.Level1)
325 {
326 const std::string fileName = "mock";
327 const std::string parentCloudId = "100";
328 const std::string cloudId = "100";
329 const unsigned long long size = 0;
330 auto rdb = make_shared<RdbStoreMock>();
331 clouddiskrdbStore_->rdbStore_ = rdb;
332
333 auto transaction = make_shared<TransactionMock>();
334 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
335 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
336
337 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
338 EXPECT_EQ(ret, E_RDB);
339 }
340
341 /**
342 * @tc.name: SetAttr
343 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
344 * @tc.type: FUNC
345 * @tc.require: SR000HRKKA
346 */
347 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest5, TestSize.Level1)
348 {
349 const std::string fileName = "test";
350 const std::string parentCloudId = "100";
351 const std::string cloudId = "100";
352 const unsigned long long size = 0;
353 auto rdb = make_shared<RdbStoreMock>();
354 clouddiskrdbStore_->rdbStore_ = rdb;
355
356 auto transaction = make_shared<TransactionMock>();
357 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
358 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
359
360 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
361 EXPECT_EQ(ret, E_RDB);
362 }
363
364 /**
365 * @tc.name: ReadDir
366 * @tc.desc: Verify the CloudDiskRdbStore::ReadDir function
367 * @tc.type: FUNC
368 * @tc.require: SR000HRKKA
369 */
370 HWTEST_F(CloudDiskRdbStoreTest, ReadDirTest1, TestSize.Level1)
371 {
372 const std::string cloudId = "rootId";
373 vector<CloudDiskFileInfo> infos;
374 auto rdb = make_shared<RdbStoreMock>();
375 clouddiskrdbStore_->rdbStore_ = rdb;
376 int32_t ret = clouddiskrdbStore_->ReadDir(cloudId, infos);
377 EXPECT_EQ(ret, E_RDB);
378 }
379
380 /**
381 * @tc.name: ReadDir
382 * @tc.desc: Verify the CloudDiskRdbStore::ReadDir function
383 * @tc.type: FUNC
384 * @tc.require: SR000HRKKA
385 */
386 HWTEST_F(CloudDiskRdbStoreTest, ReadDirTest2, TestSize.Level1)
387 {
388 const std::string cloudId = "rootId";
389 CloudDiskFileInfo info;
390 vector<CloudDiskFileInfo> infos;
391 infos.push_back(info);
392 auto rdb = make_shared<RdbStoreMock>();
393 clouddiskrdbStore_->rdbStore_ = rdb;
394 int32_t ret = clouddiskrdbStore_->ReadDir(cloudId, infos);
395 EXPECT_EQ(ret, E_OK);
396 }
397
398 /**
399 * @tc.name: Create
400 * @tc.desc: Verify the CloudDiskRdbStore::Create function
401 * @tc.type: FUNC
402 * @tc.require: SR000HRKKA
403 */
404 HWTEST_F(CloudDiskRdbStoreTest, CreateTest1, TestSize.Level1)
405 {
406 const std::string cloudId = "rootId";
407 const std::string parentCloudId = "100";
408 const std::string fileName = "";
409 bool noNeedUpload = false;
410 auto rdb = make_shared<RdbStoreMock>();
411 clouddiskrdbStore_->rdbStore_ = rdb;
412 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
413 EXPECT_EQ(ret, EINVAL);
414 }
415
416 /**
417 * @tc.name: Create
418 * @tc.desc: Verify the CloudDiskRdbStore::Create function
419 * @tc.type: FUNC
420 * @tc.require: SR000HRKKA
421 */
422 HWTEST_F(CloudDiskRdbStoreTest, CreateTest2, TestSize.Level1)
423 {
424 const std::string cloudId = "rootId";
425 const std::string parentCloudId = "100";
426 const std::string fileName = "<|>";
427 bool noNeedUpload = false;
428 auto rdb = make_shared<RdbStoreMock>();
429 clouddiskrdbStore_->rdbStore_ = rdb;
430 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
431 EXPECT_EQ(ret, EINVAL);
432 }
433
434 /**
435 * @tc.name: Create
436 * @tc.desc: Verify the CloudDiskRdbStore::Create function
437 * @tc.type: FUNC
438 * @tc.require: SR000HRKKA
439 */
440 HWTEST_F(CloudDiskRdbStoreTest, CreateTest3, TestSize.Level1)
441 {
442 const std::string cloudId = "rootId";
443 const std::string parentCloudId = "100";
444 const std::string fileName = " test";
445 bool noNeedUpload = false;
446 auto rdb = make_shared<RdbStoreMock>();
447 clouddiskrdbStore_->rdbStore_ = rdb;
448 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
449 EXPECT_EQ(ret, EINVAL);
450 }
451
452 /**
453 * @tc.name: Create
454 * @tc.desc: Verify the CloudDiskRdbStore::Create function
455 * @tc.type: FUNC
456 * @tc.require: SR000HRKKA
457 */
458 HWTEST_F(CloudDiskRdbStoreTest, CreateTest4, TestSize.Level1)
459 {
460 const std::string cloudId = "";
461 const std::string parentCloudId = "";
462 const std::string fileName = "test";
463 bool noNeedUpload = false;
464 auto rdb = make_shared<RdbStoreMock>();
465 clouddiskrdbStore_->rdbStore_ = rdb;
466 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
467 EXPECT_EQ(ret, E_INVAL_ARG);
468 }
469
470 /**
471 * @tc.name: Create
472 * @tc.desc: Verify the CloudDiskRdbStore::Create function
473 * @tc.type: FUNC
474 * @tc.require: SR000HRKKA
475 */
476 HWTEST_F(CloudDiskRdbStoreTest, CreateTest5, TestSize.Level1)
477 {
478 const std::string cloudId = "rootId";
479 const std::string parentCloudId = "100";
480 const std::string fileName = "test";
481 bool noNeedUpload = false;
482 clouddiskrdbStore_->userId_ = 0;
483 auto rdb = make_shared<RdbStoreMock>();
484 clouddiskrdbStore_->rdbStore_ = rdb;
485 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
486 EXPECT_EQ(ret, E_PATH);
487 }
488
489 /**
490 * @tc.name: Create
491 * @tc.desc: Verify the CloudDiskRdbStore::Create function
492 * @tc.type: FUNC
493 * @tc.require: SR000HRKKA
494 */
495 HWTEST_F(CloudDiskRdbStoreTest, CreateTest6, TestSize.Level1)
496 {
497 const std::string cloudId = "rootId";
498 const std::string parentCloudId = "100";
499 const std::string fileName = "test";
500 bool noNeedUpload = true;
501 clouddiskrdbStore_->userId_ = 1;
502 auto rdb = make_shared<RdbStoreMock>();
503 clouddiskrdbStore_->rdbStore_ = rdb;
504
505 auto transaction = make_shared<TransactionMock>();
506 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
507 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
508
509 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
510 EXPECT_EQ(ret, E_RDB);
511 }
512
513 /**
514 * @tc.name: Create
515 * @tc.desc: Verify the CloudDiskRdbStore::Create function
516 * @tc.type: FUNC
517 * @tc.require: SR000HRKKA
518 */
519 HWTEST_F(CloudDiskRdbStoreTest, CreateTest7, TestSize.Level1)
520 {
521 const std::string cloudId = "rootId";
522 const std::string parentCloudId = "100";
523 const std::string fileName = "mock";
524 bool noNeedUpload = true;
525 clouddiskrdbStore_->userId_ = 1;
526 auto rdb = make_shared<RdbStoreMock>();
527 clouddiskrdbStore_->rdbStore_ = rdb;
528
529 auto transaction = make_shared<TransactionMock>();
530 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
531 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
532
533 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
534 EXPECT_EQ(ret, E_RDB);
535 }
536
537 /**
538 * @tc.name: Create
539 * @tc.desc: Verify the CloudDiskRdbStore::Create function
540 * @tc.type: FUNC
541 * @tc.require: SR000HRKKA
542 */
543 HWTEST_F(CloudDiskRdbStoreTest, CreateTest8, TestSize.Level1)
544 {
545 const std::string cloudId = "rootId";
546 const std::string parentCloudId = "100";
547 const std::string fileName = "test";
548 bool noNeedUpload = true;
549 clouddiskrdbStore_->userId_ = 1;
550 auto rdb = make_shared<RdbStoreMock>();
551 clouddiskrdbStore_->rdbStore_ = rdb;
552
553 auto transaction = make_shared<TransactionMock>();
554 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
555 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
556
557 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
558 EXPECT_EQ(ret, E_RDB);
559 }
560
561 /**
562 * @tc.name: MkDir
563 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
564 * @tc.type: FUNC
565 * @tc.require: SR000HRKKA
566 */
567 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest1, TestSize.Level1)
568 {
569 const std::string cloudId = "100";
570 const std::string parentCloudId = "100";
571 const std::string directoryName = "";
572 bool noNeedUpload = false;
573 auto rdb = make_shared<RdbStoreMock>();
574 clouddiskrdbStore_->rdbStore_ = rdb;
575 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
576 EXPECT_EQ(ret, EINVAL);
577 }
578
579 /**
580 * @tc.name: MkDir
581 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
582 * @tc.type: FUNC
583 * @tc.require: SR000HRKKA
584 */
585 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest2, TestSize.Level1)
586 {
587 const std::string cloudId = "100";
588 const std::string parentCloudId = "100";
589 const std::string directoryName = ".trash";
590 bool noNeedUpload = false;
591 auto rdb = make_shared<RdbStoreMock>();
592 clouddiskrdbStore_->rdbStore_ = rdb;
593 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
594 EXPECT_EQ(ret, EINVAL);
595 }
596
597 /**
598 * @tc.name: MkDir
599 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
600 * @tc.type: FUNC
601 * @tc.require: SR000HRKKA
602 */
603 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest3, TestSize.Level1)
604 {
605 const std::string cloudId = "";
606 const std::string parentCloudId = "";
607 const std::string directoryName = "test";
608 bool noNeedUpload = false;
609 auto rdb = make_shared<RdbStoreMock>();
610 clouddiskrdbStore_->rdbStore_ = rdb;
611 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
612 EXPECT_EQ(ret, E_INVAL_ARG);
613 }
614
615 /**
616 * @tc.name: MkDir
617 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
618 * @tc.type: FUNC
619 * @tc.require: SR000HRKKA
620 */
621 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest4, TestSize.Level1)
622 {
623 const std::string cloudId = "100";
624 const std::string parentCloudId = "100";
625 const std::string directoryName = "mock";
626 bool noNeedUpload = false;
627 auto rdb = make_shared<RdbStoreMock>();
628 clouddiskrdbStore_->rdbStore_ = rdb;
629
630 auto transaction = make_shared<TransactionMock>();
631 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
632 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
633
634 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
635 EXPECT_EQ(ret, E_RDB);
636 }
637
638 /**
639 * @tc.name: MkDir
640 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
641 * @tc.type: FUNC
642 * @tc.require: SR000HRKKA
643 */
644 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest5, TestSize.Level1)
645 {
646 const std::string cloudId = "100";
647 const std::string parentCloudId = "100";
648 const std::string directoryName = "mock";
649 bool noNeedUpload = true;
650 auto rdb = make_shared<RdbStoreMock>();
651 clouddiskrdbStore_->rdbStore_ = rdb;
652
653 auto transaction = make_shared<TransactionMock>();
654 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
655 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
656
657 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
658 EXPECT_EQ(ret, E_RDB);
659 }
660
661 /**
662 * @tc.name: MkDir
663 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
664 * @tc.type: FUNC
665 * @tc.require: SR000HRKKA
666 */
667 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest6, TestSize.Level1)
668 {
669 const std::string cloudId = "100";
670 const std::string parentCloudId = "100";
671 const std::string directoryName = "test";
672 bool noNeedUpload = true;
673 auto rdb = make_shared<RdbStoreMock>();
674 clouddiskrdbStore_->rdbStore_ = rdb;
675
676 auto transaction = make_shared<TransactionMock>();
677 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
678 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
679
680 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
681 EXPECT_EQ(ret, E_RDB);
682 }
683
684 /**
685 * @tc.name: Write
686 * @tc.desc: Verify the CloudDiskRdbStore::Write function
687 * @tc.type: FUNC
688 * @tc.require: SR000HRKKA
689 */
690 HWTEST_F(CloudDiskRdbStoreTest, WriteTest1, TestSize.Level1)
691 {
692 const std::string cloudId = "";
693 const std::string parentCloudId = "100";
694 const std::string fileName = "file";
695 auto rdb = make_shared<RdbStoreMock>();
696 clouddiskrdbStore_->rdbStore_ = rdb;
697 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
698 EXPECT_EQ(ret, E_INVAL_ARG);
699 }
700
701 /**
702 * @tc.name: Write
703 * @tc.desc: Verify the CloudDiskRdbStore::Write function
704 * @tc.type: FUNC
705 * @tc.require: SR000HRKKA
706 */
707 HWTEST_F(CloudDiskRdbStoreTest, WriteTest2, TestSize.Level1)
708 {
709 const std::string cloudId = "100";
710 const std::string fileName = "file";
711 const std::string parentCloudId = "rootId";
712 auto rdb = make_shared<RdbStoreMock>();
713 clouddiskrdbStore_->rdbStore_ = rdb;
714 clouddiskrdbStore_->userId_ = 0;
715 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
716 EXPECT_EQ(ret, E_PATH);
717 }
718
719 /**
720 * @tc.name: Write
721 * @tc.desc: Verify the CloudDiskRdbStore::Write function
722 * @tc.type: FUNC
723 * @tc.require: SR000HRKKA
724 */
725 HWTEST_F(CloudDiskRdbStoreTest, WriteTest3, TestSize.Level1)
726 {
727 const std::string cloudId = "100";
728 const std::string fileName = "file";
729 const std::string parentCloudId = "rootId";
730 auto rdb = make_shared<RdbStoreMock>();
731 clouddiskrdbStore_->rdbStore_ = rdb;
732 clouddiskrdbStore_->userId_ = 1;
733
734 auto transaction = make_shared<TransactionMock>();
735 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
736 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
737 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
738 EXPECT_EQ(ret, E_RDB);
739 }
740
741 /**
742 * @tc.name: Write
743 * @tc.desc: Verify the CloudDiskRdbStore::Write function
744 * @tc.type: FUNC
745 * @tc.require: SR000HRKKA
746 */
747 HWTEST_F(CloudDiskRdbStoreTest, WriteTest4, TestSize.Level1)
748 {
749 const std::string cloudId = "100";
750 const std::string fileName = "mock";
751 const std::string parentCloudId = "rootId";
752 auto rdb = make_shared<RdbStoreMock>();
753 clouddiskrdbStore_->rdbStore_ = rdb;
754 clouddiskrdbStore_->userId_ = 1;
755 auto transaction = make_shared<TransactionMock>();
756 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
757 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
758
759 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
760 EXPECT_EQ(ret, E_RDB);
761 }
762
763 /**
764 * @tc.name: Write
765 * @tc.desc: Verify the CloudDiskRdbStore::Write function
766 * @tc.type: FUNC
767 * @tc.require: SR000HRKKA
768 */
769 HWTEST_F(CloudDiskRdbStoreTest, WriteTest5, TestSize.Level1)
770 {
771 const std::string cloudId = "100";
772 const std::string fileName = "test";
773 const std::string parentCloudId = "rootId";
774 auto rdb = make_shared<RdbStoreMock>();
775 clouddiskrdbStore_->rdbStore_ = rdb;
776 clouddiskrdbStore_->userId_ = 1;
777 auto transaction = make_shared<TransactionMock>();
778 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
779 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
780
781 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
782 EXPECT_EQ(ret, E_RDB);
783 }
784
785 /**
786 * @tc.name: LocationSetXattr
787 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
788 * @tc.type: FUNC
789 * @tc.require: SR000HRKKA
790 */
791 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest1, TestSize.Level1)
792 {
793 const std::string name = "test";
794 const std::string parentCloudId = "100";
795 const std::string cloudId = "100";
796 const std::string value = "4";
797 auto rdb = make_shared<RdbStoreMock>();
798 clouddiskrdbStore_->rdbStore_ = rdb;
799 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
800 EXPECT_EQ(ret, E_INVAL_ARG);
801 }
802
803 /**
804 * @tc.name: LocationSetXattr
805 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
806 * @tc.type: FUNC
807 * @tc.require: SR000HRKKA
808 */
809 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest2, TestSize.Level1)
810 {
811 const std::string name = "mock";
812 const std::string parentCloudId = "100";
813 const std::string cloudId = "100";
814 const std::string value = "1";
815 auto rdb = make_shared<RdbStoreMock>();
816 clouddiskrdbStore_->rdbStore_ = rdb;
817 auto transaction = make_shared<TransactionMock>();
818 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
819 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
820
821 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
822 EXPECT_EQ(ret, E_RDB);
823 }
824
825 /**
826 * @tc.name: LocationSetXattr
827 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
828 * @tc.type: FUNC
829 * @tc.require: SR000HRKKA
830 */
831 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest3, TestSize.Level1)
832 {
833 const std::string name = "mock";
834 const std::string parentCloudId = "100";
835 const std::string cloudId = "100";
836 const std::string value = "1";
837 auto rdb = make_shared<RdbStoreMock>();
838 clouddiskrdbStore_->rdbStore_ = rdb;
839 auto transaction = make_shared<TransactionMock>();
840 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
841 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
842
843 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
844 EXPECT_EQ(ret, E_RDB);
845 }
846
847 /**
848 * @tc.name: LocationSetXattr
849 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
850 * @tc.type: FUNC
851 * @tc.require: SR000HRKKA
852 */
853 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest4, TestSize.Level1)
854 {
855 const std::string name = "test";
856 const std::string parentCloudId = "100";
857 const std::string cloudId = "100";
858 const std::string value = "1";
859 auto rdb = make_shared<RdbStoreMock>();
860 clouddiskrdbStore_->rdbStore_ = rdb;
861 auto transaction = make_shared<TransactionMock>();
862 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
863 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
864
865 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
866 EXPECT_EQ(ret, E_RDB);
867 }
868
869 /**
870 * @tc.name: HasTHMSetXattr
871 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
872 * @tc.type: FUNC
873 * @tc.require: SR000HRKKA
874 */
875 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest1, TestSize.Level1)
876 {
877 const std::string name = "test";
878 const std::string key = "100";
879 const std::string cloudId = "100";
880 const std::string value = "test";
881 auto rdb = make_shared<RdbStoreMock>();
882 clouddiskrdbStore_->rdbStore_ = rdb;
883
884 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
885 EXPECT_EQ(ret, E_INVAL_ARG);
886 }
887
888 /**
889 * @tc.name: HasTHMSetXattr
890 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
891 * @tc.type: FUNC
892 * @tc.require: SR000HRKKA
893 */
894 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest2, TestSize.Level1)
895 {
896 const std::string name = "test";
897 const std::string key = "100";
898 const std::string cloudId = "100";
899 const std::string value = "2";
900 auto rdb = make_shared<RdbStoreMock>();
901 clouddiskrdbStore_->rdbStore_ = rdb;
902
903 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
904 EXPECT_EQ(ret, E_INVAL_ARG);
905 }
906
907 /**
908 * @tc.name: HasTHMSetXattr
909 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
910 * @tc.type: FUNC
911 * @tc.require: SR000HRKKA
912 */
913 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest3, TestSize.Level1)
914 {
915 const std::string name = "test";
916 const std::string key = CLOUD_HAS_LCD;
917 const std::string cloudId = "100";
918 const std::string value = "0";
919 bool preCount = true;
920 auto rdb = make_shared<RdbStoreMock>();
921 clouddiskrdbStore_->rdbStore_ = rdb;
922 auto transaction = make_shared<TransactionMock>();
923 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
924 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
925 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
926 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
927 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
928 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
929
930 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
931 EXPECT_EQ(ret, E_OK);
932 }
933
934 /**
935 * @tc.name: HasTHMSetXattr
936 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
937 * @tc.type: FUNC
938 * @tc.require: SR000HRKKA
939 */
940 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest4, TestSize.Level1)
941 {
942 const std::string name = "test";
943 const std::string key = CLOUD_HAS_THM;
944 const std::string cloudId = "100";
945 const std::string value = "0";
946 bool preCount = true;
947 auto rdb = make_shared<RdbStoreMock>();
948 clouddiskrdbStore_->rdbStore_ = rdb;
949 auto transaction = make_shared<TransactionMock>();
950 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
951 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
952 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
953 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
954 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
955 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
956
957 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
958 EXPECT_EQ(ret, E_OK);
959 }
960
961 /**
962 * @tc.name: HasTHMSetXattr
963 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
964 * @tc.type: FUNC
965 * @tc.require: SR000HRKKA
966 */
967 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest5, TestSize.Level1)
968 {
969 const std::string name = "test";
970 const std::string key = CLOUD_HAS_LCD;
971 const std::string cloudId = "100";
972 const std::string value = "1";
973 bool preCount = true;
974 auto rdb = make_shared<RdbStoreMock>();
975 clouddiskrdbStore_->rdbStore_ = rdb;
976 auto transaction = make_shared<TransactionMock>();
977 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
978 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
979 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
980 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
981 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
982 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
983
984 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
985 EXPECT_EQ(ret, E_OK);
986 }
987
988 /**
989 * @tc.name: HasTHMSetXattr
990 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
991 * @tc.type: FUNC
992 * @tc.require: SR000HRKKA
993 */
994 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest6, TestSize.Level1)
995 {
996 const std::string name = "test";
997 const std::string key = CLOUD_HAS_THM;
998 const std::string cloudId = "100";
999 const std::string value = "1";
1000 bool preCount = true;
1001 auto rdb = make_shared<RdbStoreMock>();
1002 clouddiskrdbStore_->rdbStore_ = rdb;
1003 auto transaction = make_shared<TransactionMock>();
1004 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1005 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1006 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1007 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
1008 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1009 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1010
1011 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
1012 EXPECT_EQ(ret, E_OK);
1013 }
1014
1015 /**
1016 * @tc.name: HasTHMSetXattr
1017 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
1018 * @tc.type: FUNC
1019 * @tc.require: SR000HRKKA
1020 */
1021 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest7, TestSize.Level1)
1022 {
1023 const std::string name = "test";
1024 const std::string key = CLOUD_HAS_THM;
1025 const std::string cloudId = "100";
1026 const std::string value = "1";
1027 bool preCount = true;
1028 auto rdb = make_shared<RdbStoreMock>();
1029 clouddiskrdbStore_->rdbStore_ = rdb;
1030 auto transaction = make_shared<TransactionMock>();
1031 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1032 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1033 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1034 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
1035 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1036 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1037
1038 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
1039 EXPECT_EQ(ret, E_RDB);
1040 }
1041
1042 /**
1043 * @tc.name: GetRowId
1044 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1045 * @tc.type: FUNC
1046 * @tc.require: SR000HRKKA
1047 */
1048 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest1, TestSize.Level1)
1049 {
1050 const std::string cloudId = "100";
1051 int64_t rowId = 100;
1052 bool preCount = true;
1053 auto rdb = make_shared<RdbStoreMock>();
1054 clouddiskrdbStore_->rdbStore_ = rdb;
1055 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1056 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1057
1058 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1059 EXPECT_EQ(ret, E_RDB);
1060 }
1061
1062 /**
1063 * @tc.name: GetRowId
1064 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1065 * @tc.type: FUNC
1066 * @tc.require: SR000HRKKA
1067 */
1068 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest2, TestSize.Level1)
1069 {
1070 const std::string cloudId = "100";
1071 int64_t rowId = 100;
1072 bool preCount = true;
1073 auto rdb = make_shared<RdbStoreMock>();
1074 clouddiskrdbStore_->rdbStore_ = rdb;
1075 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1076 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1077 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1078 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(1));
1079
1080 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1081 EXPECT_EQ(ret, E_RDB);
1082 }
1083
1084 /**
1085 * @tc.name: GetRowId
1086 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1087 * @tc.type: FUNC
1088 * @tc.require: SR000HRKKA
1089 */
1090 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest3, TestSize.Level1)
1091 {
1092 const std::string cloudId = "100";
1093 int64_t rowId = 100;
1094 bool preCount = true;
1095 auto rdb = make_shared<RdbStoreMock>();
1096 clouddiskrdbStore_->rdbStore_ = rdb;
1097 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1098 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1099 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1100 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1101
1102 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1103 EXPECT_EQ(ret, E_OK);
1104 }
1105
1106 /**
1107 * @tc.name: GetParentCloudIdTest
1108 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1109 * @tc.type: FUNC
1110 * @tc.require: SR000HRKKA
1111 */
1112 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest1, TestSize.Level1)
1113 {
1114 const std::string cloudId = "100";
1115 std::string parentCloudId = "mock";
1116 bool preCount = true;
1117 auto rdb = make_shared<RdbStoreMock>();
1118 clouddiskrdbStore_->rdbStore_ = rdb;
1119 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1120 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1121
1122 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1123 EXPECT_EQ(ret, E_RDB);
1124 }
1125
1126 /**
1127 * @tc.name: GetParentCloudIdTest
1128 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1129 * @tc.type: FUNC
1130 * @tc.require: SR000HRKKA
1131 */
1132 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest2, TestSize.Level1)
1133 {
1134 const std::string cloudId = "100";
1135 std::string parentCloudId = "mock";
1136 bool preCount = true;
1137 auto rdb = make_shared<RdbStoreMock>();
1138 clouddiskrdbStore_->rdbStore_ = rdb;
1139 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1140 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1141 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1142 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1143
1144 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1145 EXPECT_EQ(ret, E_RDB);
1146 }
1147
1148 /**
1149 * @tc.name: GetParentCloudIdTest
1150 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1151 * @tc.type: FUNC
1152 * @tc.require: SR000HRKKA
1153 */
1154 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest3, TestSize.Level1)
1155 {
1156 const std::string cloudId = "100";
1157 std::string parentCloudId = "mock";
1158 bool preCount = true;
1159 auto rdb = make_shared<RdbStoreMock>();
1160 clouddiskrdbStore_->rdbStore_ = rdb;
1161 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1162 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1163 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1164 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1165
1166 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1167 EXPECT_EQ(ret, E_RDB);
1168 }
1169
1170 /**
1171 * @tc.name: GetParentCloudIdTest
1172 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1173 * @tc.type: FUNC
1174 * @tc.require: SR000HRKKA
1175 */
1176 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest4, TestSize.Level1)
1177 {
1178 const std::string cloudId = "100";
1179 std::string parentCloudId = "test";
1180 bool preCount = true;
1181 auto rdb = make_shared<RdbStoreMock>();
1182 clouddiskrdbStore_->rdbStore_ = rdb;
1183 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1184 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1185 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1186 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1187
1188 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1189 EXPECT_EQ(ret, E_OK);
1190 }
1191
1192 /**
1193 * @tc.name: GetSourcePath
1194 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1195 * @tc.type: FUNC
1196 * @tc.require: SR000HRKKA
1197 */
1198 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest1, TestSize.Level1)
1199 {
1200 const std::string attr = R"({"srcPath": "/data/service"})";
1201 const std::string parentCloudId = "100";
1202 std::string sourcePath = "/data";
1203 auto rdb = make_shared<RdbStoreMock>();
1204 clouddiskrdbStore_->rdbStore_ = rdb;
1205
1206 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1207 EXPECT_EQ(ret, E_OK);
1208 }
1209
1210 /**
1211 * @tc.name: GetSourcePath
1212 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1213 * @tc.type: FUNC
1214 * @tc.require: SR000HRKKA
1215 */
1216 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest2, TestSize.Level1)
1217 {
1218 const std::string attr = R"({"srcPath": 100})";
1219 const std::string parentCloudId = "100";
1220 std::string sourcePath = "/data";
1221 auto rdb = make_shared<RdbStoreMock>();
1222 clouddiskrdbStore_->rdbStore_ = rdb;
1223
1224 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1225 EXPECT_EQ(ret, E_OK);
1226 }
1227
1228 /**
1229 * @tc.name: GetSourcePath
1230 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1231 * @tc.type: FUNC
1232 * @tc.require: SR000HRKKA
1233 */
1234 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest3, TestSize.Level1)
1235 {
1236 const std::string attr = "";
1237 const std::string parentCloudId = "100";
1238 std::string sourcePath = "/data";
1239 auto rdb = make_shared<RdbStoreMock>();
1240 clouddiskrdbStore_->rdbStore_ = rdb;
1241
1242 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1243 EXPECT_EQ(ret, E_OK);
1244 }
1245
1246 /**
1247 * @tc.name: GetSourcePath
1248 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1249 * @tc.type: FUNC
1250 * @tc.require: SR000HRKKA
1251 */
1252 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest4, TestSize.Level1)
1253 {
1254 const std::string attr = "";
1255 const std::string parentCloudId = "";
1256 std::string sourcePath = "/data";
1257 auto rdb = make_shared<RdbStoreMock>();
1258 clouddiskrdbStore_->rdbStore_ = rdb;
1259
1260 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1261 EXPECT_EQ(ret, E_OK);
1262 }
1263
1264 /**
1265 * @tc.name: GetSourcePath
1266 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1267 * @tc.type: FUNC
1268 * @tc.require: SR000HRKKA
1269 */
1270 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest5, TestSize.Level1)
1271 {
1272 const std::string attr = "";
1273 const std::string parentCloudId = "100";
1274 std::string sourcePath = "/data";
1275 auto rdb = make_shared<RdbStoreMock>();
1276 clouddiskrdbStore_->rdbStore_ = rdb;
1277
1278 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1279 EXPECT_EQ(ret, E_OK);
1280 }
1281
1282 /**
1283 * @tc.name: SourcePathSetValue
1284 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1285 * @tc.type: FUNC
1286 * @tc.require: SR000HRKKA
1287 */
1288 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest1, TestSize.Level1)
1289 {
1290 const std::string cloudId = "";
1291 const std::string attr = "";
1292 ValuesBucket setXattr;
1293 auto rdb = make_shared<RdbStoreMock>();
1294 clouddiskrdbStore_->rdbStore_ = rdb;
1295
1296 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1297 EXPECT_EQ(ret, E_INVAL_ARG);
1298 }
1299
1300 /**
1301 * @tc.name: SourcePathSetValue
1302 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1303 * @tc.type: FUNC
1304 * @tc.require: SR000HRKKA
1305 */
1306 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest2, TestSize.Level1)
1307 {
1308 const std::string cloudId = "rootId";
1309 const std::string attr = "";
1310 ValuesBucket setXattr;
1311 auto rdb = make_shared<RdbStoreMock>();
1312 clouddiskrdbStore_->rdbStore_ = rdb;
1313
1314 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1315 EXPECT_EQ(ret, E_INVAL_ARG);
1316 }
1317
1318 /**
1319 * @tc.name: SourcePathSetValue
1320 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1321 * @tc.type: FUNC
1322 * @tc.require: SR000HRKKA
1323 */
1324 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest3, TestSize.Level1)
1325 {
1326 const std::string cloudId = "test";
1327 const std::string attr = "";
1328 ValuesBucket setXattr;
1329 bool preCount = true;
1330 auto rdb = make_shared<RdbStoreMock>();
1331 clouddiskrdbStore_->rdbStore_ = rdb;
1332 auto transaction = make_shared<TransactionMock>();
1333 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1334 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1335 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1336 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1337 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
1338
1339 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1340 EXPECT_EQ(ret, E_INVAL_ARG);
1341 }
1342
1343 /**
1344 * @tc.name: RecycleSetXattr
1345 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1346 * @tc.type: FUNC
1347 * @tc.require: SR000HRKKA
1348 */
1349 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest1, TestSize.Level1)
1350 {
1351 const std::string name = "test";
1352 const std::string parentCloudId = "100";
1353 const std::string cloudId = "100";
1354 const std::string value = "notnum";
1355 auto rdb = make_shared<RdbStoreMock>();
1356 clouddiskrdbStore_->rdbStore_ = rdb;
1357 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1358 EXPECT_EQ(ret, EINVAL);
1359 }
1360
1361 /**
1362 * @tc.name: RecycleSetXattr
1363 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1364 * @tc.type: FUNC
1365 * @tc.require: SR000HRKKA
1366 */
1367 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest2, TestSize.Level1)
1368 {
1369 const std::string name = "test";
1370 const std::string parentCloudId = "100";
1371 const std::string cloudId = "100";
1372 const std::string value = "2";
1373 auto rdb = make_shared<RdbStoreMock>();
1374 clouddiskrdbStore_->rdbStore_ = rdb;
1375 auto transaction = make_shared<TransactionMock>();
1376 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1377 EXPECT_EQ(ret, E_RDB);
1378 }
1379
1380 /**
1381 * @tc.name: RecycleSetXattr
1382 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1383 * @tc.type: FUNC
1384 * @tc.require: SR000HRKKA
1385 */
1386 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest3, TestSize.Level1)
1387 {
1388 const std::string name = "test";
1389 const std::string parentCloudId = "100";
1390 const std::string cloudId = "100";
1391 const std::string value = "0";
1392 auto rdb = make_shared<RdbStoreMock>();
1393 clouddiskrdbStore_->rdbStore_ = rdb;
1394 auto transaction = make_shared<TransactionMock>();
1395 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1396 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1397 EXPECT_EQ(ret, E_RDB);
1398 }
1399
1400 /**
1401 * @tc.name: RecycleSetXattr
1402 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1403 * @tc.type: FUNC
1404 * @tc.require: SR000HRKKA
1405 */
1406 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest4, TestSize.Level1)
1407 {
1408 const std::string name = "test";
1409 const std::string parentCloudId = "100";
1410 const std::string cloudId = "100";
1411 const std::string value = "0";
1412 bool preCount = true;
1413 auto rdb = make_shared<RdbStoreMock>();
1414 clouddiskrdbStore_->rdbStore_ = rdb;
1415 auto transaction = make_shared<TransactionMock>();
1416 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1417 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1418 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1419
1420 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1421 EXPECT_EQ(ret, E_RDB);
1422 }
1423
1424 /**
1425 * @tc.name: RecycleSetXattr
1426 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1427 * @tc.type: FUNC
1428 * @tc.require: SR000HRKKA
1429 */
1430 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest5, TestSize.Level1)
1431 {
1432 const std::string name = "test";
1433 const std::string parentCloudId = "100";
1434 const std::string cloudId = "100";
1435 const std::string value = "0";
1436 bool preCount = true;
1437 auto rdb = make_shared<RdbStoreMock>();
1438 clouddiskrdbStore_->rdbStore_ = rdb;
1439 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1440 auto transaction = make_shared<TransactionMock>();
1441 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1442 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1443 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1444 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1445
1446 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1447 EXPECT_EQ(ret, E_RDB);
1448 }
1449
1450 /**
1451 * @tc.name: RecycleSetXattr
1452 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1453 * @tc.type: FUNC
1454 * @tc.require: SR000HRKKA
1455 */
1456 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest6, TestSize.Level1)
1457 {
1458 const std::string name = "test";
1459 const std::string parentCloudId = "mock";
1460 const std::string cloudId = "100";
1461 const std::string value = "1";
1462 bool preCount = true;
1463 auto rdb = make_shared<RdbStoreMock>();
1464 clouddiskrdbStore_->rdbStore_ = rdb;
1465 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1466 auto transaction = make_shared<TransactionMock>();
1467 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1468 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1469 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1470 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1471
1472 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1473 EXPECT_EQ(ret, E_RDB);
1474 }
1475
1476 /**
1477 * @tc.name: CheckIsConflict
1478 * @tc.desc: Verify the CloudDiskRdbStore::CheckIsConflict function
1479 * @tc.type: FUNC
1480 * @tc.require: SR000HRKKA
1481 */
1482 HWTEST_F(CloudDiskRdbStoreTest, CheckIsConflictTest1, TestSize.Level1)
1483 {
1484 const std::string name = "mock";
1485 const std::string parentCloudId = "100";
1486 std::string newName = "test1";
1487 auto rdb = make_shared<RdbStoreMock>();
1488 clouddiskrdbStore_->rdbStore_ = rdb;
1489
1490 int32_t ret = clouddiskrdbStore_->CheckIsConflict(name, parentCloudId, newName);
1491 EXPECT_EQ(ret, E_RDB);
1492 }
1493
1494 /**
1495 * @tc.name: CheckIsConflict
1496 * @tc.desc: Verify the CloudDiskRdbStore::CheckIsConflict function
1497 * @tc.type: FUNC
1498 * @tc.require: SR000HRKKA
1499 */
1500 HWTEST_F(CloudDiskRdbStoreTest, CheckIsConflictTest2, TestSize.Level1)
1501 {
1502 const std::string name = "test";
1503 const std::string parentCloudId = "100";
1504 std::string newName = "test1";
1505 auto rdb = make_shared<RdbStoreMock>();
1506 clouddiskrdbStore_->rdbStore_ = rdb;
1507
1508 int32_t ret = clouddiskrdbStore_->CheckIsConflict(name, parentCloudId, newName);
1509 EXPECT_EQ(ret, E_OK);
1510 }
1511
1512 /**
1513 * @tc.name: RestoreUpdateRdb
1514 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1515 * @tc.type: FUNC
1516 * @tc.require: SR000HRKKA
1517 */
1518 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest1, TestSize.Level1)
1519 {
1520 const std::string cloudId = "100";
1521 const struct RestoreInfo restoreInfo;
1522 ValuesBucket setXattr;
1523 auto rdb = make_shared<RdbStoreMock>();
1524 clouddiskrdbStore_->rdbStore_ = rdb;
1525 auto transaction = make_shared<TransactionMock>();
1526 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1527 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1528
1529 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1530 EXPECT_EQ(ret, E_RDB);
1531 }
1532
1533 /**
1534 * @tc.name: RestoreUpdateRdb
1535 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1536 * @tc.type: FUNC
1537 * @tc.require: SR000HRKKA
1538 */
1539 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest2, TestSize.Level1)
1540 {
1541 const std::string cloudId = "100";
1542 const struct RestoreInfo restoreInfo;
1543 ValuesBucket setXattr;
1544 auto rdb = make_shared<RdbStoreMock>();
1545 clouddiskrdbStore_->rdbStore_ = rdb;
1546 auto transaction = make_shared<TransactionMock>();
1547 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1548 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1549
1550 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1551 EXPECT_EQ(ret, E_OK);
1552 }
1553
1554 /**
1555 * @tc.name: RestoreUpdateRdb
1556 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1557 * @tc.type: FUNC
1558 * @tc.require: SR000HRKKA
1559 */
1560 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest3, TestSize.Level1)
1561 {
1562 const std::string cloudId = "100";
1563 const struct RestoreInfo restoreInfo;
1564 ValuesBucket setXattr;
1565 restoreInfo.parentCloudId == "mock";
1566 auto rdb = make_shared<RdbStoreMock>();
1567 clouddiskrdbStore_->rdbStore_ = rdb;
1568 auto transaction = make_shared<TransactionMock>();
1569 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1570 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1571
1572 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1573 EXPECT_EQ(ret, E_OK);
1574 }
1575
1576 /**
1577 * @tc.name: HandleRestoreXattr
1578 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1579 * @tc.type: FUNC
1580 * @tc.require: SR000HRKKA
1581 */
1582 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest1, TestSize.Level1)
1583 {
1584 const std::string name = "";
1585 const std::string parentCloudId = "";
1586 const std::string cloudId = "100";
1587 bool preCount = true;
1588 auto rdb = make_shared<RdbStoreMock>();
1589 clouddiskrdbStore_->rdbStore_ = rdb;
1590 auto transaction = make_shared<TransactionMock>();
1591 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1592 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1593 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1594
1595 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1596 EXPECT_EQ(ret, E_RDB);
1597 }
1598
1599 /**
1600 * @tc.name: HandleRestoreXattr
1601 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1602 * @tc.type: FUNC
1603 * @tc.require: SR000HRKKA
1604 */
1605 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest2, TestSize.Level1)
1606 {
1607 const std::string name = "";
1608 const std::string parentCloudId = "";
1609 const std::string cloudId = "100";
1610 bool preCount = true;
1611 auto rdb = make_shared<RdbStoreMock>();
1612 clouddiskrdbStore_->rdbStore_ = rdb;
1613 auto transaction = make_shared<TransactionMock>();
1614 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1615 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1616 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1617 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1618 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(1));
1619
1620 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1621 EXPECT_EQ(ret, E_RDB);
1622 }
1623
1624 /**
1625 * @tc.name: HandleRestoreXattr
1626 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1627 * @tc.type: FUNC
1628 * @tc.require: SR000HRKKA
1629 */
1630 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest3, TestSize.Level1)
1631 {
1632 const std::string name = "";
1633 const std::string parentCloudId = "";
1634 const std::string cloudId = "100";
1635 bool preCount = true;
1636 auto rdb = make_shared<RdbStoreMock>();
1637 clouddiskrdbStore_->rdbStore_ = rdb;
1638 auto transaction = make_shared<TransactionMock>();
1639 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1640 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1641 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1642 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1643 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(0));
1644
1645 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1646 EXPECT_EQ(ret, E_RDB);
1647 }
1648
1649 /**
1650 * @tc.name: FavoriteSetXattr
1651 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
1652 * @tc.type: FUNC
1653 * @tc.require: SR000HRKKA
1654 */
1655 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest1, TestSize.Level1)
1656 {
1657 const std::string cloudId = "rootId";
1658 const std::string value = "notnum";
1659 auto rdb = make_shared<RdbStoreMock>();
1660 clouddiskrdbStore_->rdbStore_ = rdb;
1661 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
1662 EXPECT_EQ(ret, EINVAL);
1663 }
1664
1665 /**
1666 * @tc.name: FavoriteSetXattr
1667 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
1668 * @tc.type: FUNC
1669 * @tc.require: SR000HRKKA
1670 */
1671 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest2, TestSize.Level1)
1672 {
1673 const std::string cloudId = "root";
1674 const std::string value = "2";
1675 auto rdb = make_shared<RdbStoreMock>();
1676 clouddiskrdbStore_->rdbStore_ = rdb;
1677 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
1678 EXPECT_EQ(ret, E_RDB);
1679 }
1680
1681 /**
1682 * @tc.name: FavoriteSetXattr
1683 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
1684 * @tc.type: FUNC
1685 * @tc.require: SR000HRKKA
1686 */
1687 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest3, TestSize.Level1)
1688 {
1689 const std::string cloudId = "root";
1690 const std::string value = "0";
1691 auto rdb = make_shared<RdbStoreMock>();
1692 clouddiskrdbStore_->rdbStore_ = rdb;
1693 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
1694
1695 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
1696 EXPECT_EQ(ret, E_RDB);
1697 }
1698
1699 /**
1700 * @tc.name: FavoriteSetXattr
1701 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
1702 * @tc.type: FUNC
1703 * @tc.require: SR000HRKKA
1704 */
1705 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest4, TestSize.Level1)
1706 {
1707 const std::string cloudId = "root";
1708 const std::string value = "1";
1709 auto rdb = make_shared<RdbStoreMock>();
1710 clouddiskrdbStore_->rdbStore_ = rdb;
1711 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_OK));
1712
1713 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
1714 EXPECT_EQ(ret, E_OK);
1715 }
1716
1717 /**
1718 * @tc.name: LocationGetXattr
1719 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
1720 * @tc.type: FUNC
1721 * @tc.require: SR000HRKKA
1722 */
1723 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest1, TestSize.Level1)
1724 {
1725 const std::string cloudId = "";
1726 const std::string key = IS_FAVORITE_XATTR;
1727 std::string value = "";
1728 const std::string name = "test";
1729 const std::string parentCloudId = "rootId";
1730 auto rdb = make_shared<RdbStoreMock>();
1731 clouddiskrdbStore_->rdbStore_ = rdb;
1732 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
1733 EXPECT_EQ(ret, E_INVAL_ARG);
1734 }
1735
1736 /**
1737 * @tc.name: LocationGetXattr
1738 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
1739 * @tc.type: FUNC
1740 * @tc.require: SR000HRKKA
1741 */
1742 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest2, TestSize.Level1)
1743 {
1744 const std::string cloudId = "";
1745 const std::string key = CLOUD_FILE_LOCATION;
1746 std::string value = "";
1747 const std::string name = "mock";
1748 const std::string parentCloudId = "rootId";
1749 auto rdb = make_shared<RdbStoreMock>();
1750 clouddiskrdbStore_->rdbStore_ = rdb;
1751 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
1752 EXPECT_EQ(ret, ENOENT);
1753 }
1754
1755 /**
1756 * @tc.name: LocationGetXattr
1757 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
1758 * @tc.type: FUNC
1759 * @tc.require: SR000HRKKA
1760 */
1761 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest3, TestSize.Level1)
1762 {
1763 const std::string cloudId = "";
1764 const std::string key = CLOUD_FILE_LOCATION;
1765 std::string value = "";
1766 const std::string name = "test";
1767 const std::string parentCloudId = "rootId";
1768 auto rdb = make_shared<RdbStoreMock>();
1769 clouddiskrdbStore_->rdbStore_ = rdb;
1770 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
1771 EXPECT_EQ(ret, E_OK);
1772 }
1773
1774 /**
1775 * @tc.name: FavoriteGetXattr
1776 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
1777 * @tc.type: FUNC
1778 * @tc.require: SR000HRKKA
1779 */
1780 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest1, TestSize.Level1)
1781 {
1782 const std::string cloudId = "";
1783 const std::string key = CLOUD_FILE_LOCATION;
1784 std::string value = "";
1785 auto rdb = make_shared<RdbStoreMock>();
1786 clouddiskrdbStore_->rdbStore_ = rdb;
1787 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
1788 EXPECT_EQ(ret, E_INVAL_ARG);
1789 }
1790
1791 /**
1792 * @tc.name: FavoriteGetXattr
1793 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
1794 * @tc.type: FUNC
1795 * @tc.require: SR000HRKKA
1796 */
1797 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest2, TestSize.Level1)
1798 {
1799 const std::string cloudId = "cloudId";
1800 const std::string key = IS_FAVORITE_XATTR;
1801 std::string value = "";
1802 bool preCount = true;
1803 auto rdb = make_shared<RdbStoreMock>();
1804 clouddiskrdbStore_->rdbStore_ = rdb;
1805 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1806 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1807
1808 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
1809 EXPECT_EQ(ret, E_RDB);
1810 }
1811
1812 /**
1813 * @tc.name: FavoriteGetXattr
1814 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
1815 * @tc.type: FUNC
1816 * @tc.require: SR000HRKKA
1817 */
1818 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest3, TestSize.Level1)
1819 {
1820 const std::string cloudId = "cloudId";
1821 const std::string key = IS_FAVORITE_XATTR;
1822 std::string value = "";
1823 bool preCount = true;
1824 auto rdb = make_shared<RdbStoreMock>();
1825 clouddiskrdbStore_->rdbStore_ = rdb;
1826 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1827 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1828 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1829 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1830
1831 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
1832 EXPECT_EQ(ret, E_RDB);
1833 }
1834
1835 /**
1836 * @tc.name: FavoriteGetXattr
1837 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
1838 * @tc.type: FUNC
1839 * @tc.require: SR000HRKKA
1840 */
1841 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest4, TestSize.Level1)
1842 {
1843 const std::string cloudId = "cloudId";
1844 const std::string key = IS_FAVORITE_XATTR;
1845 std::string value = "";
1846 bool preCount = true;
1847 auto rdb = make_shared<RdbStoreMock>();
1848 clouddiskrdbStore_->rdbStore_ = rdb;
1849 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1850 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1851 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1852 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1853
1854 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
1855 EXPECT_EQ(ret, E_OK);
1856 }
1857
1858 /**
1859 * @tc.name: FileStatusGetXattr
1860 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
1861 * @tc.type: FUNC
1862 * @tc.require: SR000HRKKA
1863 */
1864 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest1, TestSize.Level1)
1865 {
1866 const std::string cloudId = "";
1867 const std::string key = IS_FAVORITE_XATTR;
1868 std::string value = "";
1869 auto rdb = make_shared<RdbStoreMock>();
1870 clouddiskrdbStore_->rdbStore_ = rdb;
1871 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
1872 EXPECT_EQ(ret, E_INVAL_ARG);
1873 }
1874
1875 /**
1876 * @tc.name: FileStatusGetXattr
1877 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
1878 * @tc.type: FUNC
1879 * @tc.require: SR000HRKKA
1880 */
1881 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest2, TestSize.Level1)
1882 {
1883 const std::string cloudId = "cloudId";
1884 const std::string key = IS_FILE_STATUS_XATTR;
1885 std::string value = "";
1886 bool preCount = true;
1887 auto rdb = make_shared<RdbStoreMock>();
1888 clouddiskrdbStore_->rdbStore_ = rdb;
1889 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1890 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1891
1892 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
1893 EXPECT_EQ(ret, E_RDB);
1894 }
1895
1896 /**
1897 * @tc.name: FileStatusGetXattr
1898 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
1899 * @tc.type: FUNC
1900 * @tc.require: SR000HRKKA
1901 */
1902 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest3, TestSize.Level1)
1903 {
1904 const std::string cloudId = "cloudId";
1905 const std::string key = IS_FILE_STATUS_XATTR;
1906 std::string value = "";
1907 bool preCount = true;
1908 auto rdb = make_shared<RdbStoreMock>();
1909 clouddiskrdbStore_->rdbStore_ = rdb;
1910 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1911 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1912 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1913 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1914
1915 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
1916 EXPECT_EQ(ret, E_RDB);
1917 }
1918
1919 /**
1920 * @tc.name: FileStatusGetXattr
1921 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
1922 * @tc.type: FUNC
1923 * @tc.require: SR000HRKKA
1924 */
1925 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest4, TestSize.Level1)
1926 {
1927 const std::string cloudId = "cloudId";
1928 const std::string key = IS_FILE_STATUS_XATTR;
1929 std::string value = "";
1930 bool preCount = true;
1931 auto rdb = make_shared<RdbStoreMock>();
1932 clouddiskrdbStore_->rdbStore_ = rdb;
1933 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1934 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1935 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1936 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1937
1938 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
1939 EXPECT_EQ(ret, E_OK);
1940 }
1941
1942 /**
1943 * @tc.name: GetExtAttrValue
1944 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
1945 * @tc.type: FUNC
1946 */
1947 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest1, TestSize.Level1)
1948 {
1949 const std::string cloudId = "";
1950 const std::string key = "";
1951 std::string value = "";
1952 auto rdb = make_shared<RdbStoreMock>();
1953 clouddiskrdbStore_->rdbStore_ = rdb;
1954 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
1955 EXPECT_EQ(ret, E_INVAL_ARG);
1956 }
1957
1958 /**
1959 * @tc.name: GetExtAttrValue
1960 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
1961 * @tc.type: FUNC
1962 */
1963 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest2, TestSize.Level1)
1964 {
1965 const std::string cloudId = "100";
1966 const std::string key = "100";
1967 std::string value = "100";
1968 bool preCount = true;
1969 auto rdb = make_shared<RdbStoreMock>();
1970 clouddiskrdbStore_->rdbStore_ = rdb;
1971 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1972 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1973
1974 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
1975 EXPECT_EQ(ret, E_RDB);
1976 }
1977
1978 /**
1979 * @tc.name: GetExtAttr
1980 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
1981 * @tc.type: FUNC
1982 */
1983 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest1, TestSize.Level1)
1984 {
1985 const std::string cloudId = "";
1986 std::string value = "";
1987 int32_t pos = 0;
1988 auto rdb = make_shared<RdbStoreMock>();
1989 clouddiskrdbStore_->rdbStore_ = rdb;
1990 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
1991 EXPECT_EQ(ret, E_INVAL_ARG);
1992 }
1993
1994 /**
1995 * @tc.name: GetExtAttr
1996 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
1997 * @tc.type: FUNC
1998 */
1999 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest2, TestSize.Level1)
2000 {
2001 const std::string cloudId = "100";
2002 std::string value = "mock";
2003 int32_t pos = 0;
2004 bool preCount = true;
2005 auto rdb = make_shared<RdbStoreMock>();
2006 clouddiskrdbStore_->rdbStore_ = rdb;
2007 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2008 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2009
2010 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
2011 EXPECT_EQ(ret, E_RDB);
2012 }
2013
2014 /**
2015 * @tc.name: GetExtAttr
2016 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2017 * @tc.type: FUNC
2018 */
2019 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest3, TestSize.Level1)
2020 {
2021 const std::string cloudId = "100";
2022 std::string value = "";
2023 int32_t pos = 0;
2024 bool preCount = true;
2025 auto rdb = make_shared<RdbStoreMock>();
2026 clouddiskrdbStore_->rdbStore_ = rdb;
2027 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2028 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2029 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2030 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2031
2032 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
2033 EXPECT_EQ(ret, E_RDB);
2034 }
2035
2036 /**
2037 * @tc.name: GetExtAttr
2038 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2039 * @tc.type: FUNC
2040 */
2041 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest4, TestSize.Level1)
2042 {
2043 const std::string cloudId = "100";
2044 std::string value = "mock";
2045 int32_t pos = 0;
2046 bool preCount = true;
2047 auto rdb = make_shared<RdbStoreMock>();
2048 clouddiskrdbStore_->rdbStore_ = rdb;
2049 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2050 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2051 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2052 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2053
2054 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
2055 EXPECT_EQ(ret, E_RDB);
2056 }
2057
2058 /**
2059 * @tc.name: GetExtAttr
2060 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2061 * @tc.type: FUNC
2062 */
2063 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest5, TestSize.Level1)
2064 {
2065 const std::string cloudId = "100";
2066 std::string value = "";
2067 int32_t pos = -1;
2068 bool preCount = true;
2069 auto rdb = make_shared<RdbStoreMock>();
2070 clouddiskrdbStore_->rdbStore_ = rdb;
2071 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2072 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2073 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2074 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2075
2076 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
2077 EXPECT_EQ(ret, E_RDB);
2078 }
2079
2080 /**
2081 * @tc.name: GetExtAttr
2082 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2083 * @tc.type: FUNC
2084 */
2085 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest6, TestSize.Level1)
2086 {
2087 const std::string cloudId = "100";
2088 std::string value = "";
2089 int32_t pos = 1;
2090 bool preCount = true;
2091 auto rdb = make_shared<RdbStoreMock>();
2092 clouddiskrdbStore_->rdbStore_ = rdb;
2093 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2094 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2095 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2096 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2097
2098 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos);
2099 EXPECT_EQ(ret, E_OK);
2100 }
2101
2102 /**
2103 * @tc.name: GetXAttr
2104 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2105 * @tc.type: FUNC
2106 * @tc.require: SR000HRKKA
2107 */
2108 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest1, TestSize.Level1)
2109 {
2110 const std::string cloudId = "";
2111 const std::string key = CLOUD_FILE_LOCATION;
2112 std::string value = "";
2113 CacheNode node;
2114 node.fileName = "test";
2115 node.parentCloudId = "100";
2116 auto rdb = make_shared<RdbStoreMock>();
2117 clouddiskrdbStore_->rdbStore_ = rdb;
2118 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2119 EXPECT_EQ(ret, E_OK);
2120 }
2121
2122 /**
2123 * @tc.name: GetXAttr
2124 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2125 * @tc.type: FUNC
2126 * @tc.require: SR000HRKKA
2127 */
2128 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest2, TestSize.Level1)
2129 {
2130 const std::string cloudId = "";
2131 const std::string key = IS_FAVORITE_XATTR;
2132 std::string value = "";
2133 auto rdb = make_shared<RdbStoreMock>();
2134 clouddiskrdbStore_->rdbStore_ = rdb;
2135 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2136 EXPECT_EQ(ret, E_INVAL_ARG);
2137 }
2138
2139 /**
2140 * @tc.name: GetXAttr
2141 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2142 * @tc.type: FUNC
2143 * @tc.require: SR000HRKKA
2144 */
2145 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest3, TestSize.Level1)
2146 {
2147 const std::string cloudId = "";
2148 const std::string key = IS_FILE_STATUS_XATTR;
2149 std::string value = "";
2150 auto rdb = make_shared<RdbStoreMock>();
2151 clouddiskrdbStore_->rdbStore_ = rdb;
2152 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2153 EXPECT_EQ(ret, E_INVAL_ARG);
2154 }
2155
2156 /**
2157 * @tc.name: GetXAttr
2158 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2159 * @tc.type: FUNC
2160 * @tc.require: SR000HRKKA
2161 */
2162 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest4, TestSize.Level1)
2163 {
2164 const std::string cloudId = "";
2165 const std::string key = CLOUD_EXT_ATTR;
2166 std::string value = "";
2167 auto rdb = make_shared<RdbStoreMock>();
2168 clouddiskrdbStore_->rdbStore_ = rdb;
2169 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2170 EXPECT_EQ(ret, E_INVAL_ARG);
2171 }
2172
2173 /**
2174 * @tc.name: GetXAttr
2175 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2176 * @tc.type: FUNC
2177 * @tc.require: SR000HRKKA
2178 */
2179 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest5, TestSize.Level1)
2180 {
2181 const std::string cloudId = "";
2182 const std::string key = CLOUD_CLOUD_RECYCLE_XATTR;
2183 std::string value = "";
2184 auto rdb = make_shared<RdbStoreMock>();
2185 clouddiskrdbStore_->rdbStore_ = rdb;
2186 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2187 EXPECT_EQ(ret, ENOSYS);
2188 }
2189
2190 /**
2191 * @tc.name: ExtAttributeSetXattr
2192 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2193 * @tc.type: FUNC
2194 */
2195 HWTEST_F(CloudDiskRdbStoreTest, ExtAttributeSetXattrTest1, TestSize.Level1)
2196 {
2197 const std::string cloudId = "root";
2198 const std::string key = "user.cloud.test1";
2199 const std::string value = "1";
2200 bool preCount = true;
2201 auto rdb = make_shared<RdbStoreMock>();
2202 clouddiskrdbStore_->rdbStore_ = rdb;
2203 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2204 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2205 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2206 auto transaction = make_shared<TransactionMock>();
2207 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
2208 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2209 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
2210
2211 int32_t ret = clouddiskrdbStore_->ExtAttributeSetXattr(cloudId, value, key);
2212 EXPECT_EQ(ret, E_RDB);
2213 }
2214
2215 /**
2216 * @tc.name: ExtAttributeSetXattr
2217 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2218 * @tc.type: FUNC
2219 */
2220 HWTEST_F(CloudDiskRdbStoreTest, ExtAttributeSetXattrTest2, TestSize.Level1)
2221 {
2222 const std::string cloudId = "root";
2223 const std::string key = "user.cloud.test1";
2224 const std::string value = "1";
2225 bool preCount = true;
2226 auto rdb = make_shared<RdbStoreMock>();
2227 clouddiskrdbStore_->rdbStore_ = rdb;
2228 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2229 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2230 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2231 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2232 auto transaction = make_shared<TransactionMock>();
2233 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
2234 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
2235
2236 int32_t ret = clouddiskrdbStore_->ExtAttributeSetXattr(cloudId, value, key);
2237 EXPECT_EQ(ret, E_OK);
2238 }
2239
2240 /**
2241 * @tc.name: SetXAttr
2242 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
2243 * @tc.type: FUNC
2244 * @tc.require: SR000HRKKA
2245 */
2246 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest1, TestSize.Level1)
2247 {
2248 const std::string cloudId = "100";
2249 const std::string key = CLOUD_FILE_LOCATION;
2250 const std::string value = "notnum";
2251 const std::string name = "test";
2252 const std::string parentCloudId = "100";
2253 auto rdb = make_shared<RdbStoreMock>();
2254 clouddiskrdbStore_->rdbStore_ = rdb;
2255 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
2256 EXPECT_EQ(ret, E_INVAL_ARG);
2257 }
2258
2259 /**
2260 * @tc.name: SetXAttr
2261 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
2262 * @tc.type: FUNC
2263 * @tc.require: SR000HRKKA
2264 */
2265 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest2, TestSize.Level1)
2266 {
2267 const std::string cloudId = "100";
2268 const std::string key = CLOUD_CLOUD_RECYCLE_XATTR;
2269 const std::string value = "notnum";
2270 const std::string name = "test";
2271 const std::string parentCloudId = "100";
2272 auto rdb = make_shared<RdbStoreMock>();
2273 clouddiskrdbStore_->rdbStore_ = rdb;
2274 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
2275 EXPECT_EQ(ret, EINVAL);
2276 }
2277
2278 /**
2279 * @tc.name: SetXAttr
2280 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
2281 * @tc.type: FUNC
2282 * @tc.require: SR000HRKKA
2283 */
2284 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest3, TestSize.Level1)
2285 {
2286 const std::string cloudId = "100";
2287 const std::string key = IS_FAVORITE_XATTR;
2288 const std::string value = "notnum";
2289 const std::string name = "test";
2290 const std::string parentCloudId = "100";
2291 auto rdb = make_shared<RdbStoreMock>();
2292 clouddiskrdbStore_->rdbStore_ = rdb;
2293 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
2294 EXPECT_EQ(ret, EINVAL);
2295 }
2296
2297 /**
2298 * @tc.name: SetXAttr
2299 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
2300 * @tc.type: FUNC
2301 * @tc.require: SR000HRKKA
2302 */
2303 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest4, TestSize.Level1)
2304 {
2305 const std::string cloudId = "100";
2306 const std::string key = CLOUD_EXT_ATTR;
2307 const std::string value = "notnum";
2308 const std::string name = "test";
2309 const std::string parentCloudId = "100";
2310 auto rdb = make_shared<RdbStoreMock>();
2311 clouddiskrdbStore_->rdbStore_ = rdb;
2312 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
2313 EXPECT_EQ(ret, E_RDB);
2314 }
2315
2316 /**
2317 * @tc.name: SetXAttr
2318 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
2319 * @tc.type: FUNC
2320 * @tc.require: SR000HRKKA
2321 */
2322 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest5, TestSize.Level1)
2323 {
2324 const std::string cloudId = "100";
2325 const std::string key = IS_FILE_STATUS_XATTR;
2326 const std::string value = "notnum";
2327 const std::string name = "test";
2328 const std::string parentCloudId = "100";
2329 auto rdb = make_shared<RdbStoreMock>();
2330 clouddiskrdbStore_->rdbStore_ = rdb;
2331 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
2332 EXPECT_EQ(ret, ENOSYS);
2333 }
2334
2335 /**
2336 * @tc.name: Rename
2337 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
2338 * @tc.type: FUNC
2339 * @tc.require: SR000HRKKA
2340 */
2341 HWTEST_F(CloudDiskRdbStoreTest, RenameTest1, TestSize.Level1)
2342 {
2343 const std::string oldParentCloudId = "100";
2344 const std::string oldFileName = "test";
2345 const std::string newParentCloudId = "100";
2346 const std::string newFileName = "";
2347 auto rdb = make_shared<RdbStoreMock>();
2348 clouddiskrdbStore_->rdbStore_ = rdb;
2349 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName);
2350 EXPECT_EQ(ret, EINVAL);
2351 }
2352
2353 /**
2354 * @tc.name: Rename
2355 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
2356 * @tc.type: FUNC
2357 * @tc.require: SR000HRKKA
2358 */
2359 HWTEST_F(CloudDiskRdbStoreTest, RenameTest2, TestSize.Level1)
2360 {
2361 const std::string oldParentCloudId = "";
2362 const std::string oldFileName = "";
2363 const std::string newParentCloudId = "";
2364 const std::string newFileName = "test";
2365 auto rdb = make_shared<RdbStoreMock>();
2366 clouddiskrdbStore_->rdbStore_ = rdb;
2367 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName);
2368 EXPECT_EQ(ret, E_INVAL_ARG);
2369 }
2370
2371 /**
2372 * @tc.name: Rename
2373 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
2374 * @tc.type: FUNC
2375 * @tc.require: SR000HRKKA
2376 */
2377 HWTEST_F(CloudDiskRdbStoreTest, RenameTest3, TestSize.Level1)
2378 {
2379 const std::string oldParentCloudId = "100";
2380 const std::string oldFileName = "mock";
2381 const std::string newParentCloudId = "100";
2382 const std::string newFileName = " test";
2383 auto rdb = make_shared<RdbStoreMock>();
2384 clouddiskrdbStore_->rdbStore_ = rdb;
2385 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName);
2386 EXPECT_EQ(ret, EINVAL);
2387 }
2388
2389 /**
2390 * @tc.name: Rename
2391 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
2392 * @tc.type: FUNC
2393 * @tc.require: SR000HRKKA
2394 */
2395 HWTEST_F(CloudDiskRdbStoreTest, RenameTest4, TestSize.Level1)
2396 {
2397 const std::string oldParentCloudId = "100";
2398 const std::string oldFileName = "test";
2399 const std::string newParentCloudId = "100";
2400 const std::string newFileName = " test";
2401 auto rdb = make_shared<RdbStoreMock>();
2402 clouddiskrdbStore_->rdbStore_ = rdb;
2403 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName);
2404 EXPECT_EQ(ret, EINVAL);
2405 }
2406
2407 /**
2408 * @tc.name: Rename
2409 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
2410 * @tc.type: FUNC
2411 * @tc.require: SR000HRKKA
2412 */
2413 HWTEST_F(CloudDiskRdbStoreTest, RenameTest5, TestSize.Level1)
2414 {
2415 const std::string oldParentCloudId = "100";
2416 const std::string oldFileName = "test";
2417 const std::string newParentCloudId = "100";
2418 const std::string newFileName = "mock";
2419 auto rdb = make_shared<RdbStoreMock>();
2420 clouddiskrdbStore_->rdbStore_ = rdb;
2421 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName);
2422 EXPECT_EQ(ret, EINVAL);
2423 }
2424
2425 /**
2426 * @tc.name: GetHasChild
2427 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
2428 * @tc.type: FUNC
2429 * @tc.require: SR000HRKKA
2430 */
2431 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest1, TestSize.Level1)
2432 {
2433 const std::string cloudId = "100";
2434 bool hasChild = true;
2435 bool preCount = true;
2436 auto rdb = make_shared<RdbStoreMock>();
2437 clouddiskrdbStore_->rdbStore_ = rdb;
2438 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2439 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2440 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
2441 EXPECT_EQ(ret, E_RDB);
2442 }
2443
2444 /**
2445 * @tc.name: GetHasChild
2446 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
2447 * @tc.type: FUNC
2448 * @tc.require: SR000HRKKA
2449 */
2450 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest2, TestSize.Level1)
2451 {
2452 const std::string cloudId = "100";
2453 bool hasChild = true;
2454 bool preCount = true;
2455 auto rdb = make_shared<RdbStoreMock>();
2456 clouddiskrdbStore_->rdbStore_ = rdb;
2457 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2458 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2459 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2460 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2461 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
2462 EXPECT_EQ(ret, E_OK);
2463 }
2464
2465 /**
2466 * @tc.name: GetHasChild
2467 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
2468 * @tc.type: FUNC
2469 * @tc.require: SR000HRKKA
2470 */
2471 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest3, TestSize.Level1)
2472 {
2473 const std::string cloudId = "100";
2474 bool hasChild = true;
2475 bool preCount = true;
2476 auto rdb = make_shared<RdbStoreMock>();
2477 clouddiskrdbStore_->rdbStore_ = rdb;
2478 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2479 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2480 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2481 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2482 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
2483 EXPECT_EQ(ret, E_OK);
2484 }
2485
2486 /**
2487 * @tc.name: UnlinkSynced
2488 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkSynced function
2489 * @tc.type: FUNC
2490 * @tc.require: SR000HRKKA
2491 */
2492 HWTEST_F(CloudDiskRdbStoreTest, UnlinkSyncedTest1, TestSize.Level1)
2493 {
2494 const std::string cloudId = "100";
2495 auto rdb = make_shared<RdbStoreMock>();
2496 clouddiskrdbStore_->rdbStore_ = rdb;
2497 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_RDB));
2498
2499 int32_t ret = clouddiskrdbStore_->UnlinkSynced(cloudId);
2500 EXPECT_EQ(ret, E_RDB);
2501 }
2502
2503 /**
2504 * @tc.name: UnlinkSynced
2505 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkSynced function
2506 * @tc.type: FUNC
2507 * @tc.require: SR000HRKKA
2508 */
2509 HWTEST_F(CloudDiskRdbStoreTest, UnlinkSyncedTest2, TestSize.Level1)
2510 {
2511 const std::string cloudId = "100";
2512 auto rdb = make_shared<RdbStoreMock>();
2513 clouddiskrdbStore_->rdbStore_ = rdb;
2514 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
2515
2516 int32_t ret = clouddiskrdbStore_->UnlinkSynced(cloudId);
2517 EXPECT_EQ(ret, E_OK);
2518 }
2519
2520 /**
2521 * @tc.name: UnlinkLocal
2522 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkLocal function
2523 * @tc.type: FUNC
2524 * @tc.require: SR000HRKKA
2525 */
2526 HWTEST_F(CloudDiskRdbStoreTest, UnlinkLocalTest1, TestSize.Level1)
2527 {
2528 const std::string cloudId = "100";
2529 auto rdb = make_shared<RdbStoreMock>();
2530 clouddiskrdbStore_->rdbStore_ = rdb;
2531 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_RDB));
2532
2533 int32_t ret = clouddiskrdbStore_->UnlinkLocal(cloudId);
2534 EXPECT_EQ(ret, E_RDB);
2535 }
2536
2537 /**
2538 * @tc.name: UnlinkLocal
2539 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkLocal function
2540 * @tc.type: FUNC
2541 * @tc.require: SR000HRKKA
2542 */
2543 HWTEST_F(CloudDiskRdbStoreTest, UnlinkLocalTest2, TestSize.Level1)
2544 {
2545 const std::string cloudId = "100";
2546 auto rdb = make_shared<RdbStoreMock>();
2547 clouddiskrdbStore_->rdbStore_ = rdb;
2548 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
2549
2550 int32_t ret = clouddiskrdbStore_->UnlinkLocal(cloudId);
2551 EXPECT_EQ(ret, E_OK);
2552 }
2553
2554 /**
2555 * @tc.name: Unlink
2556 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
2557 * @tc.type: FUNC
2558 * @tc.require: SR000HRKKA
2559 */
2560 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest1, TestSize.Level1)
2561 {
2562 std::string cloudId = "";
2563 const int32_t noUpload = 0;
2564 auto rdb = make_shared<RdbStoreMock>();
2565 clouddiskrdbStore_->rdbStore_ = rdb;
2566 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
2567 EXPECT_EQ(ret, E_INVAL_ARG);
2568 }
2569
2570 /**
2571 * @tc.name: Unlink
2572 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
2573 * @tc.type: FUNC
2574 * @tc.require: SR000HRKKA
2575 */
2576 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest2, TestSize.Level1)
2577 {
2578 const int32_t noUpload = 1;
2579 std::string cloudId = "100";
2580 auto rdb = make_shared<RdbStoreMock>();
2581 clouddiskrdbStore_->rdbStore_ = rdb;
2582 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
2583 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
2584 EXPECT_EQ(ret, E_OK);
2585 }
2586
2587 /**
2588 * @tc.name: Unlink
2589 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
2590 * @tc.type: FUNC
2591 * @tc.require: SR000HRKKA
2592 */
2593 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest3, TestSize.Level1)
2594 {
2595 const int32_t noUpload = 0;
2596 std::string cloudId = "100";
2597 auto rdb = make_shared<RdbStoreMock>();
2598 clouddiskrdbStore_->rdbStore_ = rdb;
2599 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
2600 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
2601 EXPECT_EQ(ret, E_OK);
2602 }
2603
2604 /**
2605 * @tc.name: GetDirtyType
2606 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
2607 * @tc.type: FUNC
2608 * @tc.require: SR000HRKKA
2609 */
2610 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest1, TestSize.Level1)
2611 {
2612 int32_t dirtyType = 0;
2613 std::string cloudId = "100";
2614 bool preCount = true;
2615 auto rdb = make_shared<RdbStoreMock>();
2616 clouddiskrdbStore_->rdbStore_ = rdb;
2617 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2618 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2619
2620 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
2621 EXPECT_EQ(ret, E_RDB);
2622 }
2623
2624 /**
2625 * @tc.name: GetDirtyType
2626 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
2627 * @tc.type: FUNC
2628 * @tc.require: SR000HRKKA
2629 */
2630 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest2, TestSize.Level1)
2631 {
2632 int32_t dirtyType = 0;
2633 std::string cloudId = "100";
2634 bool preCount = true;
2635 auto rdb = make_shared<RdbStoreMock>();
2636 clouddiskrdbStore_->rdbStore_ = rdb;
2637 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2638 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2639 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2640 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2641
2642 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
2643 EXPECT_EQ(ret, E_RDB);
2644 }
2645
2646 /**
2647 * @tc.name: GetDirtyType
2648 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
2649 * @tc.type: FUNC
2650 * @tc.require: SR000HRKKA
2651 */
2652 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest3, TestSize.Level1)
2653 {
2654 int32_t dirtyType = -1;
2655 std::string cloudId = "100";
2656 bool preCount = true;
2657 auto rdb = make_shared<RdbStoreMock>();
2658 clouddiskrdbStore_->rdbStore_ = rdb;
2659 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2660 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2661 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2662 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2663
2664 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
2665 EXPECT_EQ(ret, E_RDB);
2666 }
2667
2668 /**
2669 * @tc.name: GetDirtyType
2670 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
2671 * @tc.type: FUNC
2672 * @tc.require: SR000HRKKA
2673 */
2674 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest4, TestSize.Level1)
2675 {
2676 int32_t dirtyType = 1;
2677 std::string cloudId = "100";
2678 bool preCount = true;
2679 auto rdb = make_shared<RdbStoreMock>();
2680 clouddiskrdbStore_->rdbStore_ = rdb;
2681 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2682 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2683 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2684 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2685
2686 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
2687 EXPECT_EQ(ret, E_OK);
2688 }
2689
2690 /**
2691 * @tc.name: GetCurNode
2692 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
2693 * @tc.type: FUNC
2694 * @tc.require: SR000HRKKA
2695 */
2696 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest1, TestSize.Level1)
2697 {
2698 CacheNode curNode;
2699 std::string cloudId = "";
2700 auto rdb = make_shared<RdbStoreMock>();
2701 clouddiskrdbStore_->rdbStore_ = rdb;
2702 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
2703 EXPECT_EQ(ret, E_INVAL_ARG);
2704 }
2705
2706 /**
2707 * @tc.name: GetCurNode
2708 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
2709 * @tc.type: FUNC
2710 * @tc.require: SR000HRKKA
2711 */
2712 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest2, TestSize.Level1)
2713 {
2714 CacheNode curNode;
2715 std::string cloudId = "100";
2716 bool preCount = true;
2717 auto rdb = make_shared<RdbStoreMock>();
2718 clouddiskrdbStore_->rdbStore_ = rdb;
2719 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2720 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2721
2722 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
2723 EXPECT_EQ(ret, E_RDB);
2724 }
2725
2726 /**
2727 * @tc.name: GetCurNode
2728 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
2729 * @tc.type: FUNC
2730 * @tc.require: SR000HRKKA
2731 */
2732 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest3, TestSize.Level1)
2733 {
2734 CacheNode curNode;
2735 std::string cloudId = "100";
2736 bool preCount = true;
2737 auto rdb = make_shared<RdbStoreMock>();
2738 clouddiskrdbStore_->rdbStore_ = rdb;
2739 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2740 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2741 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2742 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2743
2744 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
2745 EXPECT_EQ(ret, E_RDB);
2746 }
2747
2748 /**
2749 * @tc.name: GetCurNode
2750 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
2751 * @tc.type: FUNC
2752 * @tc.require: SR000HRKKA
2753 */
2754 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest4, TestSize.Level1)
2755 {
2756 CacheNode curNode;
2757 std::string cloudId = "100";
2758 bool preCount = true;
2759 auto rdb = make_shared<RdbStoreMock>();
2760 clouddiskrdbStore_->rdbStore_ = rdb;
2761 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2762 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2763 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2764 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2765 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_RDB));
2766
2767 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
2768 EXPECT_EQ(ret, E_RDB);
2769 }
2770
2771 /**
2772 * @tc.name: GetCurNode
2773 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
2774 * @tc.type: FUNC
2775 * @tc.require: SR000HRKKA
2776 */
2777 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest5, TestSize.Level1)
2778 {
2779 CacheNode curNode;
2780 std::string cloudId = "100";
2781 bool preCount = true;
2782 auto rdb = make_shared<RdbStoreMock>();
2783 clouddiskrdbStore_->rdbStore_ = rdb;
2784 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2785 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2786 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2787 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2788 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
2789
2790 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
2791 EXPECT_EQ(ret, E_OK);
2792 }
2793
2794 /**
2795 * @tc.name: GetParentNode
2796 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
2797 * @tc.type: FUNC
2798 * @tc.require: SR000HRKKA
2799 */
2800 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest1, TestSize.Level1)
2801 {
2802 const std::string parentCloudId = "";
2803 std::string nextCloudId = "100";
2804 std::string fileName = "test";
2805 auto rdb = make_shared<RdbStoreMock>();
2806 clouddiskrdbStore_->rdbStore_ = rdb;
2807
2808 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
2809 EXPECT_EQ(ret, E_INVAL_ARG);
2810 }
2811
2812 /**
2813 * @tc.name: GetParentNode
2814 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
2815 * @tc.type: FUNC
2816 * @tc.require: SR000HRKKA
2817 */
2818 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest2, TestSize.Level1)
2819 {
2820 const std::string parentCloudId = "100";
2821 std::string nextCloudId = "100";
2822 std::string fileName = "test";
2823 bool preCount = true;
2824 auto rdb = make_shared<RdbStoreMock>();
2825 clouddiskrdbStore_->rdbStore_ = rdb;
2826 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2827 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2828
2829 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
2830 EXPECT_EQ(ret, E_RDB);
2831 }
2832
2833 /**
2834 * @tc.name: GetParentNode
2835 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
2836 * @tc.type: FUNC
2837 * @tc.require: SR000HRKKA
2838 */
2839 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest3, TestSize.Level1)
2840 {
2841 const std::string parentCloudId = "100";
2842 std::string nextCloudId = "100";
2843 std::string fileName = "test";
2844 bool preCount = true;
2845 auto rdb = make_shared<RdbStoreMock>();
2846 clouddiskrdbStore_->rdbStore_ = rdb;
2847 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2848 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2849 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2850 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2851
2852 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
2853 EXPECT_EQ(ret, E_RDB);
2854 }
2855
2856 /**
2857 * @tc.name: GetParentNode
2858 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
2859 * @tc.type: FUNC
2860 * @tc.require: SR000HRKKA
2861 */
2862 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest4, TestSize.Level1)
2863 {
2864 const std::string parentCloudId = "100";
2865 std::string nextCloudId = "100";
2866 std::string fileName = "test";
2867 bool preCount = true;
2868 auto rdb = make_shared<RdbStoreMock>();
2869 clouddiskrdbStore_->rdbStore_ = rdb;
2870 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2871 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2872 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2873 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2874 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_RDB));
2875
2876 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
2877 EXPECT_EQ(ret, E_RDB);
2878 }
2879
2880 /**
2881 * @tc.name: GetParentNode
2882 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
2883 * @tc.type: FUNC
2884 * @tc.require: SR000HRKKA
2885 */
2886 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest5, TestSize.Level1)
2887 {
2888 const std::string parentCloudId = "100";
2889 std::string nextCloudId = "100";
2890 std::string fileName = "test";
2891 bool preCount = true;
2892 auto rdb = make_shared<RdbStoreMock>();
2893 clouddiskrdbStore_->rdbStore_ = rdb;
2894 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2895 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2896 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2897 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2898 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
2899
2900 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
2901 EXPECT_EQ(ret, E_OK);
2902 }
2903
2904 /**
2905 * @tc.name: GetUriFromDB
2906 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
2907 * @tc.type: FUNC
2908 * @tc.require: SR000HRKKA
2909 */
2910 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest1, TestSize.Level1)
2911 {
2912 const std::string parentCloudId = "";
2913 std::string uri = "100";
2914 auto rdb = make_shared<RdbStoreMock>();
2915 clouddiskrdbStore_->rdbStore_ = rdb;
2916
2917 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
2918 EXPECT_EQ(ret, E_OK);
2919 }
2920
2921 /**
2922 * @tc.name: GetUriFromDB
2923 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
2924 * @tc.type: FUNC
2925 * @tc.require: SR000HRKKA
2926 */
2927 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest2, TestSize.Level1)
2928 {
2929 const std::string parentCloudId = "100";
2930 std::string uri = "100";
2931 bool preCount = true;
2932 auto rdb = make_shared<RdbStoreMock>();
2933 clouddiskrdbStore_->rdbStore_ = rdb;
2934 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2935 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2936
2937 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
2938 EXPECT_EQ(ret, E_RDB);
2939 }
2940
2941 /**
2942 * @tc.name: GetUriFromDB
2943 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
2944 * @tc.type: FUNC
2945 * @tc.require: SR000HRKKA
2946 */
2947 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest3, TestSize.Level1)
2948 {
2949 const std::string parentCloudId = "100";
2950 std::string uri = "100";
2951 bool preCount = true;
2952 auto rdb = make_shared<RdbStoreMock>();
2953 clouddiskrdbStore_->rdbStore_ = rdb;
2954 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2955 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2956 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2957 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2958 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
2959
2960 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
2961 EXPECT_EQ(ret, E_OK);
2962 }
2963
2964 /**
2965 * @tc.name: GetNotifyUri
2966 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
2967 * @tc.type: FUNC
2968 * @tc.require: SR000HRKKA
2969 */
2970 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest1, TestSize.Level1)
2971 {
2972 CacheNode cacheNode;
2973 std::string uri = "100";
2974 auto rdb = make_shared<RdbStoreMock>();
2975 clouddiskrdbStore_->rdbStore_ = rdb;
2976 clouddiskrdbStore_->rootId_ = "";
2977 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
2978 EXPECT_EQ(ret, E_INVAL_ARG);
2979 }
2980
2981 /**
2982 * @tc.name: GetNotifyUri
2983 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
2984 * @tc.type: FUNC
2985 * @tc.require: SR000HRKKA
2986 */
2987 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest2, TestSize.Level1)
2988 {
2989 CacheNode cacheNode;
2990 std::string uri = "test";
2991 auto rdb = make_shared<RdbStoreMock>();
2992 clouddiskrdbStore_->rdbStore_ = rdb;
2993 clouddiskrdbStore_->rootId_ = "rootId";
2994 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
2995 EXPECT_EQ(ret, E_OK);
2996 }
2997
2998 /**
2999 * @tc.name: GetNotifyUri
3000 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3001 * @tc.type: FUNC
3002 * @tc.require: SR000HRKKA
3003 */
3004 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest3, TestSize.Level1)
3005 {
3006 CacheNode cacheNode;
3007 std::string uri = "mock";
3008 auto rdb = make_shared<RdbStoreMock>();
3009 clouddiskrdbStore_->rdbStore_ = rdb;
3010 clouddiskrdbStore_->rootId_ = "rootId";
3011 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
3012 EXPECT_EQ(ret, E_OK);
3013 }
3014
3015 /**
3016 * @tc.name: GetNotifyUri
3017 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3018 * @tc.type: FUNC
3019 * @tc.require: SR000HRKKA
3020 */
3021 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest4, TestSize.Level1)
3022 {
3023 CacheNode cacheNode;
3024 cacheNode.parentCloudId = "root";
3025 std::string uri = "mock";
3026 bool preCount = true;
3027 auto rdb = make_shared<RdbStoreMock>();
3028 clouddiskrdbStore_->rdbStore_ = rdb;
3029 clouddiskrdbStore_->rootId_ = "rootId";
3030 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3031 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3032
3033 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
3034 EXPECT_EQ(ret, E_RDB);
3035 }
3036
3037 /**
3038 * @tc.name: GetNotifyData
3039 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyData function
3040 * @tc.type: FUNC
3041 * @tc.require: SR000HRKKA
3042 */
3043 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyDataTest1, TestSize.Level1)
3044 {
3045 CacheNode cacheNode;
3046 NotifyData notifyData;
3047 notifyData.uri = "mock";
3048 auto rdb = make_shared<RdbStoreMock>();
3049 clouddiskrdbStore_->rdbStore_ = rdb;
3050 clouddiskrdbStore_->rootId_ = "";
3051
3052 int32_t ret = clouddiskrdbStore_->GetNotifyData(cacheNode, notifyData);
3053 EXPECT_EQ(ret, E_INVAL_ARG);
3054 }
3055
3056 /**
3057 * @tc.name: GetNotifyData
3058 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyData function
3059 * @tc.type: FUNC
3060 * @tc.require: SR000HRKKA
3061 */
3062 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyDataTest2, TestSize.Level1)
3063 {
3064 CacheNode cacheNode;
3065 NotifyData notifyData;
3066 notifyData.uri = "mock";
3067 auto rdb = make_shared<RdbStoreMock>();
3068 clouddiskrdbStore_->rdbStore_ = rdb;
3069 clouddiskrdbStore_->rootId_ = "rootId";
3070
3071 int32_t ret = clouddiskrdbStore_->GetNotifyData(cacheNode, notifyData);
3072 EXPECT_EQ(ret, E_OK);
3073 }
3074
3075 /**
3076 * @tc.name: CheckRootIdValid
3077 * @tc.desc: Verify the CloudDiskRdbStore::CheckRootIdValid function
3078 * @tc.type: FUNC
3079 * @tc.require: SR000HRKKA
3080 */
3081 HWTEST_F(CloudDiskRdbStoreTest, CheckRootIdValidTest1, TestSize.Level1)
3082 {
3083 auto rdb = make_shared<RdbStoreMock>();
3084 clouddiskrdbStore_->rdbStore_ = rdb;
3085 clouddiskrdbStore_->rootId_ = "rootId";
3086
3087 int32_t ret = clouddiskrdbStore_->CheckRootIdValid();
3088 EXPECT_EQ(ret, E_OK);
3089 }
3090
3091 /**
3092 * @tc.name: CheckRootIdValid
3093 * @tc.desc: Verify the CloudDiskDataCallBack::CheckRootIdValid function
3094 * @tc.type: FUNC
3095 * @tc.require: SR000HRKKA
3096 */
3097 HWTEST_F(CloudDiskRdbStoreTest, CheckRootIdValidTest2, TestSize.Level1)
3098 {
3099 auto rdb = make_shared<RdbStoreMock>();
3100 clouddiskrdbStore_->rdbStore_ = rdb;
3101 clouddiskrdbStore_->rootId_ = "";
3102
3103 int32_t ret = clouddiskrdbStore_->CheckRootIdValid();
3104 EXPECT_EQ(ret, E_INVAL_ARG);
3105 }
3106
3107 /**
3108 * @tc.name: OnCreate
3109 * @tc.desc: Verify the CloudDiskDataCallBack::OnCreate function
3110 * @tc.type: FUNC
3111 * @tc.require: SR000HRKKA
3112 */
3113 HWTEST_F(CloudDiskRdbStoreTest, OnCreateTest1, TestSize.Level1)
3114 {
3115 RdbStoreMock store;
3116 CloudDiskDataCallBack CloudDiskDataCallBack;
3117 int32_t ret = CloudDiskDataCallBack.OnCreate(store);
3118 EXPECT_EQ(ret, E_OK);
3119 }
3120
3121 /**
3122 * @tc.name: OnUpgrade
3123 * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
3124 * @tc.type: FUNC
3125 * @tc.require: SR000HRKKA
3126 */
3127 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest1, TestSize.Level1)
3128 {
3129 RdbStoreMock store;
3130 int32_t oldVersion = 13;
3131 int32_t newVersion = 14;
3132 CloudDiskDataCallBack CloudDiskDataCallBack;
3133 int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
3134 EXPECT_EQ(ret, E_OK);
3135 }
3136
3137 /**
3138 * @tc.name: OnUpgrade
3139 * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
3140 * @tc.type: FUNC
3141 * @tc.require: SR000HRKKA
3142 */
3143 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest2, TestSize.Level1)
3144 {
3145 RdbStoreMock store;
3146 int32_t oldVersion = 8;
3147 int32_t newVersion = 14;
3148 CloudDiskDataCallBack CloudDiskDataCallBack;
3149 int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
3150 EXPECT_EQ(ret, E_OK);
3151 }
3152 } // namespace OHOS::FileManagement::CloudDisk::Test