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