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 #ifndef OMIT_MULTI_VER
16 #include <gtest/gtest.h>
17 #include <ctime>
18 #include <cmath>
19 #include <random>
20 #include <chrono>
21 #include <thread>
22 #include <cstdio>
23 #include <string>
24
25 #include "distributeddb_data_generator.h"
26 #include "distributed_test_tools.h"
27 #include "kv_store_delegate.h"
28 #include "kv_store_delegate_manager.h"
29
30 using namespace std;
31 using namespace chrono;
32 using namespace testing;
33 #if defined TESTCASES_USING_GTEST_EXT
34 using namespace testing::ext;
35 #endif
36 using namespace DistributedDB;
37 using namespace DistributedDBDataGenerator;
38
39 namespace DistributedDBKvObserver {
40 const bool IS_LOCAL = false;
41 const long CHANGED_ZERO_TIME = 0;
42 const long CHANGED_ONE_TIME = 1;
43 const unsigned long OPER_CNT_START = 0;
44 const unsigned long OPER_CNT_END = 5;
45 const unsigned long TEN_RECORDS = 10;
46 const unsigned long DELETE_CNT_START = 0;
47 const unsigned long DELETE_CNT_END = 2;
48
49 DistributedDB::CipherPassword g_passwd1;
50 DistributedDB::CipherPassword g_passwd2;
51 DistributedDB::CipherPassword g_filePasswd1;
52 DistributedDB::CipherPassword g_filePasswd2;
53
54 class DistributeddbKvObserverTest : public testing::Test {
55 public:
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
58 void SetUp();
59 void TearDown();
60 private:
61 };
62
63 KvStoreDelegate *g_observerDelegate = nullptr; // the delegate used in this suit.
64 KvStoreDelegateManager *g_observerManager = nullptr;
SetUpTestCase(void)65 void DistributeddbKvObserverTest::SetUpTestCase(void)
66 {
67 MST_LOG("SetUpTestCase before all cases local[%d].", IS_LOCAL);
68 RemoveDir(DIRECTOR);
69 g_observerDelegate = DistributedTestTools::GetDelegateSuccess(g_observerManager,
70 g_kvdbParameter1, g_kvOption);
71 ASSERT_TRUE(g_observerManager != nullptr && g_observerDelegate != nullptr);
72 (void)g_passwd1.SetValue(PASSWD_VECTOR_1.data(), PASSWD_VECTOR_1.size());
73 (void)g_passwd2.SetValue(PASSWD_VECTOR_2.data(), PASSWD_VECTOR_2.size());
74 (void)g_filePasswd1.SetValue(FILE_PASSWD_VECTOR_1.data(), FILE_PASSWD_VECTOR_1.size());
75 (void)g_filePasswd2.SetValue(FILE_PASSWD_VECTOR_2.data(), FILE_PASSWD_VECTOR_2.size());
76 }
77
TearDownTestCase(void)78 void DistributeddbKvObserverTest::TearDownTestCase(void)
79 {
80 EXPECT_TRUE(g_observerManager->CloseKvStore(g_observerDelegate) == OK);
81 g_observerDelegate = nullptr;
82 DBStatus status = g_observerManager->DeleteKvStore(STORE_ID_1);
83 EXPECT_EQ(status, DistributedDB::DBStatus::OK) << "fail to delete exist kvdb";
84 delete g_observerManager;
85 g_observerManager = nullptr;
86 RemoveDir(DIRECTOR);
87 }
88
SetUp(void)89 void DistributeddbKvObserverTest::SetUp(void)
90 {
91 EXPECT_TRUE(g_observerDelegate != nullptr);
92 UnitTest *test = UnitTest::GetInstance();
93 ASSERT_NE(test, nullptr);
94 const TestInfo *testinfo = test->current_test_info();
95 ASSERT_NE(testinfo, nullptr);
96 string testCaseName = string(testinfo->name());
97 MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
98 }
99
TearDown(void)100 void DistributeddbKvObserverTest::TearDown(void)
101 {
102 }
103
104 /*
105 * @tc.name: ObserverRegister 001
106 * @tc.desc: Verify that can register a fresh observer base on kv db.
107 * @tc.type: FUNC
108 * @tc.require: SR000BUH3K
109 * @tc.author: luqianfu
110 */
111 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister001, TestSize.Level1)
112 {
113 DistributedTestTools::Clear(*g_observerDelegate);
114
115 KvStoreObserverImpl observer;
116
117 /**
118 * @tc.steps: step1. Register observer base on kv db.
119 * @tc.expected: step1. Register successfully.
120 */
121 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
122 EXPECT_TRUE(status == DBStatus::OK);
123
124 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
125 EXPECT_TRUE(statusRelease == DBStatus::OK);
126 }
127
128 /*
129 * @tc.name: ObserverRegister 002
130 * @tc.desc: Verify that can register a null observer on kv db.
131 * @tc.type: FUNC
132 * @tc.require: SR000BUH3K
133 * @tc.author: luqianfu
134 */
135 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister002, TestSize.Level1)
136 {
137 DistributedTestTools::Clear(*g_observerDelegate);
138
139 /**
140 * @tc.steps: step1. Register a null observer base on kv db.
141 * @tc.expected: step1. Register failed.
142 */
143 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, nullptr);
144 EXPECT_TRUE(status != DBStatus::OK);
145
146 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, nullptr);
147 EXPECT_TRUE(statusRelease != DBStatus::OK);
148 }
149
150 /*
151 * @tc.name: ObserverRegister 003
152 * @tc.desc: Verify that can register only once with the same observer.
153 * @tc.type: FUNC
154 * @tc.require: SR000BUH3K
155 * @tc.author: luqianfu
156 */
157 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister003, TestSize.Level1)
158 {
159 DistributedTestTools::Clear(*g_observerDelegate);
160
161 KvStoreObserverImpl observer;
162
163 /**
164 * @tc.steps: step1. Register observer 6 times base on kv db.
165 * @tc.expected: step1. First register is successful and 5 times later return null.
166 */
167 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
168 EXPECT_TRUE(status == DBStatus::OK);
169 for (int time = OPER_CNT_START; time < static_cast<int>(OPER_CNT_END); ++time) {
170 status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
171 EXPECT_TRUE(status != DBStatus::OK);
172 }
173
174 /**
175 * @tc.steps: step2. Register Put (k1,v1) to db.
176 * @tc.expected: step2. First put successfully and the observer return inserting data once.
177 */
178 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
179 EXPECT_TRUE(status == DBStatus::OK);
180
181 vector<DistributedDB::Entry> insertEntries;
182 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
183 insertEntries.push_back(entry);
184 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
185 observer.Clear();
186
187 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
188 EXPECT_TRUE(statusRelease == DBStatus::OK);
189 }
190
191 /*
192 * @tc.name: ObserverRegister 004
193 * @tc.desc: Verify that can register different observers.
194 * @tc.type: FUNC
195 * @tc.require: SR000BUH3K
196 * @tc.author: luqianfu
197 */
198 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister004, TestSize.Level1)
199 {
200 DistributedTestTools::Clear(*g_observerDelegate);
201
202 KvStoreObserverImpl observer1, observer2;
203 /**
204 * @tc.steps: step1. Register observer1 bases on kv db.
205 * @tc.expected: step1. Register successfully.
206 */
207 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer1);
208 EXPECT_TRUE(status == DBStatus::OK);
209
210 /**
211 * @tc.steps: step2. put (k1,v1) to db.
212 * @tc.expected: step2. put successfully and the observer1 return 1 inserting data info.
213 */
214 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
215 EXPECT_TRUE(status == DBStatus::OK);
216 vector<DistributedDB::Entry> insertEntries;
217 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
218 insertEntries.push_back(entry);
219 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
220 observer1.Clear();
221
222 /**
223 * @tc.steps: step3. register a null observer bases on kv db.
224 * @tc.expected: step3. register successfully.
225 */
226 status = DistributedTestTools::RegisterObserver(g_observerDelegate, nullptr);
227 EXPECT_TRUE(status != DBStatus::OK);
228 /**
229 * @tc.steps: step4. put (k2,v2) to db.
230 * @tc.expected: step4. register successfully.
231 */
232 status = DistributedTestTools::Put(*g_observerDelegate, KEY_2, VALUE_2);
233 EXPECT_TRUE(status == DBStatus::OK);
234 insertEntries.clear();
235 DistributedDB::Entry entry2 = { KEY_2, VALUE_2 };
236 insertEntries.push_back(entry2);
237 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
238 observer1.Clear();
239
240 /**
241 * @tc.steps: step5. register observer2 bases on kv db.
242 * @tc.expected: step5. register successfully.
243 */
244 status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer2);
245 EXPECT_TRUE(status == DBStatus::OK);
246
247 /**
248 * @tc.steps: step6. put (k3,v3) to db.
249 * @tc.expected: step6. put successfully and the observer1,2 return 1 inserting data info individually.
250 */
251 status = DistributedTestTools::Put(*g_observerDelegate, KEY_3, VALUE_3);
252 EXPECT_TRUE(status == DBStatus::OK);
253 insertEntries.clear();
254 DistributedDB::Entry entry3 = { KEY_3, VALUE_3 };
255 insertEntries.push_back(entry3);
256 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
257 observer1.Clear();
258 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
259 observer2.Clear();
260 // step5: clear the preset of step1(repair the config and stub)
261 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer1);
262 EXPECT_TRUE(statusRelease == DBStatus::OK);
263 statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer2);
264 EXPECT_TRUE(statusRelease == DBStatus::OK);
265 }
266
267 /*
268 * @tc.name: ObserverRegister 005
269 * @tc.desc: Verify that unregister observer (release snapshot) won't return changed data info.
270 * @tc.type: FUNC
271 * @tc.require: SR000BUH3K
272 * @tc.author: luqianfu
273 */
274 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister005, TestSize.Level1)
275 {
276 DistributedTestTools::Clear(*g_observerDelegate);
277
278 KvStoreObserverImpl observer;
279
280 /**
281 * @tc.steps: step1. Register observer1 bases on kv db.
282 * @tc.expected: step1. Register successfully to construct observer exist.
283 */
284 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
285 EXPECT_TRUE(status == DBStatus::OK);
286
287 /**
288 * @tc.steps: step2. put (k1,v1) to db.
289 * @tc.expected: step2. put successfully and the observer1 return 1 inserting data info.
290 */
291 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
292 EXPECT_TRUE(status == DBStatus::OK);
293
294 vector<DistributedDB::Entry> insertEntries;
295 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
296 insertEntries.push_back(entry);
297 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
298 observer.Clear();
299
300 /**
301 * @tc.steps: step3. unregister observer1 (release snapshot).
302 * @tc.expected: step3. operate successfully.
303 */
304 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
305 EXPECT_TRUE(statusRelease == DBStatus::OK);
306
307 /**
308 * @tc.steps: step4. put (k2,v2) to db.
309 * @tc.expected: step4. put successfully and has nothing changed data info returned.
310 */
311 status = DistributedTestTools::Put(*g_observerDelegate, KEY_2, VALUE_2);
312 EXPECT_TRUE(status == DBStatus::OK);
313 insertEntries.clear();
314 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
315 observer.Clear();
316 }
317
318 /*
319 * @tc.name: ObserverRegister 006
320 * @tc.desc: Verify that register observer, and then unregister it many times will success only firstly.
321 * @tc.type: FUNC
322 * @tc.require: SR000BUH3K
323 * @tc.author: luqianfu
324 */
325 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister006, TestSize.Level1)
326 {
327 DistributedTestTools::Clear(*g_observerDelegate);
328
329 KvStoreObserverImpl observer;
330
331 /**
332 * @tc.steps: step1. Register observer1 bases on kv db.
333 * @tc.expected: step1. Register successfully to construct observer exist.
334 */
335 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
336 EXPECT_TRUE(status == DBStatus::OK);
337
338 /**
339 * @tc.steps: step2. unregister observer1 for 5 times.
340 * @tc.expected: step2. Firstly register successfully and another failed.
341 */
342 for (int time = OPER_CNT_START; time < static_cast<int>(OPER_CNT_END); ++time) {
343 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
344 if (time == OPER_CNT_START) {
345 EXPECT_TRUE(statusRelease == DBStatus::OK);
346 }
347 else {
348 EXPECT_TRUE(statusRelease != DBStatus::OK);
349 }
350 }
351
352 /**
353 * @tc.steps: step3. put (k1,v1) to db.
354 * @tc.expected: step3. put successfully and has nothing changed data info returned.
355 */
356 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
357 EXPECT_TRUE(status == DBStatus::OK);
358 vector<DistributedDB::Entry> insertEntries;
359 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
360 observer.Clear();
361 }
362
363 /*
364 * @tc.name: ObserverRegister 007
365 * @tc.desc: Verify that unregister an unregistered observer will fail.
366 * @tc.type: FUNC
367 * @tc.require: SR000BUH3K
368 * @tc.author: luqianfu
369 */
370 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister007, TestSize.Level1)
371 {
372 DistributedTestTools::Clear(*g_observerDelegate);
373
374 KvStoreDelegate *delegate = nullptr;
375 KvStoreDelegateManager *manager = nullptr;
376 delegate = DistributedTestTools::GetDelegateSuccess(manager,
377 g_kvdbParameter2_1_1, g_kvOption);
378 ASSERT_TRUE(manager != nullptr && delegate != nullptr) << "fail to create exist kvdb";
379
380 /**
381 * @tc.steps: step1. Register observer1 bases on kv db1 snap and unregister it bases on kv db2.
382 * @tc.expected: step1. Register successfully and unregister failed.
383 */
384 KvStoreObserverImpl observer;
385 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(delegate, &observer);
386
387 EXPECT_TRUE(statusRelease != DBStatus::OK);
388
389 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
390 delegate = nullptr;
391 DBStatus status = manager->DeleteKvStore(STORE_ID_2);
392 EXPECT_TRUE(status == DBStatus::OK) << "fail to delete exist kvdb";
393 delete manager;
394 manager = nullptr;
395 }
396
397 /*
398 * @tc.name: ObserverRegister 008
399 * @tc.desc: Verify that observer will not be called after unregister.
400 * @tc.type: FUNC
401 * @tc.require: SR000BUH3K
402 * @tc.author: luqianfu
403 */
404 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister008, TestSize.Level1)
405 {
406 DistributedTestTools::Clear(*g_observerDelegate);
407
408 KvStoreDelegate *delegate1 = nullptr;
409 KvStoreDelegate *delegate2 = nullptr;
410 KvStoreDelegateManager *manager1 = nullptr;
411 KvStoreDelegateManager *manager2 = nullptr;
412
413 /**
414 * @tc.steps: step1. open delegate1 and delegate2 from hv db2.
415 * @tc.expected: step1. open successfully.
416 */
417 delegate1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter2_1_1, g_kvOption);
418 ASSERT_TRUE(manager1 != nullptr && delegate1 != nullptr);
419 KvOption option = g_kvOption;
420 option.createIfNecessary = IS_NOT_NEED_CREATE;
421 EXPECT_TRUE(delegate1 != nullptr) << "fail to create exist kvdb";
422 delegate2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2_1_1, option);
423 ASSERT_TRUE(manager2 != nullptr && delegate2 != nullptr);
424
425 /**
426 * @tc.steps: step2. Register observer1 bases on kv db2 and close delegate1.
427 * @tc.expected: step2. Register and close successfully.
428 */
429 KvStoreObserverImpl observer1;
430 DBStatus status = DistributedTestTools::RegisterObserver(delegate1, &observer1);
431 EXPECT_TRUE(status == DBStatus::OK);
432 EXPECT_TRUE(manager1->CloseKvStore(delegate1) == OK);
433 delegate1 = nullptr;
434
435 /**
436 * @tc.steps: step3. put (k1,v1) to delegate2.
437 * @tc.expected: step3. observer1 return nothing.
438 */
439 status = DistributedTestTools::Put(*delegate2, KEY_1, VALUE_1);
440 EXPECT_TRUE(status == DBStatus::OK);
441 vector<DistributedDB::Entry> insertEntries;
442 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
443 observer1.Clear();
444
445 EXPECT_TRUE(manager2->CloseKvStore(delegate2) == OK);
446 delegate2 = nullptr;
447 status = manager2->DeleteKvStore(STORE_ID_2);
448 EXPECT_TRUE(status == DBStatus::OK) << "fail to delete exist kvdb";
449 delete manager1;
450 manager1 = nullptr;
451 delete manager2;
452 manager2 = nullptr;
453 }
454
455 /*
456 * @tc.name: ObserverRegister 009
457 * @tc.desc: Delete kv db, and verify observer will not be activated.
458 * @tc.type: FUNC
459 * @tc.require: SR000BUH3K
460 * @tc.author: luqianfu
461 */
462 HWTEST_F(DistributeddbKvObserverTest, ObserverRegister009, TestSize.Level1)
463 {
464 DistributedTestTools::Clear(*g_observerDelegate);
465
466 KvStoreDelegate *delegate1 = nullptr;
467 KvStoreDelegateManager *manager1 = nullptr;
468 delegate1 = DistributedTestTools::GetDelegateSuccess(manager1,
469 g_kvdbParameter2_1_1, g_kvOption);
470 ASSERT_TRUE(manager1 != nullptr && delegate1 != nullptr) << "fail to create exist kvdb";
471
472 /**
473 * @tc.steps: step1. Register observer1 bases on kv db2 and put(k1,v1).
474 * @tc.expected: step1. Register successfully and observer1 return a inserting data info.
475 */
476 KvStoreObserverImpl observer1;
477 DBStatus status = DistributedTestTools::RegisterObserver(delegate1, &observer1);
478 EXPECT_TRUE(status == OK);
479 DBStatus statusPut = DistributedTestTools::Put(*delegate1, KEY_1, VALUE_1);
480 EXPECT_TRUE(statusPut == DBStatus::OK);
481
482 vector<DistributedDB::Entry> insertEntries;
483 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
484 insertEntries.push_back(entry);
485 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
486 observer1.Clear();
487
488 /**
489 * @tc.steps: step2. close db then delete db.
490 * @tc.expected: step2. operate successfully and observer1 return nothing.
491 */
492 EXPECT_TRUE(manager1->CloseKvStore(delegate1) == OK);
493 delegate1 = nullptr;
494 EXPECT_TRUE(manager1->DeleteKvStore(STORE_ID_2) == OK);
495 vector<DistributedDB::Entry> deleteEntries;
496 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ZERO_TIME, DELETE_LIST, deleteEntries));
497 observer1.Clear();
498
499 delete manager1;
500 manager1 = nullptr;
501 }
502
503 /*
504 * @tc.name: DataChange 001
505 * @tc.desc: verify that can observer for inserting a record.
506 * @tc.type: FUNC
507 * @tc.require: SR000BUH3K
508 * @tc.author: luqianfu
509 */
510 HWTEST_F(DistributeddbKvObserverTest, DataChange001, TestSize.Level1)
511 {
512 DistributedTestTools::Clear(*g_observerDelegate);
513
514 /**
515 * @tc.steps: step1. Register observer1 bases on kv db2.
516 * @tc.expected: step1. Register successfully to construct observer exist.
517 */
518 KvStoreObserverImpl observer;
519 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
520 EXPECT_TRUE(status == DBStatus::OK);
521
522 /**
523 * @tc.steps: step2. put (k1,v1) to db.
524 * @tc.expected: step2. put successfully and observer1 return a insert data info.
525 */
526 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
527 EXPECT_TRUE(status == DBStatus::OK);
528 vector<DistributedDB::Entry> insertEntries;
529 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
530 insertEntries.push_back(entry);
531 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
532 observer.Clear();
533
534 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
535 EXPECT_TRUE(statusRelease == DBStatus::OK);
536 }
537
538 /*
539 * @tc.name: DataChange 002
540 * @tc.desc: verify that can observer for updating a record.
541 * @tc.type: FUNC
542 * @tc.require: SR000BUH3K
543 * @tc.author: luqianfu
544 */
545 HWTEST_F(DistributeddbKvObserverTest, DataChange002, TestSize.Level1)
546 {
547 DistributedTestTools::Clear(*g_observerDelegate);
548 vector<Entry> entries1;
549 entries1.push_back(ENTRY_1);
550 entries1.push_back(ENTRY_2);
551
552 /**
553 * @tc.steps: step1. putBatch (k1,v1)(k2,v2) and register observer1 bases on kv db2.
554 * @tc.expected: step1. operate successfully to construct data and observer exist.
555 */
556 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
557 EXPECT_TRUE(statusPut == DBStatus::OK);
558
559 KvStoreObserverImpl observer;
560 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
561 EXPECT_TRUE(status == DBStatus::OK);
562
563 /**
564 * @tc.steps: step2. update (k1,v1) to (k1,v2).
565 * @tc.expected: step2. update successfully and observer return a updating data info.
566 */
567 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_2);
568 EXPECT_TRUE(status == DBStatus::OK);
569
570 vector<DistributedDB::Entry> updateEntries;
571 DistributedDB::Entry entry = { KEY_1, VALUE_2 };
572 updateEntries.push_back(entry);
573 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, UPDATE_LIST, updateEntries));
574 observer.Clear();
575
576 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
577 EXPECT_TRUE(statusRelease == DBStatus::OK);
578 }
579
580 /*
581 * @tc.name: DataChange 003
582 * @tc.desc: verify that can observer for deleting a record.
583 * @tc.type: FUNC
584 * @tc.require: SR000BUH3K
585 * @tc.author: luqianfu
586 */
587 HWTEST_F(DistributeddbKvObserverTest, DataChange003, TestSize.Level1)
588 {
589 DistributedTestTools::Clear(*g_observerDelegate);
590 vector<Entry> entries1;
591 entries1.push_back(ENTRY_1);
592 entries1.push_back(ENTRY_2);
593
594 /**
595 * @tc.steps: step1. putBatch (k1,v1)(k2,v2) and register observer1 bases on kv db2.
596 * @tc.expected: step1. operate successfully to construct data and observer exist.
597 */
598 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
599 EXPECT_TRUE(statusPut == DBStatus::OK);
600 KvStoreObserverImpl observer;
601 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
602 EXPECT_TRUE(status == DBStatus::OK);
603
604 /**
605 * @tc.steps: step2. delete from kb.
606 * @tc.expected: step2. delete successfully and observer return a deleting data info.
607 */
608 status = DistributedTestTools::Delete(*g_observerDelegate, KEY_1);
609 EXPECT_TRUE(status == DBStatus::OK);
610
611 vector<DistributedDB::Entry> deleteEntries;
612 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
613 deleteEntries.push_back(entry);
614 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries));
615 observer.Clear();
616
617 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
618 EXPECT_TRUE(statusRelease == DBStatus::OK);
619 }
620
621 /*
622 * @tc.name: DataChange 004
623 * @tc.desc: verify that can observer for batch inserting.
624 * @tc.type: FUNC
625 * @tc.require: SR000BUH3K
626 * @tc.author: luqianfu
627 */
628 HWTEST_F(DistributeddbKvObserverTest, DataChange004, TestSize.Level1)
629 {
630 DistributedTestTools::Clear(*g_observerDelegate);
631
632 /**
633 * @tc.steps: step1. register observer1 bases on kv db2 and putBatch (k1,v1)(k2,v2).
634 * @tc.expected: step1. operate successfully.
635 */
636 KvStoreObserverImpl observer;
637 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
638 EXPECT_TRUE(status == DBStatus::OK);
639
640 vector<Entry> entries1;
641 entries1.push_back(ENTRY_1);
642 entries1.push_back(ENTRY_2);
643 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
644 EXPECT_TRUE(statusPut == DBStatus::OK);
645
646 /**
647 * @tc.steps: step2. check callback.
648 * @tc.expected: step2. observer1 return a batch inserting data info.
649 */
650 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, entries1));
651 observer.Clear();
652
653 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
654 EXPECT_TRUE(statusRelease == DBStatus::OK);
655 }
656
657 /*
658 * @tc.name: DataChange 005
659 * @tc.desc: verify that can observer for batch updating.
660 * @tc.type: FUNC
661 * @tc.require: SR000BUH3K
662 * @tc.author: luqianfu
663 */
664 HWTEST_F(DistributeddbKvObserverTest, DataChange005, TestSize.Level1)
665 {
666 DistributedTestTools::Clear(*g_observerDelegate);
667 vector<Entry> entries1;
668 entries1.push_back(ENTRY_1);
669 entries1.push_back(ENTRY_2);
670
671 /**
672 * @tc.steps: step1. putBatch (k1,v1)(k2,v2) and register observer1 bases on kv db2.
673 * @tc.expected: step1. operate successfully to construct data and observer1 exist.
674 */
675 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
676 EXPECT_TRUE(statusPut == DBStatus::OK);
677 KvStoreObserverImpl observer;
678 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
679 EXPECT_TRUE(status == DBStatus::OK);
680
681 /**
682 * @tc.steps: step2. updateBatch (k1,v1)(k2,v2) to (k1,v2)(k2,v3) and check callback.
683 * @tc.expected: step2. observer1 return a batch updating data info.
684 */
685 vector<Entry> entries2;
686 entries2.push_back(ENTRY_1_2);
687 entries2.push_back(ENTRY_2_3);
688 statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries2);
689 EXPECT_TRUE(statusPut == DBStatus::OK);
690
691 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, UPDATE_LIST, entries2));
692 observer.Clear();
693
694 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
695 EXPECT_TRUE(statusRelease == DBStatus::OK);
696 }
697
698 /*
699 * @tc.name: DataChange 006
700 * @tc.desc: verify that can observer for batch deleting.
701 * @tc.type: FUNC
702 * @tc.require: SR000BUH3K
703 * @tc.author: luqianfu
704 */
705 HWTEST_F(DistributeddbKvObserverTest, DataChange006, TestSize.Level1)
706 {
707 DistributedTestTools::Clear(*g_observerDelegate);
708 vector<Entry> entries1;
709 entries1.push_back(ENTRY_1);
710 entries1.push_back(ENTRY_2);
711
712 /**
713 * @tc.steps: step1. putBatch (k1,v1)(k2,v2) and register observer1 bases on kv db2.
714 * @tc.expected: step1. operate successfully to construct data and observer1 exist.
715 */
716 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
717 EXPECT_TRUE(statusPut == DBStatus::OK);
718 KvStoreObserverImpl observer;
719 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
720 EXPECT_TRUE(status == DBStatus::OK);
721
722 /**
723 * @tc.steps: step2. deleteBatch (k1)(k2) from db and check callback.
724 * @tc.expected: step2. observer1 return a batch deleting data info.
725 */
726 vector<Key> keys1;
727 keys1.push_back(ENTRY_1.key);
728 keys1.push_back(ENTRY_2.key);
729 DBStatus statusDelete = DistributedTestTools::DeleteBatch(*g_observerDelegate, keys1);
730 EXPECT_TRUE(statusDelete == DBStatus::OK);
731
732 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, entries1));
733 observer.Clear();
734
735 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
736 EXPECT_TRUE(statusRelease == DBStatus::OK);
737 }
738
739 /*
740 * @tc.name: DataChange 007
741 * @tc.desc: verify that can observer for clearing.
742 * @tc.type: FUNC
743 * @tc.require: SR000BUH3K
744 * @tc.author: luqianfu
745 */
746 HWTEST_F(DistributeddbKvObserverTest, DataChange007, TestSize.Level1)
747 {
748 DistributedTestTools::Clear(*g_observerDelegate);
749 vector<Entry> entries1;
750 entries1.push_back(ENTRY_1);
751 entries1.push_back(ENTRY_2);
752
753 /**
754 * @tc.steps: step1. putBatch (k1,v1)(k2,v2) and register observer1 bases on kv db2.
755 * @tc.expected: step1. operate successfully to construct data and observer1 exist.
756 */
757 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries1);
758 EXPECT_TRUE(statusPut == DBStatus::OK);
759
760 KvStoreObserverImpl observer;
761 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
762 EXPECT_TRUE(status == DBStatus::OK);
763
764 /**
765 * @tc.steps: step2. deleteBatch (k1)(k2) from db and check callback.
766 * @tc.expected: step2. observer1 return a clear data info.
767 */
768 DBStatus statusClear = DistributedTestTools::Clear(*g_observerDelegate);
769 EXPECT_TRUE(statusClear == DBStatus::OK);
770
771 vector<DistributedDB::Entry> deleteEntries;
772 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries));
773 observer.Clear();
774
775 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
776 EXPECT_TRUE(statusRelease == DBStatus::OK);
777 }
778
779 /*
780 * @tc.name: DataChange 008
781 * @tc.desc: verify that observer won't be activated if inserting null key.
782 * @tc.type: FUNC
783 * @tc.require: SR000BUH3K
784 * @tc.author: luqianfu
785 */
786 HWTEST_F(DistributeddbKvObserverTest, DataChange008, TestSize.Level1)
787 {
788 DistributedTestTools::Clear(*g_observerDelegate);
789
790 /**
791 * @tc.steps: step1. register observer1 bases on kv db2 and put (k=null,v=ok).
792 * @tc.expected: step1. register successfully and put failed.
793 */
794 KvStoreObserverImpl observer;
795 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
796 EXPECT_TRUE(status == DBStatus::OK);
797
798 DBStatus statusPut = DistributedTestTools::Put(*g_observerDelegate, KEY_EMPTY, OK_VALUE_1);
799 EXPECT_TRUE(statusPut != DBStatus::OK);
800
801 /**
802 * @tc.steps: step2. check callback.
803 * @tc.expected: step2. observer1 return nothing.
804 */
805 vector<DistributedDB::Entry> insertEntries;
806 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
807 observer.Clear();
808
809 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
810 EXPECT_TRUE(statusRelease == DBStatus::OK);
811 }
812
813 /*
814 * @tc.name: DataChange 009
815 * @tc.desc: verify that observer won't be activated if batch inserting failed.
816 * @tc.type: FUNC
817 * @tc.require: SR000BUH3K
818 * @tc.author: luqianfu
819 */
820 HWTEST_F(DistributeddbKvObserverTest, DataChange009, TestSize.Level1)
821 {
822 DistributedTestTools::Clear(*g_observerDelegate);
823
824 /**
825 * @tc.steps: step1. register observer1 bases on kv db2 and putBatch (k1=null,v1)(k2,v2).
826 * @tc.expected: step1. register successfully and putBatch failed.
827 */
828 KvStoreObserverImpl observer;
829
830 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
831 EXPECT_TRUE(status == DBStatus::OK);
832
833 vector<Entry> entries;
834 entries.push_back(ENTRY_NULL_1); // null key with VALUE_1.
835 entries.push_back(ENTRY_2);
836 DBStatus statusPut = DistributedTestTools::PutBatch(*g_observerDelegate, entries);
837 EXPECT_TRUE(statusPut != DBStatus::OK);
838
839 /**
840 * @tc.steps: step2. check callback.
841 * @tc.expected: step2. observer1 return nothing.
842 */
843 vector<DistributedDB::Entry> insertEntries;
844 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
845 observer.Clear();
846
847 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
848 EXPECT_TRUE(statusRelease == DBStatus::OK);
849 }
850
KvObserverVerifyInsert(KvStoreDelegate * & delegate1,KvStoreDelegate * & delegate2,KvStoreObserverImpl & observer1,KvStoreObserverImpl & observer2)851 vector<Entry> KvObserverVerifyInsert(KvStoreDelegate *&delegate1, KvStoreDelegate *&delegate2,
852 KvStoreObserverImpl &observer1, KvStoreObserverImpl &observer2)
853 {
854 vector<DistributedDB::Entry> insertEntries1;
855 vector<DistributedDB::Entry> insertEntries2;
856 DBStatus statusPut = DistributedTestTools::Put(*delegate1, KEY_A_1, VALUE_A_1);
857 EXPECT_TRUE(statusPut == DBStatus::OK);
858
859 DistributedDB::Entry entry = { KEY_A_1, VALUE_A_1 };
860 insertEntries1.push_back(entry);
861 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, insertEntries1));
862 observer1.Clear();
863 insertEntries2.push_back(entry);
864 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ONE_TIME, INSERT_LIST, insertEntries2));
865 observer2.Clear();
866
867 vector<Entry> entriesBatch;
868 vector<Key> allKeys;
869 GenerateRecords(TEN_RECORDS, DEFAULT_START, allKeys, entriesBatch);
870 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*delegate1, entriesBatch);
871 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
872
873 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, entriesBatch));
874 observer1.Clear();
875 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ONE_TIME, INSERT_LIST, entriesBatch));
876 observer2.Clear();
877
878 DBStatus statusDelete = DistributedTestTools::Delete(*delegate1, KEY_A_1);
879 EXPECT_TRUE(statusDelete == DBStatus::OK);
880
881 vector<DistributedDB::Entry> deleteEntries1;
882 deleteEntries1.push_back(entry);
883 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries1));
884 observer1.Clear();
885 vector<DistributedDB::Entry> deleteEntries2;
886 deleteEntries2.push_back(entry);
887 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries2));
888 observer2.Clear();
889
890 return entriesBatch;
891 }
892
KvObserverVerifyUpdateAndDelete(KvStoreDelegate * & delegate1,KvStoreDelegate * & delegate2,KvStoreObserverImpl & observer1,KvStoreObserverImpl & observer2,vector<Entry> & entriesBatch)893 vector<DistributedDB::Entry> KvObserverVerifyUpdateAndDelete(KvStoreDelegate *&delegate1, KvStoreDelegate *&delegate2,
894 KvStoreObserverImpl &observer1, KvStoreObserverImpl &observer2, vector<Entry> &entriesBatch)
895 {
896 DBStatus statusPut = DistributedTestTools::Put(*delegate1, KEY_1, VALUE_2);
897 EXPECT_TRUE(statusPut == DBStatus::OK);
898 entriesBatch.front().value = VALUE_2;
899 vector<DistributedDB::Entry> updateEntries1;
900 DistributedDB::Entry entry1 = { KEY_1, VALUE_2 };
901 updateEntries1.push_back(entry1);
902 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, UPDATE_LIST, updateEntries1));
903 observer1.Clear();
904 vector<DistributedDB::Entry> updateEntries2;
905 updateEntries2.push_back(entry1);
906 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ONE_TIME, UPDATE_LIST, updateEntries2));
907 observer2.Clear();
908 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(delegate2, &observer2);
909 EXPECT_TRUE(statusRelease == DBStatus::OK);
910 for (auto itEntriesBatch = entriesBatch.begin(); itEntriesBatch != entriesBatch.end(); ++itEntriesBatch) {
911 itEntriesBatch->value.push_back('A');
912 }
913 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*delegate1, entriesBatch);
914 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
915
916 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, UPDATE_LIST, entriesBatch));
917 observer1.Clear();
918 updateEntries2.clear();
919 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ZERO_TIME, UPDATE_LIST, updateEntries2));
920 observer2.Clear();
921 vector<Key> keys1;
922 vector<DistributedDB::Entry> deleteBatch;
923 for (int time = OPER_CNT_START; time < static_cast<int>(OPER_CNT_END); ++time) {
924 keys1.push_back(entriesBatch.back().key);
925 deleteBatch.push_back(entriesBatch.back());
926 entriesBatch.pop_back();
927 }
928 DBStatus statusDelete = DistributedTestTools::DeleteBatch(*delegate1, keys1);
929 EXPECT_TRUE(statusDelete == DBStatus::OK);
930 vector<DistributedDB::Entry> deleteEntries1;
931 deleteEntries1.clear();
932 deleteEntries1 = deleteBatch;
933 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries1));
934 return deleteEntries1;
935 }
936
937 /*
938 * @tc.name: DataChange 010
939 * @tc.desc: verify that can observer for complex data changing.
940 * @tc.type: FUNC
941 * @tc.require: SR000BUH3K
942 * @tc.author: luqianfu
943 */
944 HWTEST_F(DistributeddbKvObserverTest, DataChange010, TestSize.Level2)
945 {
946 DistributedTestTools::Clear(*g_observerDelegate);
947
948 KvStoreDelegate *delegate1 = nullptr;
949 KvStoreDelegate *delegate2 = nullptr;
950 KvStoreDelegateManager *manager1 = nullptr;
951 KvStoreDelegateManager *manager2 = nullptr;
952 delegate1 = DistributedTestTools::GetDelegateSuccess(manager1,
953 g_kvdbParameter2, g_kvOption);
954 ASSERT_TRUE(manager1 != nullptr && delegate1 != nullptr) << "fail to create exist kvdb";
955 KvOption option = g_kvOption;
956 option.createIfNecessary = IS_NOT_NEED_CREATE;
957 delegate2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2, option);
958 ASSERT_TRUE(manager2 != nullptr && delegate2 != nullptr);
959 KvStoreObserverImpl observer1, observer2;
960
961 /**
962 * @tc.steps: step1. register observer1 bases on kv db.
963 * @tc.expected: step1. register successfully.
964 */
965 DBStatus status = DistributedTestTools::RegisterObserver(delegate1, &observer1);
966 EXPECT_TRUE(status == DBStatus::OK);
967
968 /**
969 * @tc.steps: step2. register observer2 bases on kv db.
970 * @tc.expected: step2. register successfully.
971 */
972 status = DistributedTestTools::RegisterObserver(delegate2, &observer2);
973 EXPECT_TRUE(status == DBStatus::OK);
974
975 /**
976 * @tc.steps: step3. put (k="abc",v="a1") and putBatch 10 items (keys,values) then delete (k=abc).
977 * @tc.expected: step3. operate successfully and both of observer1,2 return changes data info.
978 */
979 vector<Entry> entriesBatch = KvObserverVerifyInsert(delegate1, delegate2, observer1, observer2);
980
981 /**
982 * @tc.steps: step4. update (k1,v1) to (k1,v2), release observer2 and putBatch then deleteBatch.
983 * @tc.expected: step4. operate successfully and only observer1 return changed data info.
984 */
985 vector<DistributedDB::Entry> deleteEntries1 = KvObserverVerifyUpdateAndDelete(delegate1, delegate2,
986 observer1, observer2, entriesBatch);
987 observer1.Clear();
988
989 /**
990 * @tc.steps: step5. clear db.
991 * @tc.expected: step5. observer1 return a delete data info.
992 */
993 DBStatus statusClear = DistributedTestTools::Clear(*delegate1);
994 EXPECT_TRUE(statusClear == DBStatus::OK);
995 deleteEntries1.clear();
996 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries1));
997 observer1.Clear();
998
999 /**
1000 * @tc.steps: step6. unregister observer1.
1001 * @tc.expected: step6. unregister successfully.
1002 */
1003 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(delegate1, &observer1);
1004 EXPECT_TRUE(statusRelease == DBStatus::OK);
1005 EXPECT_TRUE(manager1->CloseKvStore(delegate1) == OK);
1006 delegate1 = nullptr;
1007 EXPECT_TRUE(manager2->CloseKvStore(delegate2) == OK);
1008 delegate2 = nullptr;
1009 status = manager2->DeleteKvStore(STORE_ID_2);
1010 EXPECT_EQ(status, DistributedDB::DBStatus::OK);
1011 delete manager1;
1012 manager1 = nullptr;
1013 delete manager2;
1014 manager2 = nullptr;
1015 }
1016
KvObserverVerifyTransactionCommit(KvStoreObserverImpl & observer1,KvStoreDelegate * & delegate1,KvStoreDelegateManager * & transactionManager1)1017 void KvObserverVerifyTransactionCommit(KvStoreObserverImpl &observer1,
1018 KvStoreDelegate *&delegate1, KvStoreDelegateManager *&transactionManager1)
1019 {
1020 vector<Entry> entriesBatch;
1021 vector<Key> allKeys;
1022 GenerateRecords(TEN_RECORDS, DEFAULT_START, allKeys, entriesBatch);
1023 DBStatus statusStart = delegate1->StartTransaction();
1024 EXPECT_TRUE(statusStart == DBStatus::OK);
1025 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*delegate1, entriesBatch);
1026 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1027 DBStatus statusDelete = DistributedTestTools::Delete(*delegate1, KEY_1);
1028 EXPECT_TRUE(statusDelete == DBStatus::OK);
1029
1030 entriesBatch.erase(entriesBatch.begin());
1031 DBStatus statusPut = DistributedTestTools::Put(*delegate1, KEY_2, VALUE_3);
1032 EXPECT_TRUE(statusPut == DBStatus::OK);
1033 entriesBatch.front().value = VALUE_3;
1034 vector<Key> keys;
1035 for (int time = DELETE_CNT_START; time < static_cast<int>(DELETE_CNT_END); ++time) {
1036 keys.push_back(entriesBatch.back().key);
1037 entriesBatch.pop_back();
1038 }
1039 statusDelete = DistributedTestTools::DeleteBatch(*delegate1, keys);
1040 EXPECT_TRUE(statusDelete == DBStatus::OK);
1041
1042 vector<DistributedDB::Entry> insertEntries;
1043 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
1044 vector<DistributedDB::Entry> updateEntries;
1045 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ZERO_TIME, UPDATE_LIST, updateEntries));
1046 vector<DistributedDB::Entry> deleteEntries;
1047 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ZERO_TIME, DELETE_LIST, deleteEntries));
1048 observer1.Clear();
1049 DBStatus statusCommit = delegate1->Commit();
1050 EXPECT_TRUE(statusCommit == DBStatus::OK);
1051
1052 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, INSERT_LIST, entriesBatch));
1053 updateEntries.clear();
1054 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, UPDATE_LIST, updateEntries));
1055 deleteEntries.clear();
1056 EXPECT_TRUE(VerifyObserverResult(observer1, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries));
1057 observer1.Clear();
1058 EXPECT_TRUE(DistributedTestTools::UnRegisterObserver(delegate1, &observer1) == OK);
1059 EXPECT_TRUE(transactionManager1->CloseKvStore(delegate1) == OK);
1060 delegate1 = nullptr;
1061 }
1062
KvObserverVerifyTransactionRollback(KvStoreObserverImpl & observer2,KvStoreDelegate * & delegate2)1063 void KvObserverVerifyTransactionRollback(KvStoreObserverImpl &observer2, KvStoreDelegate *&delegate2)
1064 {
1065 vector<Entry> entriesBatch2;
1066 vector<Key> allKeys2;
1067 GenerateRecords(TEN_RECORDS, DEFAULT_ANOTHER_START, allKeys2, entriesBatch2);
1068
1069 DBStatus statusStart = delegate2->StartTransaction();
1070 EXPECT_TRUE(statusStart == DBStatus::OK);
1071 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*delegate2, entriesBatch2);
1072 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1073 DBStatus statusDelete = DistributedTestTools::Delete(*delegate2, entriesBatch2[0].key);
1074 EXPECT_TRUE(statusDelete == DBStatus::OK);
1075 entriesBatch2.erase(entriesBatch2.begin());
1076 DBStatus statusPut = DistributedTestTools::Put(*delegate2, entriesBatch2[1].key, VALUE_3);
1077 EXPECT_TRUE(statusPut == DBStatus::OK);
1078 entriesBatch2.front().value = VALUE_3;
1079
1080 vector<Key> keys2;
1081 for (int time = DELETE_CNT_START; time < static_cast<int>(DELETE_CNT_END); ++time) {
1082 keys2.push_back(entriesBatch2.at(time).key);
1083 }
1084 statusDelete = DistributedTestTools::DeleteBatch(*delegate2, keys2);
1085 EXPECT_TRUE(statusDelete == DBStatus::OK);
1086
1087 DBStatus statusRollback = delegate2->Rollback();
1088 EXPECT_TRUE(statusRollback == DBStatus::OK);
1089 std::this_thread::sleep_for(std::chrono::seconds(UNIQUE_SECOND));
1090
1091 // step4: check the result.
1092 vector<DistributedDB::Entry> insertEntries2;
1093 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries2));
1094 observer2.Clear();
1095 vector<DistributedDB::Entry> updateEntries2;
1096 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ZERO_TIME, UPDATE_LIST, updateEntries2));
1097 observer2.Clear();
1098 vector<DistributedDB::Entry> deleteEntries2;
1099 EXPECT_TRUE(VerifyObserverResult(observer2, CHANGED_ZERO_TIME, DELETE_LIST, deleteEntries2));
1100 observer2.Clear();
1101 }
1102
1103 /*
1104 * @tc.name: DataChange 011
1105 * @tc.desc: verify that can observer for transaction operating changing.
1106 * @tc.type: FUNC
1107 * @tc.require: SR000BUH3K
1108 * @tc.author: luqianfu
1109 */
1110 HWTEST_F(DistributeddbKvObserverTest, DataChange011, TestSize.Level2)
1111 {
1112 DistributedTestTools::Clear(*g_observerDelegate);
1113
1114 KvStoreObserverImpl observer1;
1115 KvStoreObserverImpl observer2;
1116
1117 KvStoreDelegate *delegate1 = nullptr;
1118 KvStoreDelegateManager *transactionManager1 = nullptr;
1119 delegate1 = DistributedTestTools::GetDelegateSuccess(transactionManager1,
1120 g_kvdbParameter2, g_kvOption);
1121 ASSERT_TRUE(transactionManager1 != nullptr && delegate1 != nullptr);
1122
1123 /**
1124 * @tc.steps: step1. register observer1 bases on kv db.
1125 * @tc.expected: step1. register successfully.
1126 */
1127 DBStatus status = DistributedTestTools::RegisterObserver(delegate1, &observer1);
1128 EXPECT_TRUE(status == DBStatus::OK);
1129
1130 /**
1131 * @tc.steps: step2. start transaction, putBatch 10(keys,values), delete(k1), put(k2,v3), deleteBatch(k9)(k8).
1132 * @tc.expected: step2. operate successfully and observer1 return corresponding changed data info.
1133 */
1134 KvObserverVerifyTransactionCommit(observer1, delegate1, transactionManager1);
1135
1136 /**
1137 * @tc.steps: step3. register observer2 bases on kv db.
1138 * @tc.expected: step3. register successfully.
1139 */
1140 KvStoreDelegate *delegate2 = nullptr;
1141 KvStoreDelegateManager *transactionManager2 = nullptr;
1142 delegate2 = DistributedTestTools::GetDelegateSuccess(transactionManager2, g_kvdbParameter1_2_2, g_kvOption);
1143 ASSERT_TRUE(transactionManager2 != nullptr && delegate2 != nullptr);
1144 status = DistributedTestTools::RegisterObserver(delegate2, &observer2);
1145 EXPECT_TRUE(delegate2 != nullptr);
1146
1147 /**
1148 * @tc.steps: step4. repeat step2 but don'commit transaction ,rollback it.
1149 * @tc.expected: step4. operate successfully and observer2 return nothing.
1150 */
1151 KvObserverVerifyTransactionRollback(observer2, delegate2);
1152
1153 EXPECT_TRUE(DistributedTestTools::UnRegisterObserver(delegate2, &observer2) == OK);
1154 EXPECT_TRUE(transactionManager2->CloseKvStore(delegate2) == OK);
1155 delegate2 = nullptr;
1156
1157 status = transactionManager2->DeleteKvStore(STORE_ID_2);
1158 EXPECT_TRUE(status == DistributedDB::DBStatus::OK);
1159 delete transactionManager1;
1160 transactionManager1 = nullptr;
1161 delete transactionManager2;
1162 transactionManager2 = nullptr;
1163 }
1164
1165 /*
1166 * @tc.name: ObserverPressure 001
1167 * @tc.desc: verify that support many observers for inserting a record.
1168 * @tc.type: FUNC
1169 * @tc.require: SR000BUH3K
1170 * @tc.author: luqianfu
1171 */
1172 HWTEST_F(DistributeddbKvObserverTest, ObserverPressure001, TestSize.Level2)
1173 {
1174 int countPerDelegate = 8;
1175
1176 DistributedTestTools::Clear(*g_observerDelegate);
1177
1178 /**
1179 * @tc.steps: step1. register 8 observers bases on kv db.
1180 * @tc.expected: step1. register successfully.
1181 */
1182 KvStoreObserverImpl observers[OBSERVER_NUM];
1183 KvStoreDelegate *delegate = nullptr;
1184 KvStoreDelegateManager *transactionManagers = nullptr;
1185 int obsCnt;
1186
1187 for (obsCnt = OBSERVER_CNT_START; obsCnt < static_cast<int>(OBSERVER_CNT_END); ++obsCnt) {
1188 if (obsCnt % countPerDelegate == 0) {
1189 delegate = DistributedTestTools::GetDelegateSuccess(transactionManagers,
1190 g_kvdbParameter1, g_kvOption);
1191 ASSERT_TRUE(transactionManagers != nullptr && delegate != nullptr);
1192 }
1193 DBStatus status = DistributedTestTools::RegisterObserver(delegate, &observers[obsCnt]);
1194 EXPECT_TRUE(status == OK);
1195 }
1196
1197 /**
1198 * @tc.steps: step2. put (k1,v="ok").
1199 * @tc.expected: step2. put successfully and all of observers can return a inserting data info.
1200 */
1201 DBStatus statusPut = DistributedTestTools::Put(*g_observerDelegate, KEY_1, OK_VALUE_1);
1202 EXPECT_TRUE(statusPut == DBStatus::OK);
1203
1204 vector<DistributedDB::Entry> insertEntries;
1205 DistributedDB::Entry entry = { KEY_1, OK_VALUE_1 };
1206 insertEntries.push_back(entry);
1207 for (obsCnt = OBSERVER_CNT_START; obsCnt < static_cast<int>(OBSERVER_CNT_END); ++obsCnt) {
1208 EXPECT_TRUE(VerifyObserverResult(observers[obsCnt], CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
1209 observers[obsCnt].Clear();
1210 }
1211
1212 for (obsCnt = OBSERVER_CNT_START; obsCnt < static_cast<int>(OBSERVER_CNT_END); ++obsCnt) {
1213 EXPECT_EQ(DistributedTestTools::UnRegisterObserver(delegate, &observers[obsCnt]), OK);
1214 if (obsCnt % countPerDelegate == 7) {
1215 EXPECT_TRUE(transactionManagers->CloseKvStore(delegate) == OK);
1216 delegate = nullptr;
1217 delete transactionManagers;
1218 transactionManagers = nullptr;
1219 }
1220 }
1221 }
1222
1223 /*
1224 * @tc.name: ObserverPressure 002
1225 * @tc.desc: verify that support observer for inserting a big key record.
1226 * @tc.type: FUNC
1227 * @tc.require: SR000BUH3K
1228 * @tc.author: luqianfu
1229 */
1230 HWTEST_F(DistributeddbKvObserverTest, ObserverPressure002, TestSize.Level2)
1231 {
1232 DistributedTestTools::Clear(*g_observerDelegate);
1233
1234 /**
1235 * @tc.steps: step1. register an observer bases on kv db.
1236 * @tc.expected: step1. register successfully.
1237 */
1238 KvStoreObserverImpl observer;
1239 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1240 EXPECT_TRUE(status == DBStatus::OK);
1241
1242 /**
1243 * @tc.steps: step2. put (k,v) that the size of k is 1K.
1244 * @tc.expected: step2. put successfully and observer can return a inserting data info.
1245 */
1246 Entry entryCurrent;
1247 entryCurrent.key.assign(ONE_K_LONG_STRING, 'a');
1248 entryCurrent.value = VALUE_1;
1249 status = DistributedTestTools::Put(*g_observerDelegate, entryCurrent.key, entryCurrent.value);
1250 EXPECT_TRUE(status == DBStatus::OK);
1251
1252 vector<DistributedDB::Entry> insertEntries;
1253 insertEntries.push_back(entryCurrent);
1254 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
1255 observer.Clear();
1256
1257 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1258 EXPECT_TRUE(statusRelease == DBStatus::OK);
1259 }
1260
1261 /*
1262 * @tc.name: ObserverPressure 003
1263 * @tc.desc: verify that support observer for inserting a big value record.
1264 * @tc.type: FUNC
1265 * @tc.require: SR000BUH3K
1266 * @tc.author: luqianfu
1267 */
1268 HWTEST_F(DistributeddbKvObserverTest, ObserverPressure003, TestSize.Level2)
1269 {
1270 DistributedTestTools::Clear(*g_observerDelegate);
1271
1272 KvStoreObserverImpl observer;
1273
1274 /**
1275 * @tc.steps: step1. register an observer bases on kv db.
1276 * @tc.expected: step1. register successfully.
1277 */
1278 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1279 EXPECT_TRUE(status == DBStatus::OK);
1280
1281 /**
1282 * @tc.steps: step2. put (k,v) that the size of v is 4M.
1283 * @tc.expected: step2. put successfully and observer can return a inserting data info.
1284 */
1285 Entry entryCurrent;
1286 entryCurrent.key = KEY_1;
1287 entryCurrent.value.assign(FOUR_M_LONG_STRING, 'a');
1288 status = DistributedTestTools::Put(*g_observerDelegate, entryCurrent.key, entryCurrent.value);
1289 EXPECT_TRUE(status == DBStatus::OK);
1290
1291 vector<DistributedDB::Entry> insertEntries;
1292 insertEntries.push_back(entryCurrent);
1293 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
1294 observer.Clear();
1295
1296 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1297 EXPECT_TRUE(statusRelease == DBStatus::OK);
1298 }
1299
1300 /*
1301 * @tc.name: ObserverPerformance 001
1302 * @tc.desc: test performance of subscribing for inserting, deleting, updating one record.
1303 * @tc.type: Performance
1304 * @tc.require: SR000BUH3K
1305 * @tc.author: luqianfu
1306 */
1307 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance001, TestSize.Level3)
1308 {
1309 DistributedTestTools::Clear(*g_observerDelegate);
1310
1311 KvStoreObserverImpl observer;
1312
1313 /**
1314 * @tc.steps: step1. register an observer bases on kv db.
1315 * @tc.expected: step1. register successfully.
1316 */
1317 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1318 EXPECT_TRUE(status == DBStatus::OK);
1319 auto tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1320
1321 /**
1322 * @tc.steps: step2. put (k1,v1) to db and caclute the time of observer return info.
1323 * @tc.expected: step2. put successfully, printf the time of observer return info after insert data.
1324 */
1325 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_1);
1326 EXPECT_TRUE(status == DBStatus::OK);
1327 vector<DistributedDB::Entry> insertEntries;
1328 DistributedDB::Entry entry = { KEY_1, VALUE_1 };
1329 insertEntries.push_back(entry);
1330 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, insertEntries));
1331 observer.Clear();
1332 auto duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1333 MST_LOG(" Getting notice from subscribing to insert a record costs: %lldus.", (long long)duration.count());
1334 observer.Clear();
1335
1336 /**
1337 * @tc.steps: step3. put (k1,v2) to db and caclute the time of observer return info.
1338 * @tc.expected: step3. put successfully, printf the time of observer return info after update data.
1339 */
1340 tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1341 status = DistributedTestTools::Put(*g_observerDelegate, KEY_1, VALUE_2);
1342 EXPECT_TRUE(status == DBStatus::OK);
1343 vector<DistributedDB::Entry> updateEntries;
1344 entry.value = VALUE_2;
1345 updateEntries.push_back(entry);
1346 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, UPDATE_LIST, updateEntries));
1347 observer.Clear();
1348 duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1349 MST_LOG(" Getting notice from subscribing to update a record costs: %lldus.", (long long)duration.count());
1350 observer.Clear();
1351
1352 /**
1353 * @tc.steps: step4. delete (k1) from db and caclute the time of observer return info.
1354 * @tc.expected: step4. delete successfully, printf the time of observer return info after delete data.
1355 */
1356 tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1357 status = DistributedTestTools::Delete(*g_observerDelegate, KEY_1);
1358 EXPECT_TRUE(status == DBStatus::OK);
1359 vector<DistributedDB::Entry> deleteEntries;
1360 deleteEntries.push_back(entry);
1361 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, deleteEntries));
1362 observer.Clear();
1363 duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1364 MST_LOG(" Getting notice from subscribing to delete a record costs: %lldus.", (long long)duration.count());
1365 observer.Clear();
1366
1367 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1368 EXPECT_TRUE(statusRelease == DBStatus::OK);
1369 }
1370
KvObserverBatchPerformance(KvStoreObserverImpl & observer,vector<Entry> & entriesBatch)1371 void KvObserverBatchPerformance(KvStoreObserverImpl &observer, vector<Entry> &entriesBatch)
1372 {
1373 for (auto itEntriesBatch = entriesBatch.begin(); itEntriesBatch != entriesBatch.end(); ++itEntriesBatch) {
1374 itEntriesBatch->value.push_back('A');
1375 }
1376 auto tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1377 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*g_observerDelegate, entriesBatch);
1378 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1379 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, UPDATE_LIST, entriesBatch));
1380 observer.Clear();
1381
1382 auto duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1383 MST_LOG(" Getting notice from subscribing to update 10 records costs: %lldus.", (long long)duration.count());
1384 }
1385
1386 /*
1387 * @tc.name: ObserverPerformance 002
1388 * @tc.desc: test performance of subscribing for batch inserting, deleting, updating.
1389 * @tc.type: Performance
1390 * @tc.require: SR000BUH3K
1391 * @tc.author: luqianfu
1392 */
1393 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance002, TestSize.Level3)
1394 {
1395 DistributedTestTools::Clear(*g_observerDelegate);
1396
1397 KvStoreObserverImpl observer;
1398
1399 /**
1400 * @tc.steps: step1. register an observer bases on kv db.
1401 * @tc.expected: step1. register successfully.
1402 */
1403 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1404 EXPECT_TRUE(status == DBStatus::OK);
1405
1406 /**
1407 * @tc.steps: step2. putBatch 10 items (keys,values) to db and caclute the time of observer return info.
1408 * @tc.expected: step2. putBatch successfully,printf the time of observer return info after insert 10 data.
1409 */
1410 vector<Entry> entriesBatch;
1411 vector<Key> allKeys;
1412 GenerateRecords(TEN_RECORDS, DEFAULT_START, allKeys, entriesBatch);
1413 auto tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1414 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*g_observerDelegate, entriesBatch);
1415 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1416 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, entriesBatch));
1417 observer.Clear();
1418
1419 auto duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1420 MST_LOG(" Getting notice from subscribing to insert 10 records costs: %lldus.", (long long)duration.count());
1421
1422 /**
1423 * @tc.steps: step3. updateBatch (keys,values) and caclute the time of observer return info.
1424 * @tc.expected: step3. updateBatch successfully,printf the time of observer return info after updateBatch data.
1425 */
1426 KvObserverBatchPerformance(observer, entriesBatch);
1427
1428 /**
1429 * @tc.steps: step4. deleteBatch (keys) from db and caclute the time of observer return info.
1430 * @tc.expected: step4. deleteBatch successfully,printf the time of observer return info after deleteBatch data.
1431 */
1432 tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1433 status = DistributedTestTools::DeleteBatch(*g_observerDelegate, allKeys);
1434 EXPECT_TRUE(status == DBStatus::OK);
1435 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, entriesBatch));
1436 observer.Clear();
1437
1438 duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1439 MST_LOG(" Getting notice from subscribing to delete 10 records costs: %lldus.", (long long)duration.count());
1440
1441 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1442 EXPECT_TRUE(statusRelease == DBStatus::OK);
1443 }
1444
KvObserverTransactionPerformance(KvStoreObserverImpl & observer,vector<Entry> & entriesBatch)1445 void KvObserverTransactionPerformance(KvStoreObserverImpl &observer, vector<Entry> &entriesBatch)
1446 {
1447 for (auto itEntriesBatch = entriesBatch.begin(); itEntriesBatch != entriesBatch.end(); ++itEntriesBatch) {
1448 itEntriesBatch->value.push_back('A');
1449 }
1450 auto tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1451 DBStatus statusStart = g_observerDelegate->StartTransaction();
1452 EXPECT_TRUE(statusStart == DBStatus::OK);
1453 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*g_observerDelegate, entriesBatch);
1454 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1455 DBStatus statusCommit = g_observerDelegate->Commit();
1456 EXPECT_TRUE(statusCommit == DBStatus::OK);
1457 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, UPDATE_LIST, entriesBatch));
1458 observer.Clear();
1459
1460 auto duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1461 MST_LOG(" Getting notice from subscribing a transaction to update 10 records costs: %lldus.",
1462 (long long)duration.count());
1463 }
1464
1465 /*
1466 * @tc.name: ObserverPerformance 003
1467 * @tc.desc: test performance of subscribing for transaction operation.
1468 * @tc.type: Performance
1469 * @tc.require: SR000BUH3K
1470 * @tc.author: luqianfu
1471 */
1472 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance003, TestSize.Level3)
1473 {
1474 DistributedTestTools::Clear(*g_observerDelegate);
1475
1476 KvStoreObserverImpl observer;
1477
1478 /**
1479 * @tc.steps: step1. register an observer bases on kv db.
1480 * @tc.expected: step1. register successfully.
1481 */
1482 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1483 EXPECT_TRUE(status == DBStatus::OK);
1484
1485 /**
1486 * @tc.steps: step2. start transaction and putBatch 10 items (keys,values) to db then commit.
1487 * @tc.expected: step2. operate successfully.
1488 */
1489 vector<Entry> entriesBatch;
1490 vector<Key> allKeys;
1491 GenerateRecords(TEN_RECORDS, DEFAULT_START, allKeys, entriesBatch);
1492 auto tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1493 DBStatus statusStart = g_observerDelegate->StartTransaction();
1494 EXPECT_TRUE(statusStart == DBStatus::OK);
1495 DBStatus statusPutBatch = DistributedTestTools::PutBatch(*g_observerDelegate, entriesBatch);
1496 EXPECT_TRUE(statusPutBatch == DBStatus::OK);
1497 DBStatus statusCommit = g_observerDelegate->Commit();
1498 EXPECT_TRUE(statusCommit == DBStatus::OK);
1499
1500 /**
1501 * @tc.steps: step3. check collback and calculate the duration of step2.
1502 * @tc.expected: step3. observer return batch inserting data info.
1503 */
1504 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, INSERT_LIST, entriesBatch));
1505 observer.Clear();
1506 auto duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1507 MST_LOG(" Getting notice from subscribing a transaction to insert 10 records costs: %lldus.",
1508 (long long)duration.count());
1509
1510 /**
1511 * @tc.steps: step4. start transaction and deleteBatch 10 items (keys,values) to db then commit.
1512 * @tc.expected: step4. operate successfully.
1513 */
1514 KvObserverTransactionPerformance(observer, entriesBatch);
1515 tick = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
1516 statusStart = g_observerDelegate->StartTransaction();
1517 EXPECT_TRUE(statusStart == DBStatus::OK);
1518 status = DistributedTestTools::DeleteBatch(*g_observerDelegate, allKeys);
1519 EXPECT_TRUE(status == DBStatus::OK);
1520 statusCommit = g_observerDelegate->Commit();
1521 EXPECT_TRUE(statusCommit == DBStatus::OK);
1522
1523 /**
1524 * @tc.steps: step5. check collback and calculate the duration of step4.
1525 * @tc.expected: step5. observer return batch deleting data info.
1526 */
1527 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ONE_TIME, DELETE_LIST, entriesBatch));
1528 observer.Clear();
1529 duration = std::chrono::duration_cast<microseconds>(observer.GetOnChangeTime() - tick);
1530 MST_LOG(" Getting notice from subscribing to delete a record costs: %lldus.", (long long)duration.count());
1531
1532 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1533 EXPECT_TRUE(statusRelease == DBStatus::OK);
1534 }
1535
1536 /*
1537 * @tc.name: ObserverPerformance 004
1538 * @tc.desc: test system info of subscribing for inserting, deleting, updating one record.
1539 * @tc.type: Performance
1540 * @tc.require: SR000BUH3K
1541 * @tc.author: luqianfu
1542 */
1543 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance004, TestSize.Level3)
1544 {
1545 DistributedTestTools::Clear(*g_observerDelegate);
1546
1547 KvStoreObserverImpl observer;
1548
1549 /**
1550 * @tc.steps: step1. register an observer bases on kv db.
1551 * @tc.expected: step1. register successfully.
1552 */
1553 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1554 EXPECT_TRUE(status == DBStatus::OK);
1555
1556 vector<DistributedDB::Entry> insertEntries;
1557 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
1558 observer.Clear();
1559
1560 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1561 EXPECT_TRUE(statusRelease == DBStatus::OK);
1562 }
1563
1564 /*
1565 * @tc.name: ObserverPerformance 005
1566 * @tc.desc: test system info of subscribing for batch inserting, deleting, updating.
1567 * @tc.type: Performance
1568 * @tc.require: SR000BUH3K
1569 * @tc.author: luqianfu
1570 */
1571 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance005, TestSize.Level3)
1572 {
1573 DistributedTestTools::Clear(*g_observerDelegate);
1574
1575 /**
1576 * @tc.steps: step1. register an observer bases on kv db.
1577 * @tc.expected: step1. register successfully.
1578 */
1579 KvStoreObserverImpl observer;
1580 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1581 EXPECT_TRUE(status == DBStatus::OK);
1582
1583 vector<DistributedDB::Entry> insertEntries;
1584 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
1585 observer.Clear();
1586
1587 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1588 EXPECT_TRUE(statusRelease == DBStatus::OK);
1589 }
1590
1591 /*
1592 * @tc.name: ObserverPerformance 006
1593 * @tc.desc: test system info of subscribing for transaction operation.
1594 * @tc.type: Performance
1595 * @tc.require: SR000BUH3K
1596 * @tc.author: luqianfu
1597 */
1598 HWTEST_F(DistributeddbKvObserverTest, ObserverPerformance006, TestSize.Level3)
1599 {
1600 DistributedTestTools::Clear(*g_observerDelegate);
1601
1602 /**
1603 * @tc.steps: step1. register an observer bases on kv db.
1604 * @tc.expected: step1. register successfully.
1605 */
1606 KvStoreObserverImpl observer;
1607 DBStatus status = DistributedTestTools::RegisterObserver(g_observerDelegate, &observer);
1608 EXPECT_TRUE(status == DBStatus::OK);
1609
1610 vector<DistributedDB::Entry> insertEntries;
1611 EXPECT_TRUE(VerifyObserverResult(observer, CHANGED_ZERO_TIME, INSERT_LIST, insertEntries));
1612 observer.Clear();
1613
1614 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(g_observerDelegate, &observer);
1615 EXPECT_TRUE(statusRelease == DBStatus::OK);
1616 }
1617
1618 #ifndef LOW_LEVEL_MEM_DEV
1619 /*
1620 * @tc.name: ObserverRekeyDb 001
1621 * @tc.desc: verify that Rekey will return busy when there are registered observer or putting data to db.
1622 * @tc.type: FUNC
1623 * @tc.require: SR000CQDT4
1624 * @tc.author: fengxiaoyun
1625 */
1626 HWTEST_F(DistributeddbKvObserverTest, ObserverRekeyDb001, TestSize.Level3)
1627 {
1628 KvStoreDelegate *kvObserverDelegate = nullptr;
1629 KvStoreDelegateManager *manager = nullptr;
1630 KvOption option;
1631
1632 kvObserverDelegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter2, option);
1633 ASSERT_TRUE(manager != nullptr && kvObserverDelegate != nullptr);
1634
1635 /**
1636 * @tc.steps: step1. register observer.
1637 * @tc.expected: step1. register successfully.
1638 */
1639 KvStoreObserverImpl observer;
1640 DBStatus status = DistributedTestTools::RegisterObserver(kvObserverDelegate, &observer);
1641 EXPECT_TRUE(status == DBStatus::OK);
1642
1643 /**
1644 * @tc.steps: step2. call Rekey to update passwd to passwd_1.
1645 * @tc.expected: step2. Rekey returns BUSY.
1646 */
1647 EXPECT_TRUE(kvObserverDelegate->Rekey(g_passwd1) == BUSY);
1648
1649 /**
1650 * @tc.steps: step3. unregister observer.
1651 * @tc.expected: step3. unregister successfully.
1652 */
1653 DBStatus statusRelease = DistributedTestTools::UnRegisterObserver(kvObserverDelegate, &observer);
1654 EXPECT_TRUE(statusRelease == DBStatus::OK);
1655
1656 /**
1657 * @tc.steps: step4. put (1k,4M) of (k,v) to db.
1658 * @tc.expected: step4. put successfully.
1659 */
1660 vector<Entry> entriesBatch;
1661 vector<Key> allKeys;
1662 GenerateFixedRecords(entriesBatch, allKeys, BATCH_RECORDS, ONE_K_LONG_STRING, FOUR_M_LONG_STRING);
__anondab7ef1b0102() 1663 thread subThread([&kvObserverDelegate, &entriesBatch]() {
1664 DBStatus rekeyStatus = DistributedTestTools::PutBatch(*kvObserverDelegate, entriesBatch);
1665 EXPECT_TRUE(rekeyStatus == OK || rekeyStatus == BUSY);
1666 });
1667 subThread.detach();
1668
1669 /**
1670 * @tc.steps: step5. call Rekey to update passwd to passwd_2.
1671 * @tc.expected: step5. Rekey returns BUSY.
1672 */
1673 status = kvObserverDelegate->Rekey(g_passwd2);
1674 EXPECT_TRUE(status == OK || status == BUSY);
1675 std::this_thread::sleep_for(std::chrono::seconds(NB_OPERATION_CNT_END));
1676 EXPECT_TRUE(manager->CloseKvStore(kvObserverDelegate) == OK);
1677 kvObserverDelegate = nullptr;
1678 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_2) == OK);
1679 delete manager;
1680 manager = nullptr;
1681 }
1682 #endif
1683 }
1684 #endif // OMIT_MULTI_VER