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