1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include "distributeddb_data_generate_unit_test.h"
19 #include "distributeddb_tools_unit_test.h"
20 #include "log_print.h"
21 
22 using namespace testing::ext;
23 using namespace DistributedDB;
24 using namespace DistributedDBUnitTest;
25 using namespace std;
26 
27 namespace {
28     const Key NULL_KEY;
29     const int OBSERVER_SLEEP_TIME = 100;
30 
31     // define some variables to init a KvStoreDelegateManager object.
32     KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
33     string g_testDir;
34     KvStoreConfig g_config;
35 
36     // define the g_kvNbDelegateCallback, used to get some information when open a kv store.
37     DBStatus g_kvDelegateStatus = INVALID_ARGS;
38     KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
39 
KvStoreNbDelegateCallback(DBStatus statusSrc,KvStoreNbDelegate * kvStoreSrc,DBStatus * statusDst,KvStoreNbDelegate ** kvStoreDst)40     void KvStoreNbDelegateCallback(DBStatus statusSrc, KvStoreNbDelegate *kvStoreSrc,
41         DBStatus *statusDst, KvStoreNbDelegate **kvStoreDst)
42     {
43         *statusDst = statusSrc;
44         *kvStoreDst = kvStoreSrc;
45     }
46 
47     // the type of g_kvNbDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
48     auto g_kvNbDelegateCallback = bind(&KvStoreNbDelegateCallback, placeholders::_1,
49         placeholders::_2, &g_kvDelegateStatus, &g_kvNbDelegatePtr);
50 
51     // define parameters for conflict callback
52     bool g_isNeedInsertEntryInCallback = false;
53     int g_conflictCallbackTimes = 0;
54     Entry g_localEntry;
55     Entry g_syncEntry;
56     bool g_isLocalLastest = false;
57     bool g_isSyncNull = false;
ResetCallbackArg(bool isLocalLastest=false)58     void ResetCallbackArg(bool isLocalLastest = false)
59     {
60         g_conflictCallbackTimes = 0;
61         g_localEntry.key.clear();
62         g_localEntry.value.clear();
63         g_syncEntry.key.clear();
64         g_syncEntry.value.clear();
65         g_isLocalLastest = isLocalLastest;
66         g_isSyncNull = true;
67         g_isNeedInsertEntryInCallback = false;
68     }
69 
ConflictCallback(const Entry & local,const Entry * sync,bool isLocalLastest)70     void ConflictCallback(const Entry &local, const Entry *sync, bool isLocalLastest)
71     {
72         g_conflictCallbackTimes++;
73         g_localEntry = local;
74         if (sync != nullptr) {
75             g_syncEntry = *sync;
76             g_isSyncNull = false;
77         } else {
78             g_isSyncNull = true;
79         }
80         g_isLocalLastest = isLocalLastest;
81         if (g_isNeedInsertEntryInCallback) {
82             ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
83             EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
84         }
85     }
86 }
87 
88 class DistributedDBInterfacesNBPublishTest : public testing::Test {
89 public:
90     static void SetUpTestCase(void);
91     static void TearDownTestCase(void);
92     void SetUp();
93     void TearDown();
94 };
95 
SetUpTestCase(void)96 void DistributedDBInterfacesNBPublishTest::SetUpTestCase(void)
97 {
98     DistributedDBToolsUnitTest::TestDirInit(g_testDir);
99     g_config.dataDir = g_testDir;
100     g_mgr.SetKvStoreConfig(g_config);
101 }
102 
TearDownTestCase(void)103 void DistributedDBInterfacesNBPublishTest::TearDownTestCase(void)
104 {
105     if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
106         LOGE("rm test db files error!");
107     }
108 }
109 
SetUp(void)110 void DistributedDBInterfacesNBPublishTest::SetUp(void)
111 {
112     DistributedDBToolsUnitTest::PrintTestCaseInfo();
113     g_kvDelegateStatus = INVALID_ARGS;
114     g_kvNbDelegatePtr = nullptr;
115 }
116 
TearDown(void)117 void DistributedDBInterfacesNBPublishTest::TearDown(void) {}
118 
119 /**
120   * @tc.name: SingleVerPublishKey001
121   * @tc.desc: Publish nonexistent key
122   * @tc.type: FUNC
123   * @tc.require: AR000DPTQ5
124   * @tc.author: wumin
125   */
126 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey001, TestSize.Level1)
127 {
128     const KvStoreNbDelegate::Option option = {true, false};
129     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey001", option, g_kvNbDelegateCallback);
130     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
131     EXPECT_TRUE(g_kvDelegateStatus == OK);
132     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
133     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
134     /**
135      * @tc.steps:step1. PublishLocal key2.
136      * @tc.expected: step1. return NOT_FOUND.
137      */
138     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_2, true, true, nullptr), NOT_FOUND);
139     /**
140      * @tc.steps:step2. Get value of key1 and key2 both from local and sync table
141      * @tc.expected: step2. value of key1 and key2 are correct
142      */
143     Value readValue;
144     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
145     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
146     EXPECT_EQ(readValue, VALUE_1);
147 
148     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
149     EXPECT_EQ(readValue, VALUE_2);
150     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), NOT_FOUND);
151     /**
152      * @tc.steps:step3. PublishLocal key2.
153      * @tc.expected: step3. return OK.
154      */
155     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_2, true, false, nullptr), NOT_FOUND);
156     /**
157      * @tc.steps:step4. Get value of key1 and key2 both from local and sync table
158      * @tc.expected: step4. value of key1 and key2 are correct
159      */
160     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
161     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
162     EXPECT_EQ(readValue, VALUE_1);
163 
164     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
165     EXPECT_EQ(readValue, VALUE_2);
166     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), NOT_FOUND);
167     /**
168      * @tc.steps:step5. PublishLocal key2.
169      * @tc.expected: step5. return OK.
170      */
171     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_2, false, true, nullptr), NOT_FOUND);
172     /**
173      * @tc.steps:step6. Get value of key1 and key2 both from local and sync table
174      * @tc.expected: step6. value of key1 and key2 are correct
175      */
176     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
177     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
178     EXPECT_EQ(readValue, VALUE_1);
179 
180     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
181     EXPECT_EQ(readValue, VALUE_2);
182     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), NOT_FOUND);
183     /**
184      * @tc.steps:step7. PublishLocal key2.
185      * @tc.expected: step7. return OK.
186      */
187     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_2, false, false, nullptr), NOT_FOUND);
188     /**
189      * @tc.steps:step8. Get value of key1 and key2 both from local and sync table
190      * @tc.expected: step8. value of key1 and key2 are correct
191      */
192     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
193     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
194     EXPECT_EQ(readValue, VALUE_1);
195 
196     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
197     EXPECT_EQ(readValue, VALUE_2);
198     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), NOT_FOUND);
199 
200     // finilize
201     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
202     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey001"), OK);
203     g_kvNbDelegatePtr = nullptr;
204 }
205 
206 /**
207   * @tc.name: SingleVerPublishKey002
208   * @tc.desc: Publish no conflict key without deleting key from local table
209   * @tc.type: FUNC
210   * @tc.require: AR000DPTQ5
211   * @tc.author: wumin
212   */
213 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey002, TestSize.Level1)
214 {
215     const KvStoreNbDelegate::Option option = {true, false};
216     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey002", option, g_kvNbDelegateCallback);
217     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
218     EXPECT_TRUE(g_kvDelegateStatus == OK);
219 
220     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
221     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_2, VALUE_2), OK);
222     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_3), OK);
223 
224     KvStoreObserverUnitTest *observerLocal = new (std::nothrow) KvStoreObserverUnitTest;
225     ASSERT_TRUE(observerLocal != nullptr);
226     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_LOCAL_ONLY, observerLocal), OK);
227 
228     KvStoreObserverUnitTest *observerSync = new (std::nothrow) KvStoreObserverUnitTest;
229     ASSERT_TRUE(observerSync != nullptr);
230     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observerSync), OK);
231     /**
232      * @tc.steps:step1. PublishLocal key1.
233      * @tc.expected: step1. return OK.
234      */
235     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, false, true, nullptr), OK);
236     /**
237      * @tc.steps:step2. Get value of key1 from local table
238      * @tc.expected: step2. value of key1 is value1
239      */
240     Value readValue;
241     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
242     EXPECT_EQ(readValue, VALUE_1);
243     /**
244      * @tc.steps:step3. Get value of key2 from local table
245      * @tc.expected: step3. value of key2 is value2
246      */
247     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), OK);
248     EXPECT_EQ(readValue, VALUE_2);
249     /**
250      * @tc.steps:step4. Get value of key1 from sync table
251      * @tc.expected: step4. value of key1 is value1
252      */
253     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
254     EXPECT_EQ(readValue, VALUE_1);
255     /**
256      * @tc.steps:step5. Get value of key2 from sync table
257      * @tc.expected: step5. value of key2 is value3
258      */
259     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
260     EXPECT_EQ(readValue, VALUE_3);
261     /**
262      * @tc.steps:step6. Check observer data.
263      * @tc.expected: step6. return OK.
264      */
265     std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
266     vector<Entry> entriesRet = {{KEY_1, VALUE_1}};
267     EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observerSync->GetEntriesInserted()));
268     EXPECT_EQ(observerLocal->GetCallCount(), 0UL);
269 
270     // finilize
271     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerLocal), OK);
272     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerSync), OK);
273     delete observerLocal;
274     observerLocal = nullptr;
275     delete observerSync;
276     observerSync = nullptr;
277 
278     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
279     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey002"), OK);
280     g_kvNbDelegatePtr = nullptr;
281 }
282 
283 /**
284   * @tc.name: SingleVerPublishKey003
285   * @tc.desc: Publish no conflict key with deleting key from local table
286   * @tc.type: FUNC
287   * @tc.require: AR000DPTQ5
288   * @tc.author: wumin
289   */
290 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey003, TestSize.Level1)
291 {
292     const KvStoreNbDelegate::Option option = {true, false};
293     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey003", option, g_kvNbDelegateCallback);
294     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
295     EXPECT_TRUE(g_kvDelegateStatus == OK);
296 
297     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
298     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_2, VALUE_2), OK);
299     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_3), OK);
300 
301     KvStoreObserverUnitTest *observerLocal = new (std::nothrow) KvStoreObserverUnitTest;
302     ASSERT_TRUE(observerLocal != nullptr);
303     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_LOCAL_ONLY, observerLocal), OK);
304 
305     KvStoreObserverUnitTest *observerSync = new (std::nothrow) KvStoreObserverUnitTest;
306     ASSERT_TRUE(observerSync != nullptr);
307     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observerSync), OK);
308     /**
309      * @tc.steps:step1. PublishLocal key1.
310      * @tc.expected: step1. return OK.
311      */
312     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, true, nullptr), OK);
313     /**
314      * @tc.steps:step2. Get value of key1 from local table
315      * @tc.expected: step2. value of key1 is value1
316      */
317     Value readValue;
318     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), NOT_FOUND);
319     /**
320      * @tc.steps:step3. Get value of key2 from local table
321      * @tc.expected: step3. value of key2 is value2
322      */
323     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), OK);
324     EXPECT_EQ(readValue, VALUE_2);
325     /**
326      * @tc.steps:step4. Get value of key1 from sync table
327      * @tc.expected: step4. value of key1 is value1
328      */
329     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
330     EXPECT_EQ(readValue, VALUE_1);
331     /**
332      * @tc.steps:step5. Get value of key2 from sync table
333      * @tc.expected: step5. value of key2 is value3
334      */
335     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
336     EXPECT_EQ(readValue, VALUE_3);
337     /**
338      * @tc.steps:step6. Check observer data.
339      * @tc.expected: step6. return OK.
340      */
341     std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
342     vector<Entry> entriesRet = {{KEY_1, VALUE_1}};
343     EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observerSync->GetEntriesInserted()));
344     EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observerLocal->GetEntriesDeleted()));
345 
346     // finilize
347     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerLocal), OK);
348     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerSync), OK);
349     delete observerLocal;
350     observerLocal = nullptr;
351     delete observerSync;
352     observerSync = nullptr;
353 
354     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
355     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey003"), OK);
356     g_kvNbDelegatePtr = nullptr;
357 }
358 
359 /**
360   * @tc.name: SingleVerPublishKey004
361   * @tc.desc: Publish conflict key and update timestamp
362   * @tc.type: FUNC
363   * @tc.require: AR000DPTQ5
364   * @tc.author: wumin
365   */
366 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey004, TestSize.Level1)
367 {
368     const KvStoreNbDelegate::Option option = {true, false};
369     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey004", option, g_kvNbDelegateCallback);
370     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
371     EXPECT_TRUE(g_kvDelegateStatus == OK);
372 
373     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
374     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_2, VALUE_2), OK);
375     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_3), OK);
376     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_4), OK);
377 
378     KvStoreObserverUnitTest *observerLocal = new (std::nothrow) KvStoreObserverUnitTest;
379     ASSERT_TRUE(observerLocal != nullptr);
380     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_LOCAL_ONLY, observerLocal), OK);
381 
382     KvStoreObserverUnitTest *observerSync = new (std::nothrow) KvStoreObserverUnitTest;
383     ASSERT_TRUE(observerSync != nullptr);
384     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observerSync), OK);
385     /**
386      * @tc.steps:step1. PublishLocal key1.
387      * @tc.expected: step1. return OK.
388      */
389     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, false, true, nullptr), OK);
390     /**
391      * @tc.steps:step2. Get value of key1 from local table
392      * @tc.expected: step2. value of key1 is value1
393      */
394     Value readValue;
395     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
396     EXPECT_EQ(readValue, VALUE_1);
397     /**
398      * @tc.steps:step3. Get value of key2 from local table
399      * @tc.expected: step3. value of key2 is value2
400      */
401     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), OK);
402     EXPECT_EQ(readValue, VALUE_2);
403     /**
404      * @tc.steps:step4. Get value of key1 from sync table
405      * @tc.expected: step4. value of key1 is value1
406      */
407     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
408     EXPECT_EQ(readValue, VALUE_1);
409     /**
410      * @tc.steps:step5. Get value of key2 from sync table
411      * @tc.expected: step5. value of key2 is value3
412      */
413     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
414     EXPECT_EQ(readValue, VALUE_3);
415     /**
416      * @tc.steps:step6. Check observer data.
417      * @tc.expected: step6. return OK.
418      */
419     std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
420     vector<Entry> entriesRet = {{KEY_1, VALUE_1}};
421     EXPECT_TRUE(DistributedDBToolsUnitTest::CheckObserverResult(entriesRet, observerSync->GetEntriesUpdated()));
422     EXPECT_EQ(observerLocal->GetCallCount(), 0UL);
423 
424     // finilize
425     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerLocal), OK);
426     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerSync), OK);
427     delete observerLocal;
428     observerLocal = nullptr;
429     delete observerSync;
430     observerSync = nullptr;
431 
432     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
433     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey004"), OK);
434     g_kvNbDelegatePtr = nullptr;
435 }
436 
437 /**
438   * @tc.name: SingleVerPublishKey005
439   * @tc.desc: Publish conflict key but do not update timestamp
440   * @tc.type: FUNC
441   * @tc.require: AR000DPTQ5
442   * @tc.author: wumin
443   */
444 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey005, TestSize.Level1)
445 {
446     const KvStoreNbDelegate::Option option = {true, false};
447     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey005", option, g_kvNbDelegateCallback);
448     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
449     EXPECT_TRUE(g_kvDelegateStatus == OK);
450 
451     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
452     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_2, VALUE_2), OK);
453     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_3), OK);
454     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_4), OK);
455 
456     KvStoreObserverUnitTest *observerLocal = new (std::nothrow) KvStoreObserverUnitTest;
457     ASSERT_TRUE(observerLocal != nullptr);
458     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_LOCAL_ONLY, observerLocal), OK);
459 
460     KvStoreObserverUnitTest *observerSync = new (std::nothrow) KvStoreObserverUnitTest;
461     ASSERT_TRUE(observerSync != nullptr);
462     EXPECT_EQ(g_kvNbDelegatePtr->RegisterObserver(NULL_KEY, OBSERVER_CHANGES_NATIVE, observerSync), OK);
463     /**
464      * @tc.steps:step1. PublishLocal key1.
465      * @tc.expected: step1. return OK.
466      */
467     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, false, nullptr), STALE);
468     /**
469      * @tc.steps:step2. Get value of key1 from local table
470      * @tc.expected: step2. value of key1 is value1
471      */
472     Value readValue;
473     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
474     EXPECT_EQ(readValue, VALUE_1);
475     /**
476      * @tc.steps:step3. Get value of key2 from local table
477      * @tc.expected: step3. value of key2 is value2
478      */
479     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_2, readValue), OK);
480     EXPECT_EQ(readValue, VALUE_2);
481     /**
482      * @tc.steps:step4. Get value of key1 from sync table
483      * @tc.expected: step4. value of key1 is value4
484      */
485     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
486     EXPECT_EQ(readValue, VALUE_4);
487     /**
488      * @tc.steps:step5. Get value of key2 from sync table
489      * @tc.expected: step5. value of key2 is value3
490      */
491     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
492     EXPECT_EQ(readValue, VALUE_3);
493     /**
494      * @tc.steps:step6. Check observer data.
495      * @tc.expected: step6. return OK.
496      */
497     std::this_thread::sleep_for(std::chrono::milliseconds(OBSERVER_SLEEP_TIME));
498     EXPECT_EQ(observerSync->GetCallCount(), 0UL);
499     EXPECT_EQ(observerLocal->GetCallCount(), 0UL);
500 
501     // finilize
502     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerLocal), OK);
503     EXPECT_EQ(g_kvNbDelegatePtr->UnRegisterObserver(observerSync), OK);
504     delete observerLocal;
505     observerLocal = nullptr;
506     delete observerSync;
507     observerSync = nullptr;
508 
509     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
510     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey005"), OK);
511     g_kvNbDelegatePtr = nullptr;
512 }
513 
514 /**
515   * @tc.name: SingleVerPublishKey006
516   * @tc.desc: Publish no conflict key and onConflict() not null
517   * @tc.type: FUNC
518   * @tc.require: AR000DPTQ5
519   * @tc.author: wumin
520   */
521 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey006, TestSize.Level1)
522 {
523     const KvStoreNbDelegate::Option option = {true, false};
524     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey006", option, g_kvNbDelegateCallback);
525     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
526     EXPECT_TRUE(g_kvDelegateStatus == OK);
527 
528     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
529     /**
530      * @tc.steps:step1. PublishLocal key1.
531      * @tc.expected: step1. return OK.
532      */
533     ResetCallbackArg();
534     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, false, ConflictCallback), OK);
535     Value readValue;
536     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), NOT_FOUND);
537     /**
538      * @tc.steps:step2. Check onConflict callback.
539      * @tc.expected: step2. return OK.
540      */
541     EXPECT_EQ(g_conflictCallbackTimes, 0);
542     /**
543      * @tc.steps:step3. Get value of key1 from sync table
544      * @tc.expected: step3. value of key1 is value4
545      */
546     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
547     EXPECT_EQ(readValue, VALUE_1);
548 
549     // finilize
550     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
551     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey006"), OK);
552     g_kvNbDelegatePtr = nullptr;
553 }
554 
555 /**
556   * @tc.name: SingleVerPublishKey007
557   * @tc.desc: Publish conflict key and onConflict() not null
558   * @tc.type: FUNC
559   * @tc.require: AR000DPTQ5
560   * @tc.author: wumin
561   */
562 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey007, TestSize.Level1)
563 {
564     const KvStoreNbDelegate::Option option = {true, false};
565     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey007", option, g_kvNbDelegateCallback);
566     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
567     EXPECT_TRUE(g_kvDelegateStatus == OK);
568 
569     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
570     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
571     /**
572      * @tc.steps:step1. PublishLocal key1.
573      * @tc.expected: step1. return OK.
574      */
575     ResetCallbackArg(true);
576     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, false, ConflictCallback), OK);
577     Value readValue;
578     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
579     EXPECT_EQ(readValue, VALUE_1);
580     /**
581      * @tc.steps:step2. Check onConflict callback.
582      * @tc.expected: step2. return OK.
583      */
584     EXPECT_EQ(g_conflictCallbackTimes, 1);
585     EXPECT_EQ(g_isLocalLastest, false);
586     Entry entryRet = {KEY_1, VALUE_1};
587     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_localEntry, entryRet));
588     entryRet = {KEY_1, VALUE_2};
589     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_syncEntry, entryRet));
590     /**
591      * @tc.steps:step3. Get value of key1 from sync table
592      * @tc.expected: step3. value of key1 is value4
593      */
594     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
595     EXPECT_EQ(readValue, VALUE_2);
596 
597     // finilize
598     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
599     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey007"), OK);
600     g_kvNbDelegatePtr = nullptr;
601 }
602 
603 /**
604   * @tc.name: SingleVerPublishKey008
605   * @tc.desc: Publish conflict key and onConflict() not null, need update timestamp
606   * @tc.type: FUNC
607   * @tc.require: AR000DPTQ5
608   * @tc.author: wumin
609   */
610 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey008, TestSize.Level1)
611 {
612     const KvStoreNbDelegate::Option option = {true, false};
613     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey008", option, g_kvNbDelegateCallback);
614     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
615     EXPECT_TRUE(g_kvDelegateStatus == OK);
616 
617     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
618     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
619     /**
620      * @tc.steps:step1. PublishLocal key1.
621      * @tc.expected: step1. return OK.
622      */
623     ResetCallbackArg(false);
624     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, true, ConflictCallback), OK);
625     Value readValue;
626     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
627     EXPECT_EQ(readValue, VALUE_1);
628     /**
629      * @tc.steps:step2. Check onConflict callback.
630      * @tc.expected: step2. return OK.
631      */
632     EXPECT_EQ(g_conflictCallbackTimes, 1);
633     EXPECT_EQ(g_isLocalLastest, true);
634     Entry entryRet = {KEY_1, VALUE_1};
635     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_localEntry, entryRet));
636     entryRet = {KEY_1, VALUE_2};
637     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_syncEntry, entryRet));
638     /**
639      * @tc.steps:step3. Get value of key1 from sync table
640      * @tc.expected: step3. value of key1 is value4
641      */
642     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
643     EXPECT_EQ(readValue, VALUE_2);
644 
645     // finilize
646     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
647     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey008"), OK);
648     g_kvNbDelegatePtr = nullptr;
649 }
650 
651 /**
652   * @tc.name: SingleVerPublishKey009
653   * @tc.desc: Publish conflict key (deleted) and onConflict() not null
654   * @tc.type: FUNC
655   * @tc.require: AR000DPTQ5
656   * @tc.author: wumin
657   */
658 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey009, TestSize.Level1)
659 {
660     const KvStoreNbDelegate::Option option = {true, false};
661     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey009", option, g_kvNbDelegateCallback);
662     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
663     EXPECT_TRUE(g_kvDelegateStatus == OK);
664 
665     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
666     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
667     EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
668     /**
669      * @tc.steps:step1. PublishLocal key1.
670      * @tc.expected: step1. return OK.
671      */
672     ResetCallbackArg(true);
673     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, false, ConflictCallback), OK);
674     Value readValue;
675     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
676     EXPECT_EQ(readValue, VALUE_1);
677     /**
678      * @tc.steps:step2. Check onConflict callback.
679      * @tc.expected: step2. return OK.
680      */
681     EXPECT_EQ(g_conflictCallbackTimes, 1);
682     EXPECT_EQ(g_isLocalLastest, false);
683     EXPECT_EQ(g_isSyncNull, true);
684     Entry entryRet = {KEY_1, VALUE_1};
685     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_localEntry, entryRet));
686     /**
687      * @tc.steps:step3. Get value of key1 from sync table
688      * @tc.expected: step3. value of key1 is value4
689      */
690     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
691 
692     // finilize
693     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
694     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey009"), OK);
695     g_kvNbDelegatePtr = nullptr;
696 }
697 
698 /**
699   * @tc.name: SingleVerPublishKey010
700   * @tc.desc: Publish conflict key (deleted) and onConflict() not null, need update timestamp
701   * @tc.type: FUNC
702   * @tc.require: AR000DPTQ5
703   * @tc.author: wumin
704   */
705 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey010, TestSize.Level1)
706 {
707     const KvStoreNbDelegate::Option option = {true, false};
708     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey010", option, g_kvNbDelegateCallback);
709     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
710     EXPECT_TRUE(g_kvDelegateStatus == OK);
711 
712     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
713     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
714     EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
715     /**
716      * @tc.steps:step1. PublishLocal key1.
717      * @tc.expected: step1. return OK.
718      */
719     ResetCallbackArg(false);
720     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, true, ConflictCallback), OK);
721     Value readValue;
722     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
723     EXPECT_EQ(readValue, VALUE_1);
724     /**
725      * @tc.steps:step2. Check onConflict callback.
726      * @tc.expected: step2. return OK.
727      */
728     EXPECT_EQ(g_conflictCallbackTimes, 1);
729     EXPECT_EQ(g_isLocalLastest, true);
730     EXPECT_EQ(g_isSyncNull, true);
731     Entry entryRet = {KEY_1, VALUE_1};
732     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_localEntry, entryRet));
733     /**
734      * @tc.steps:step3. Get value of key1 from sync table
735      * @tc.expected: step3. value of key1 is value4
736      */
737     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
738 
739     // finilize
740     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
741     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey010"), OK);
742     g_kvNbDelegatePtr = nullptr;
743 }
744 
745 /**
746   * @tc.name: SingleVerPublishKey011
747   * @tc.desc: Publish conflict key (deleted) and onConflict() not null, put(k1,v1) in callback method
748   * @tc.type: FUNC
749   * @tc.require: AR000DPTQ5
750   * @tc.author: wumin
751   */
752 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey011, TestSize.Level1)
753 {
754     const KvStoreNbDelegate::Option option = {true, false};
755     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey011", option, g_kvNbDelegateCallback);
756     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
757     EXPECT_TRUE(g_kvDelegateStatus == OK);
758 
759     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
760     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
761     EXPECT_EQ(g_kvNbDelegatePtr->Delete(KEY_1), OK);
762     /**
763      * @tc.steps:step1. PublishLocal key1.
764      * @tc.expected: step1. return OK.
765      */
766     ResetCallbackArg(true);
767     g_isNeedInsertEntryInCallback = true;
768     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(KEY_1, true, false, ConflictCallback), OK);
769     Value readValue;
770     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
771     EXPECT_EQ(readValue, VALUE_1);
772     /**
773      * @tc.steps:step2. Check onConflict callback.
774      * @tc.expected: step2. return OK.
775      */
776     EXPECT_EQ(g_conflictCallbackTimes, 1);
777     EXPECT_EQ(g_isLocalLastest, false);
778     EXPECT_EQ(g_isSyncNull, true);
779     Entry entryRet = {KEY_1, VALUE_1};
780     EXPECT_TRUE(DistributedDBToolsUnitTest::IsEntryEqual(g_localEntry, entryRet));
781     /**
782      * @tc.steps:step3. Get value of key1 from sync table
783      * @tc.expected: step3. value of key1 is value4
784      */
785     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
786     EXPECT_EQ(readValue, VALUE_1);
787 
788     // finilize
789     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
790     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey011"), OK);
791     g_kvNbDelegatePtr = nullptr;
792 }
793 
794 /**
795   * @tc.name: SingleVerPublishKey012
796   * @tc.desc: Publish empty and illegal key
797   * @tc.type: FUNC
798   * @tc.require:
799   * @tc.author: caihaoting
800   */
801 HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey012, TestSize.Level1)
802 {
803     const KvStoreNbDelegate::Option option = {true, false};
804     g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey012", option, g_kvNbDelegateCallback);
805     ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
806     EXPECT_TRUE(g_kvDelegateStatus == OK);
807     EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
808     EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
809     /**
810      * @tc.steps:step1. PublishLocal empty and illegal key.
811      * @tc.expected: step1. return INVALID_ARGS.
812      */
813     Key key = {};
814     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(key, true, true, nullptr), INVALID_ARGS);
815     Key illegalKey;
816     DistributedDBToolsUnitTest::GetRandomKeyValue(illegalKey, DBConstant::MAX_KEY_SIZE + 1); // 1K + 1
817     EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(illegalKey, true, true, nullptr), INVALID_ARGS);
818     /**
819      * @tc.steps:step2. Get value of key1 and key2 both from local and sync table
820      * @tc.expected: step2. value of key1 and key2 are correct
821      */
822     Value readValue;
823     EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
824     EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
825     EXPECT_EQ(readValue, VALUE_1);
826 
827     // finilize
828     EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
829     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey012"), OK);
830     g_kvNbDelegatePtr = nullptr;
831 }
832