1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "db_common.h"
19 #include "distributeddb_data_generate_unit_test.h"
20 #include "distributeddb_tools_unit_test.h"
21 #include "log_print.h"
22
23 using namespace testing::ext;
24 using namespace DistributedDB;
25 using namespace DistributedDBUnitTest;
26 using namespace std;
27
28 namespace {
29 const int BATCH_BASE_SIZE = 60;
30 const Key NULL_KEY;
31 const Key NULL_VALUE;
32 const int CONFLICT_ALL = 15;
33 const auto OLD_VALUE_TYPE = KvStoreNbConflictData::ValueType::OLD_VALUE;
34 const auto NEW_VALUE_TYPE = KvStoreNbConflictData::ValueType::NEW_VALUE;
35
36 const int OBSERVER_SLEEP_TIME = 30;
37
38 // define some variables to init a KvStoreDelegateManager object.
39 KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
40 string g_testDir;
41 KvStoreConfig g_config;
42
43 // define the g_kvNbDelegateCallback, used to get some information when open a kv store.
44 DBStatus g_kvDelegateStatus = INVALID_ARGS;
45 KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
46
47 struct SingleVerConflictData {
48 KvStoreNbConflictType type = CONFLICT_NATIVE_ALL;
49 Key key;
50 Value oldValue;
51 Value newValue;
52 bool oldIsDeleted = false;
53 bool newIsDeleted = false;
54 bool oldIsNative = false;
55 bool newIsNative = false;
56 int getoldValueErrCode = 0;
57 int getNewValueErrCode = 0;
operator ==__anon6a32d6d60111::SingleVerConflictData58 bool operator==(const SingleVerConflictData &comparedData) const
59 {
60 if (this->type == comparedData.type &&
61 this->key == comparedData.key &&
62 this->oldValue == comparedData.oldValue &&
63 this->newValue == comparedData.newValue &&
64 this->oldIsDeleted == comparedData.oldIsDeleted &&
65 this->newIsDeleted == comparedData.newIsDeleted &&
66 this->oldIsNative == comparedData.oldIsNative &&
67 this->newIsNative == comparedData.newIsNative &&
68 this->getoldValueErrCode == comparedData.getoldValueErrCode &&
69 this->getNewValueErrCode == comparedData.getNewValueErrCode) {
70 return true;
71 }
72 LOGD("type = %d, ctype = %d", this->type, comparedData.type);
73 DBCommon::PrintHexVector(this->key, __LINE__, "key");
74 DBCommon::PrintHexVector(comparedData.key, __LINE__, "ckey");
75 DBCommon::PrintHexVector(this->oldValue, __LINE__, "oldValue");
76 DBCommon::PrintHexVector(comparedData.oldValue, __LINE__, "coldValue");
77 DBCommon::PrintHexVector(this->newValue, __LINE__, "newValue");
78 DBCommon::PrintHexVector(comparedData.newValue, __LINE__, "cnewValue");
79
80 LOGD("oldIsDeleted = %d, coldIsDeleted = %d", this->oldIsDeleted, comparedData.oldIsDeleted);
81 LOGD("newIsDeleted = %d, cnewIsDeleted = %d", this->newIsDeleted, comparedData.newIsDeleted);
82 LOGD("oldIsNative = %d, coldIsNative = %d", this->oldIsNative, comparedData.oldIsNative);
83 LOGD("newIsNative = %d, cnewIsNative = %d", this->newIsNative, comparedData.newIsNative);
84 LOGD("getoldValueErrCode = %d, cgetoldValueErrCode = %d", this->getoldValueErrCode,
85 comparedData.getoldValueErrCode);
86 LOGD("getNewValueErrCode = %d, cgetNewValueErrCode = %d", this->getNewValueErrCode,
87 comparedData.getNewValueErrCode);
88
89 return false;
90 }
91 };
92 std::vector<SingleVerConflictData> g_conflictData;
93
KvStoreNbDelegateCallback(DBStatus statusSrc,KvStoreNbDelegate * kvStoreSrc,DBStatus * statusDst,KvStoreNbDelegate ** kvStoreDst)94 void KvStoreNbDelegateCallback(DBStatus statusSrc, KvStoreNbDelegate *kvStoreSrc,
95 DBStatus *statusDst, KvStoreNbDelegate **kvStoreDst)
96 {
97 *statusDst = statusSrc;
98 *kvStoreDst = kvStoreSrc;
99 }
100
101 // the type of g_kvNbDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
102 auto g_kvNbDelegateCallback = bind(&KvStoreNbDelegateCallback, placeholders::_1,
103 placeholders::_2, &g_kvDelegateStatus, &g_kvNbDelegatePtr);
104
NotifierCallback(const KvStoreNbConflictData & data)105 void NotifierCallback(const KvStoreNbConflictData &data)
106 {
107 Key key;
108 Value oldValue;
109 Value newValue;
110 data.GetKey(key);
111 data.GetValue(OLD_VALUE_TYPE, oldValue);
112 LOGD("Get new value status:%d", data.GetValue(NEW_VALUE_TYPE, newValue));
113 LOGD("Type:%d", data.GetType());
114 DBCommon::PrintHexVector(oldValue, __LINE__);
115 DBCommon::PrintHexVector(newValue, __LINE__);
116 LOGD("Type:IsDeleted %d vs %d, IsNative %d vs %d", data.IsDeleted(OLD_VALUE_TYPE),
117 data.IsDeleted(NEW_VALUE_TYPE), data.IsNative(OLD_VALUE_TYPE), data.IsNative(NEW_VALUE_TYPE));
118 g_conflictData.push_back({data.GetType(), key, oldValue, newValue, data.IsDeleted(OLD_VALUE_TYPE),
119 data.IsDeleted(NEW_VALUE_TYPE), data.IsNative(OLD_VALUE_TYPE), data.IsNative(NEW_VALUE_TYPE),
120 data.GetValue(OLD_VALUE_TYPE, oldValue), data.GetValue(NEW_VALUE_TYPE, newValue)});
121 }
122 }
123
124 class DistributedDBInterfacesNBTransactionTest : public testing::Test {
125 public:
126 static void SetUpTestCase(void);
127 static void TearDownTestCase(void);
128 void SetUp();
129 void TearDown();
130 };
131
SetUpTestCase(void)132 void DistributedDBInterfacesNBTransactionTest::SetUpTestCase(void)
133 {
134 DistributedDBToolsUnitTest::TestDirInit(g_testDir);
135 g_config.dataDir = g_testDir;
136 g_mgr.SetKvStoreConfig(g_config);
137 g_mgr.SetProcessLabel("DistributedDBInterfacesNBTransactionTest", "test");
138 }
139
TearDownTestCase(void)140 void DistributedDBInterfacesNBTransactionTest::TearDownTestCase(void)
141 {
142 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
143 LOGE("rm test db files error!");
144 }
145 }
146
SetUp(void)147 void DistributedDBInterfacesNBTransactionTest::SetUp(void)
148 {
149 DistributedDBToolsUnitTest::PrintTestCaseInfo();
150 g_kvDelegateStatus = INVALID_ARGS;
151 g_kvNbDelegatePtr = nullptr;
152 }
153
TearDown(void)154 void DistributedDBInterfacesNBTransactionTest::TearDown(void) {}
155
156 /**
157 * @tc.name: start001
158 * @tc.desc: Test the nb transaction start twice.
159 * @tc.type: FUNC
160 * @tc.require: AR000DPTQ9
161 * @tc.author: wumin
162 */
163 HWTEST_F(DistributedDBInterfacesNBTransactionTest, start001, TestSize.Level1)
164 {
165 const KvStoreNbDelegate::Option option = {true, false};
166 g_mgr.GetKvStore("distributed_nb_transaction_start001", option, g_kvNbDelegateCallback);
167 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
168 EXPECT_TRUE(g_kvDelegateStatus == OK);
169
170 /**
171 * @tc.steps:step1. Start transaction.
172 * @tc.expected: step1. return OK.
173 */
174 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
175
176 /**
177 * @tc.steps:step2. Start transaction again.
178 * @tc.expected: step2. return DB_ERROR.
179 */
180 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), DB_ERROR);
181
182 // finilize
183 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
184 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_start001"), OK);
185 g_kvNbDelegatePtr = nullptr;
186 }
187
188 /**
189 * @tc.name: start002
190 * @tc.desc: Test the nb transaction begin and end not match.
191 * @tc.type: FUNC
192 * @tc.require: AR000DPTQ9
193 * @tc.author: wumin
194 */
195 HWTEST_F(DistributedDBInterfacesNBTransactionTest, start002, TestSize.Level1)
196 {
197 const KvStoreNbDelegate::Option option = {true, false};
198 g_mgr.GetKvStore("distributed_nb_transaction_start002", option, g_kvNbDelegateCallback);
199 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
200 EXPECT_TRUE(g_kvDelegateStatus == OK);
201 /**
202 * @tc.steps:step1. Start transaction.
203 * @tc.expected: step1. return OK.
204 */
205 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
206 /**
207 * @tc.steps:step2. Rollback transaction.
208 * @tc.expected: step2. return OK.
209 */
210 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
211 /**
212 * @tc.steps:step3. Commit transaction.
213 * @tc.expected: step3. return DB_ERROR.
214 */
215 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), DB_ERROR);
216 /**
217 * @tc.steps:step4. Start transaction.
218 * @tc.expected: step4. return OK.
219 */
220 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
221 /**
222 * @tc.steps:step5. Commit transaction.
223 * @tc.expected: step5. return DB_ERROR.
224 */
225 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
226 /**
227 * @tc.steps:step6. Rollback transaction.
228 * @tc.expected: step6. return OK.
229 */
230 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), DB_ERROR);
231
232 // finilize
233 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
234 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_start002"), OK);
235 g_kvNbDelegatePtr = nullptr;
236 }
237
238 /**
239 * @tc.name: start003
240 * @tc.desc: Test the nb transaction rollback automatically when db close.
241 * @tc.type: FUNC
242 * @tc.require: AR000DPTQ9
243 * @tc.author: wumin
244 */
245 HWTEST_F(DistributedDBInterfacesNBTransactionTest, start003, TestSize.Level1)
246 {
247 const KvStoreNbDelegate::Option option = {true, false};
248 g_mgr.GetKvStore("distributed_nb_transaction_start003", option, g_kvNbDelegateCallback);
249 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
250 EXPECT_TRUE(g_kvDelegateStatus == OK);
251 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
252 /**
253 * @tc.steps:step1. Start transaction.
254 * @tc.expected: step1. return OK.
255 */
256 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
257
258 /**
259 * @tc.steps:step2. Put (key1,value2)
260 * @tc.expected: step2. return OK.
261 */
262 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
263 /**
264 * @tc.steps:step3. Close db
265 * @tc.expected: step3. return OK.
266 */
267 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
268 g_kvNbDelegatePtr = nullptr;
269 /**
270 * @tc.steps:step4. Open db again
271 * @tc.expected: step4. return OK.
272 */
273 g_mgr.GetKvStore("distributed_nb_transaction_start003", option, g_kvNbDelegateCallback);
274 EXPECT_TRUE(g_kvDelegateStatus == OK);
275 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
276 /**
277 * @tc.steps:step5. Get key1
278 * @tc.expected: step5. return OK, value of key1 is value1.
279 */
280 Value value;
281 EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, value), OK);
282 EXPECT_EQ(value, VALUE_1);
283
284 // finilize
285 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
286 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_start003"), OK);
287 g_kvNbDelegatePtr = nullptr;
288 }
289
290 /**
291 * @tc.name: start004
292 * @tc.desc: Test the nb operations return BUSY after transaction started.
293 * @tc.type: FUNC
294 * @tc.require: AR000DPTQ9
295 * @tc.author: wumin
296 */
297 HWTEST_F(DistributedDBInterfacesNBTransactionTest, start004, TestSize.Level4)
298 {
299 const KvStoreNbDelegate::Option option = {true, false};
300 g_mgr.GetKvStore("distributed_nb_transaction_start004", option, g_kvNbDelegateCallback);
301 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
302 EXPECT_TRUE(g_kvDelegateStatus == OK);
303 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
304 /**
305 * @tc.steps:step1. Start transaction.
306 * @tc.expected: step1. return OK.
307 */
308 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
309 /**
310 * @tc.steps:step2. Local data and sync data can be simultaneously operated in transactions.
311 * @tc.expected: step2. From September 2020 return OK.
312 */
313 EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_3, VALUE_3), OK);
314 EXPECT_EQ(g_kvNbDelegatePtr->DeleteLocal(KEY_1), OK);
315
316 CipherPassword password;
317 EXPECT_EQ(g_kvNbDelegatePtr->Rekey(password), BUSY);
318
319 KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
320 ASSERT_TRUE(observer != nullptr);
321 EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(KEY_3, OBSERVER_CHANGES_NATIVE, observer), BUSY);
322 EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observer), NOT_FOUND);
323 delete observer;
324 observer = nullptr;
325
326 std::string filePath = g_testDir + "/test.txt";
327 EXPECT_EQ(g_kvNbDelegatePtr->Export(filePath, password), BUSY);
328
329 KvStoreResultSet *readResultSet = nullptr;
330 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(KEY_4, readResultSet), BUSY);
331 EXPECT_EQ(g_kvNbDelegatePtr->CloseResultSet(readResultSet), INVALID_ARGS);
332 /**
333 * @tc.steps:step1. Commit transaction.
334 * @tc.expected: step1. return OK.
335 */
336 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
337
338 // finilize
339 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
340 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_start004"), OK);
341 g_kvNbDelegatePtr = nullptr;
342 }
343
344 /**
345 * @tc.name: commit001
346 * @tc.desc: Test the nb transaction commit without start.
347 * @tc.type: FUNC
348 * @tc.require: AR000DPTQ9
349 * @tc.author: wumin
350 */
351 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit001, TestSize.Level1)
352 {
353 const KvStoreNbDelegate::Option option = {true, false};
354 g_mgr.GetKvStore("distributed_nb_transaction_commit001", option, g_kvNbDelegateCallback);
355 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
356 EXPECT_TRUE(g_kvDelegateStatus == OK);
357 /**
358 * @tc.steps:step1. Commit transaction.
359 * @tc.expected: step1. return DB_ERROR.
360 */
361 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), DB_ERROR);
362
363 // finilize
364 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
365 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit001"), OK);
366 g_kvNbDelegatePtr = nullptr;
367 }
368
369 /**
370 * @tc.name: commit002
371 * @tc.desc: Test the nb transaction commit twice.
372 * @tc.type: FUNC
373 * @tc.require: AR000DPTQ9
374 * @tc.author: wumin
375 */
376 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit002, TestSize.Level1)
377 {
378 const KvStoreNbDelegate::Option option = {true, false};
379 g_mgr.GetKvStore("distributed_nb_transaction_commit002", option, g_kvNbDelegateCallback);
380 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
381 EXPECT_TRUE(g_kvDelegateStatus == OK);
382 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
383 /**
384 * @tc.steps:step1. Start transaction.
385 * @tc.expected: step1. return OK.
386 */
387 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
388 /**
389 * @tc.steps:step2. Get key1
390 * @tc.expected: step2. return OK, value of key1 is value1.
391 */
392 Value value1;
393 EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, value1), OK);
394 EXPECT_EQ(value1, VALUE_1);
395 /**
396 * @tc.steps:step3. Put (key2,value2)
397 * @tc.expected: step3. return OK.
398 */
399 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
400 /**
401 * @tc.steps:step4. Get key2
402 * @tc.expected: step4. return OK, value of key2 is value2.
403 */
404 Value value2;
405 EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, value2), OK);
406 EXPECT_EQ(value2, VALUE_2);
407 /**
408 * @tc.steps:step5. Commit transaction.
409 * @tc.expected: step5. return OK.
410 */
411 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
412 /**
413 * @tc.steps:step6. Commit transaction again.
414 * @tc.expected: step6. return DB_ERROR.
415 */
416 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), DB_ERROR);
417
418 // finilize
419 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
420 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit002"), OK);
421 g_kvNbDelegatePtr = nullptr;
422 }
423
424 /**
425 * @tc.name: commit003
426 * @tc.desc: Test the entry size exceed the maximum limit in one transaction
427 * @tc.type: FUNC
428 * @tc.require: AR000DPTQ9
429 * @tc.author: wumin
430 */
431 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit003, TestSize.Level1)
432 {
433 const KvStoreNbDelegate::Option option = {true, false};
434 g_mgr.GetKvStore("distributed_nb_transaction_commit003", option, g_kvNbDelegateCallback);
435 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
436 EXPECT_TRUE(g_kvDelegateStatus == OK);
437 /**
438 * @tc.steps:step1. Start transaction.
439 * @tc.expected: step1. return OK.
440 */
441 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
442 /**
443 * @tc.steps:step2. Put (key1,value1)
444 * @tc.expected: step2. return OK.
445 */
446 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
447 /**
448 * @tc.steps:step3. Delete key1
449 * @tc.expected: step3. return OK.
450 */
451 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
452 /**
453 * @tc.steps:step4. PutBatch 64 records (from key2 to key65)
454 * @tc.expected: step4. return OK.
455 */
456 vector<Entry> entrysBase;
457 vector<Key> keysBase;
458 DistributedDBUnitTest::GenerateRecords(BATCH_BASE_SIZE + 5, entrysBase, keysBase);
459
460 vector<Entry> entrys1(entrysBase.begin() + 1, entrysBase.end());
461 EXPECT_EQ(entrys1.size(), 64UL);
462 EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entrys1), OK);
463 /**
464 * @tc.steps:step5. DeleteBatch 63 records (from key2 to key64)
465 * @tc.expected: step5. return OK.
466 */
467 vector<Key> keys1(keysBase.begin() + 1, keysBase.end() - 1);
468 EXPECT_EQ(keys1.size(), 63UL);
469 EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keys1), OVER_MAX_LIMITS);
470 /**
471 * @tc.steps:step6. DeleteBatch 60 records (from key1 to key60)
472 * @tc.expected: step6. return OK.
473 */
474 vector<Key> keys2(keysBase.begin(), keysBase.begin() + 60);
475 EXPECT_EQ(keys2.size(), 60UL);
476 EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keys2), OK);
477 /**
478 * @tc.steps:step6. Commit.
479 * @tc.expected: step6. return OK.
480 */
481 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
482 /**
483 * @tc.steps:step7. GetEntries.
484 * @tc.expected: step7. return OK.
485 */
486 vector<Entry> entriesExpect(entrysBase.begin() + 60, entrysBase.end());
487 EXPECT_EQ(entriesExpect.size(), 5UL);
488 const Key prefix;
489 vector<Entry> entriesRet;
490 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entriesRet), OK);
491 EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntriesEqual(entriesExpect, entriesRet));
492
493 // finilize
494 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
495 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit003"), OK);
496 g_kvNbDelegatePtr = nullptr;
497 }
498
499 /**
500 * @tc.name: commit004
501 * @tc.desc: Test the nb normal operations in one transaction
502 * @tc.type: FUNC
503 * @tc.require: AR000DPTQ9
504 * @tc.author: wumin
505 */
506 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit004, TestSize.Level1)
507 {
508 const KvStoreNbDelegate::Option option = {true, false};
509 g_mgr.GetKvStore("distributed_nb_transaction_commit004", option, g_kvNbDelegateCallback);
510 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
511 EXPECT_TRUE(g_kvDelegateStatus == OK);
512 KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
513 ASSERT_TRUE(observer != nullptr);
514 EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observer), OK);
515 /**
516 * @tc.steps:step1. Start transaction.
517 * @tc.expected: step1. return OK.
518 */
519 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
520 /**
521 * @tc.steps:step2. Put (key1,value1) and (key2,value2)
522 * @tc.expected: step2. put OK.
523 */
524 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
525 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
526 /**
527 * @tc.steps:step3. Delete key2
528 * @tc.expected: step3. return OK.
529 */
530 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_2), OK);
531 /**
532 * @tc.steps:step4. PutBatch 65 records (from key3 to key67)
533 * @tc.expected: step4. return OK.
534 */
535 vector<Entry> entrysBase;
536 vector<Key> keysBase;
537 DistributedDBUnitTest::GenerateRecords(BATCH_BASE_SIZE + 7, entrysBase, keysBase);
538
539 vector<Entry> entrys1(entrysBase.begin() + 2, entrysBase.end());
540 EXPECT_EQ(entrys1.size(), 65UL);
541 EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entrys1), OK);
542 /**
543 * @tc.steps:step5. DeleteBatch 60 records (from key8 to key67)
544 * @tc.expected: step5. return OK.
545 */
546 vector<Key> keys(keysBase.begin() + 7, keysBase.end());
547 EXPECT_EQ(keys.size(), 60UL);
548 EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keys), OK);
549 /**
550 * @tc.steps:step6. Commit.
551 * @tc.expected: step6. return OK.
552 */
553 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
554 /**
555 * @tc.steps:step7. Check observer data.
556 * @tc.expected: step6. return OK.
557 */
558 vector<Entry> entriesRet;
559 Entry entry1 = {KEY_1, VALUE_1};
560 entriesRet.push_back(entry1);
561 entriesRet.insert(entriesRet.end(), entrysBase.begin() + 2, entrysBase.begin() + 7);
562 EXPECT_EQ(entriesRet.size(), 6UL);
563
564 std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
565 EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observer->GetEntriesInserted()));
566 /**
567 * @tc.steps:step8. GetEntries.
568 * @tc.expected: step8. return OK.
569 */
570 const Key prefix;
571 vector<Entry> entries;
572 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
573 EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntriesEqual(entriesRet, entries, true));
574
575 // finilize
576 EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observer), OK);
577 delete observer;
578 observer = nullptr;
579
580 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
581 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit004"), OK);
582 g_kvNbDelegatePtr = nullptr;
583 }
584
585 /**
586 * @tc.name: commit005
587 * @tc.desc: Test the conflict data report normally in one transaction
588 * @tc.type: FUNC
589 * @tc.require: AR000DPTQ9
590 * @tc.author: wumin
591 */
592 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit005, TestSize.Level1)
593 {
594 const KvStoreNbDelegate::Option option = {true, false};
595 g_mgr.GetKvStore("distributed_nb_transaction_commit005", option, g_kvNbDelegateCallback);
596 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
597 EXPECT_TRUE(g_kvDelegateStatus == OK);
598 EXPECT_TRUE(g_kvNbDelegatePtr->SetConflictNotifier(CONFLICT_ALL, NotifierCallback) == OK);
599
600 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
601 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
602 /**
603 * @tc.steps:step1. Start transaction.
604 * @tc.expected: step1. return OK.
605 */
606 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
607 /**
608 * @tc.steps:step2. Put (key1,value3) and (key2,value4)
609 * @tc.expected: step2. put OK.
610 */
611 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_3), OK);
612 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_4), OK);
613 /**
614 * @tc.steps:step3. Delete key2
615 * @tc.expected: step3. return OK.
616 */
617 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_2), OK);
618 /**
619 * @tc.steps:step4. put (key3 ,value5) (key3 ,value6)
620 * @tc.expected: step4. return OK.
621 */
622 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_3, VALUE_5), OK);
623 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_3, VALUE_6), OK);
624 /**
625 * @tc.steps:step5. Commit.
626 * @tc.expected: step5. return OK.
627 */
628 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
629 /**
630 * @tc.steps:step6. Check conflict report data.
631 * @tc.expected: step6. return OK.
632 */
633 std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
634 EXPECT_EQ(g_conflictData.size(), 2UL);
635 if (g_conflictData.size() == 2) {
636 SingleVerConflictData expectNotifyData1 = {KvStoreNbConflictType::CONFLICT_NATIVE_ALL,
637 KEY_1, VALUE_1, VALUE_3, false, false, true, true, OK, OK};
638 EXPECT_EQ(g_conflictData[0], expectNotifyData1);
639
640 SingleVerConflictData expectNotifyData2 = {KvStoreNbConflictType::CONFLICT_NATIVE_ALL,
641 KEY_2, VALUE_2, NULL_VALUE, false, true, true, true, OK, DB_ERROR};
642 EXPECT_EQ(g_conflictData[1], expectNotifyData2);
643 }
644
645 // finilize
646 g_conflictData.clear();
647 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
648 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit005"), OK);
649 g_kvNbDelegatePtr = nullptr;
650 }
651
652 /**
653 * @tc.name: commit006
654 * @tc.desc: Test the conflict data report and observer function both be normal in one transaction
655 * @tc.type: FUNC
656 * @tc.require: AR000DPTQ9
657 * @tc.author: wumin
658 */
659 HWTEST_F(DistributedDBInterfacesNBTransactionTest, commit006, TestSize.Level1)
660 {
661 const KvStoreNbDelegate::Option option = {true, false};
662 g_mgr.GetKvStore("distributed_nb_transaction_commit006", option, g_kvNbDelegateCallback);
663 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
664 EXPECT_TRUE(g_kvDelegateStatus == OK);
665
666 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
667 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
668
669 EXPECT_TRUE(g_kvNbDelegatePtr->SetConflictNotifier(CONFLICT_ALL, NotifierCallback) == OK);
670
671 KvStoreObserverUnitTest *observer = new (std::nothrow) KvStoreObserverUnitTest;
672 ASSERT_TRUE(observer != nullptr);
673 EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observer), OK);
674 /**
675 * @tc.steps:step1. Start transaction.
676 * @tc.expected: step1. return OK.
677 */
678 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
679 /**
680 * @tc.steps:step2. Put (key1,value2)
681 * @tc.expected: step2. put OK.
682 */
683 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
684 /**
685 * @tc.steps:step3. Commit.
686 * @tc.expected: step3. return OK.
687 */
688 EXPECT_EQ(g_kvNbDelegatePtr->Commit(), OK);
689 std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
690 /**
691 * @tc.steps:step4. Get value of key1.
692 * @tc.expected: step4. return OK, value of key1 is value2.
693 */
694 Value readValue;
695 EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
696 EXPECT_TRUE(readValue == VALUE_2);
697 /**
698 * @tc.steps:step5. Check observer data.
699 * @tc.expected: step5. return OK.
700 */
701 vector<Entry> entriesRet = {{KEY_1, VALUE_2}};
702 EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observer->GetEntriesInserted()));
703 /**
704 * @tc.steps:step6. Check conflict report data.
705 * @tc.expected: step6. return OK.
706 */
707 std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
708 EXPECT_EQ(g_conflictData.size(), 1UL);
709 if (g_conflictData.size() == 1) {
710 SingleVerConflictData expectNotifyData = {KvStoreNbConflictType::CONFLICT_NATIVE_ALL,
711 KEY_1, {}, VALUE_2, true, false, true, true, DB_ERROR, OK};
712 EXPECT_EQ(g_conflictData[0], expectNotifyData);
713 }
714
715 // finilize
716 g_conflictData.clear();
717 EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observer), OK);
718 delete observer;
719 observer = nullptr;
720
721 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
722 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_commit006"), OK);
723 g_kvNbDelegatePtr = nullptr;
724 }
725
726 /**
727 * @tc.name: rollback001
728 * @tc.desc: Test the transaction rollback without start.
729 * @tc.type: FUNC
730 * @tc.require: AR000DPTQ9
731 * @tc.author: wumin
732 */
733 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback001, TestSize.Level1)
734 {
735 const KvStoreNbDelegate::Option option = {true, false};
736 g_mgr.GetKvStore("distributed_nb_transaction_rollback001", option, g_kvNbDelegateCallback);
737 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
738 EXPECT_TRUE(g_kvDelegateStatus == OK);
739 /**
740 * @tc.steps:step1. Transaction rollback without start.
741 * @tc.expected: step1. return DB_ERROR.
742 */
743 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), DB_ERROR);
744
745 // finilize
746 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
747 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback001"), OK);
748 g_kvNbDelegatePtr = nullptr;
749 }
750
751 /**
752 * @tc.name: rollback002
753 * @tc.desc: Test the transaction rollback twice
754 * @tc.type: FUNC
755 * @tc.require: AR000DPTQ9
756 * @tc.author: wumin
757 */
758 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback002, TestSize.Level1)
759 {
760 const KvStoreNbDelegate::Option option = {true, false};
761 g_mgr.GetKvStore("distributed_nb_transaction_rollback002", option, g_kvNbDelegateCallback);
762 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
763 EXPECT_TRUE(g_kvDelegateStatus == OK);
764 /**
765 * @tc.steps:step1. Start transaction.
766 * @tc.expected: step1. return OK.
767 */
768 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
769 /**
770 * @tc.steps:step1. Rollback.
771 * @tc.expected: step1. return OK.
772 */
773 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
774 /**
775 * @tc.steps:step1. Transaction rollback without start.
776 * @tc.expected: step1. return DB_ERROR.
777 */
778 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), DB_ERROR);
779
780 // finilize
781 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
782 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback002"), OK);
783 g_kvNbDelegatePtr = nullptr;
784 }
785
786 /**
787 * @tc.name: rollback003
788 * @tc.desc: Test the Put operation rollback
789 * @tc.type: FUNC
790 * @tc.require: AR000DPTQ9
791 * @tc.author: wumin
792 */
793 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback003, TestSize.Level1)
794 {
795 const KvStoreNbDelegate::Option option = {true, false};
796 g_mgr.GetKvStore("distributed_nb_transaction_rollback003", option, g_kvNbDelegateCallback);
797 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
798 EXPECT_TRUE(g_kvDelegateStatus == OK);
799 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
800 /**
801 * @tc.steps:step1. Start transaction.
802 * @tc.expected: step1. return OK.
803 */
804 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
805 /**
806 * @tc.steps:step2. Put (key2,value2)
807 * @tc.expected: step2. return OK.
808 */
809 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
810 /**
811 * @tc.steps:step3. Rollback.
812 * @tc.expected: step3. return OK.
813 */
814 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
815 /**
816 * @tc.steps:step4. GetEntries.
817 * @tc.expected: step4. return OK.
818 */
819 const Key prefix;
820 vector<Entry> entries;
821 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
822 EXPECT_EQ(entries.size(), 1UL);
823 if (entries.size() > 0) {
824 EXPECT_EQ(entries[0].key, KEY_1);
825 EXPECT_EQ(entries[0].value, VALUE_1);
826 }
827
828 // finilize
829 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
830 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback003"), OK);
831 g_kvNbDelegatePtr = nullptr;
832 }
833
834 /**
835 * @tc.name: rollback004
836 * @tc.desc: Test the PutBatch operation rollback
837 * @tc.type: FUNC
838 * @tc.require: AR000DPTQ9
839 * @tc.author: wumin
840 */
841 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback004, TestSize.Level1)
842 {
843 const KvStoreNbDelegate::Option option = {true, false};
844 g_mgr.GetKvStore("distributed_nb_transaction_rollback004", option, g_kvNbDelegateCallback);
845 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
846 EXPECT_TRUE(g_kvDelegateStatus == OK);
847 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
848 /**
849 * @tc.steps:step1. Start transaction.
850 * @tc.expected: step1. return OK.
851 */
852 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
853 /**
854 * @tc.steps:step2. PutBatch 10 records
855 * @tc.expected: step2. return OK.
856 */
857 vector<Entry> entrysBase;
858 vector<Key> keysBase;
859 DistributedDBUnitTest::GenerateRecords(10, entrysBase, keysBase);
860
861 EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entrysBase), OK);
862 /**
863 * @tc.steps:step3. Rollback.
864 * @tc.expected: step3. return OK.
865 */
866 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
867 /**
868 * @tc.steps:step4. GetEntries.
869 * @tc.expected: step4. return OK.
870 */
871 const Key prefix;
872 vector<Entry> entries;
873 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
874 EXPECT_EQ(entries.size(), 1UL);
875 if (entries.size() > 0) {
876 EXPECT_EQ(entries[0].key, KEY_1);
877 EXPECT_EQ(entries[0].value, VALUE_1);
878 }
879
880 // finilize
881 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
882 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback004"), OK);
883 g_kvNbDelegatePtr = nullptr;
884 }
885
886 /**
887 * @tc.name: rollback005
888 * @tc.desc: Test the modify operation rollback
889 * @tc.type: FUNC
890 * @tc.require: AR000DPTQ9
891 * @tc.author: wumin
892 */
893 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback005, TestSize.Level1)
894 {
895 const KvStoreNbDelegate::Option option = {true, false};
896 g_mgr.GetKvStore("distributed_nb_transaction_rollback005", option, g_kvNbDelegateCallback);
897 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
898 EXPECT_TRUE(g_kvDelegateStatus == OK);
899 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
900 /**
901 * @tc.steps:step1. Start transaction.
902 * @tc.expected: step1. return OK.
903 */
904 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
905 /**
906 * @tc.steps:step2. Put (key1,value2)
907 * @tc.expected: step2. return OK.
908 */
909 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
910 /**
911 * @tc.steps:step3. Rollback.
912 * @tc.expected: step3. return OK.
913 */
914 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
915 /**
916 * @tc.steps:step4. GetEntries.
917 * @tc.expected: step4. return OK.
918 */
919 const Key prefix;
920 vector<Entry> entries;
921 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
922 EXPECT_EQ(entries.size(), 1UL);
923 if (entries.size() > 0) {
924 EXPECT_EQ(entries[0].key, KEY_1);
925 EXPECT_EQ(entries[0].value, VALUE_1);
926 }
927
928 // finilize
929 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
930 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback005"), OK);
931 g_kvNbDelegatePtr = nullptr;
932 }
933
934 /**
935 * @tc.name: rollback006
936 * @tc.desc: Test the Delete operation rollback
937 * @tc.type: FUNC
938 * @tc.require: AR000DPTQ9
939 * @tc.author: wumin
940 */
941 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback006, TestSize.Level1)
942 {
943 const KvStoreNbDelegate::Option option = {true, false};
944 g_mgr.GetKvStore("distributed_nb_transaction_rollback006", option, g_kvNbDelegateCallback);
945 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
946 EXPECT_TRUE(g_kvDelegateStatus == OK);
947 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
948 /**
949 * @tc.steps:step1. Start transaction.
950 * @tc.expected: step1. return OK.
951 */
952 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
953 /**
954 * @tc.steps:step2. Delete key1
955 * @tc.expected: step2. return OK.
956 */
957 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
958 /**
959 * @tc.steps:step3. Rollback.
960 * @tc.expected: step3. return OK.
961 */
962 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
963 /**
964 * @tc.steps:step4. GetEntries.
965 * @tc.expected: step4. return OK.
966 */
967 const Key prefix;
968 vector<Entry> entries;
969 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
970 EXPECT_EQ(entries.size(), 1UL);
971 if (entries.size() > 0) {
972 EXPECT_EQ(entries[0].key, KEY_1);
973 EXPECT_EQ(entries[0].value, VALUE_1);
974 }
975
976 // finilize
977 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
978 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback006"), OK);
979 g_kvNbDelegatePtr = nullptr;
980 }
981
982 /**
983 * @tc.name: rollback007
984 * @tc.desc: Test the DeleteBatch operation rollback
985 * @tc.type: FUNC
986 * @tc.require: AR000DPTQ9
987 * @tc.author: wumin
988 */
989 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback007, TestSize.Level1)
990 {
991 const KvStoreNbDelegate::Option option = {true, false};
992 g_mgr.GetKvStore("distributed_nb_transaction_rollback007", option, g_kvNbDelegateCallback);
993 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
994 EXPECT_TRUE(g_kvDelegateStatus == OK);
995
996 vector<Entry> entries;
997 vector<Key> keys;
998 DistributedDBUnitTest::GenerateRecords(10, entries, keys);
999
1000 EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entries), OK);
1001 /**
1002 * @tc.steps:step1. Start transaction.
1003 * @tc.expected: step1. return OK.
1004 */
1005 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
1006 /**
1007 * @tc.steps:step2. DeleteBatch from key1 to key10
1008 * @tc.expected: step2. return OK.
1009 */
1010 EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keys), OK);
1011 /**
1012 * @tc.steps:step3. Rollback.
1013 * @tc.expected: step3. return OK.
1014 */
1015 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
1016 /**
1017 * @tc.steps:step4. GetEntries.
1018 * @tc.expected: step4. return OK.
1019 */
1020 const Key prefix;
1021 vector<Entry> entriesRet;
1022 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entriesRet), OK);
1023 EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntriesEqual(entries, entriesRet));
1024
1025 // finilize
1026 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
1027 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback007"), OK);
1028 g_kvNbDelegatePtr = nullptr;
1029 }
1030
1031 /**
1032 * @tc.name: rollback008
1033 * @tc.desc: Test the multiple operations rollback
1034 * @tc.type: FUNC
1035 * @tc.require: AR000DPTQ9
1036 * @tc.author: wumin
1037 */
1038 HWTEST_F(DistributedDBInterfacesNBTransactionTest, rollback008, TestSize.Level1)
1039 {
1040 const KvStoreNbDelegate::Option option = {true, false};
1041 g_mgr.GetKvStore("distributed_nb_transaction_rollback008", option, g_kvNbDelegateCallback);
1042 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
1043 EXPECT_TRUE(g_kvDelegateStatus == OK);
1044 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
1045 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
1046 /**
1047 * @tc.steps:step1. Start transaction.
1048 * @tc.expected: step1. return OK.
1049 */
1050 EXPECT_EQ(g_kvNbDelegatePtr->StartTransaction(), OK);
1051 /**
1052 * @tc.steps:step2. Put (key3,value3) (key1,value4)
1053 * @tc.expected: step2. return OK.
1054 */
1055 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_3, VALUE_3), OK);
1056 EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_4), OK);
1057 /**
1058 * @tc.steps:step3. Delete key2
1059 * @tc.expected: step3. return OK.
1060 */
1061 EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_2), OK);
1062 /**
1063 * @tc.steps:step4. PutBatch 10 records (from key3 to key12)
1064 * @tc.expected: step4. return OK.
1065 */
1066 vector<Entry> entrysBase;
1067 vector<Key> keysBase;
1068 DistributedDBUnitTest::GenerateRecords(12, entrysBase, keysBase);
1069
1070 vector<Entry> entrys1(entrysBase.begin() + 2, entrysBase.end());
1071 EXPECT_EQ(entrys1.size(), 10UL);
1072 EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entrys1), OK);
1073 /**
1074 * @tc.steps:step5. DeleteBatch 5 records (from key3 to key7)
1075 * @tc.expected: step5. return OK.
1076 */
1077 vector<Key> keys(keysBase.begin() + 2, keysBase.begin() + 7);
1078 EXPECT_EQ(keys.size(), 5UL);
1079 EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keys), OK);
1080 /**
1081 * @tc.steps:step6. Commit.
1082 * @tc.expected: step6. return OK.
1083 */
1084 EXPECT_EQ(g_kvNbDelegatePtr->Rollback(), OK);
1085 /**
1086 * @tc.steps:step7. GetEntries.
1087 * @tc.expected: step7. return OK.
1088 */
1089 const Key prefix;
1090 vector<Entry> entries;
1091 EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(prefix, entries), OK);
1092 EXPECT_EQ(entries.size(), 2UL);
1093 if (entries.size() > 1) {
1094 EXPECT_EQ(entries[0].key, KEY_1);
1095 EXPECT_EQ(entries[0].value, VALUE_1);
1096 EXPECT_EQ(entries[1].key, KEY_2);
1097 EXPECT_EQ(entries[1].value, VALUE_2);
1098 }
1099
1100 // finilize
1101 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
1102 EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_transaction_rollback008"), OK);
1103 g_kvNbDelegatePtr = nullptr;
1104 }