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 "distributeddb_storage_single_ver_natural_store_testcase.h"
17
18 #include "generic_single_ver_kv_entry.h"
19 #include "runtime_context.h"
20 #include "time_helper.h"
21
22 using namespace DistributedDB;
23 using namespace DistributedDBUnitTest;
24
25 namespace {
26 const int MAX_TEST_KEY_SIZE = 1024;
27 const int MAX_TEST_VAL_SIZE = 4194304;
28
29 // select result index for the item for sync database
30 const int SYNC_RES_KEY_INDEX = 0;
31 const int SYNC_RES_VAL_INDEX = 1;
32 const int SYNC_RES_TIME_INDEX = 2;
33 const int SYNC_RES_FLAG_INDEX = 3;
34 const int SYNC_RES_HASH_KEY_INDEX = 6;
35
36 const std::string SYNC_DATA_DEFAULT_SQL = "select * from SYNC_DATA;";
37 }
38
39 /**
40 * @tc.name: GetSyncData001
41 * @tc.desc: To test the function of querying the data in the time stamp range in the database.
42 * @tc.type: FUNC
43 * @tc.require: AR000CCPOM
44 * @tc.author: wangbingquan
45 */
GetSyncData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)46 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData001(SQLiteSingleVerNaturalStore *&store,
47 SQLiteSingleVerNaturalStoreConnection *&connection)
48 {
49 /**
50 * @tc.steps:step1. Obtain the data within the time stamp range
51 * through the GetSyncData(A, C) interface of the NaturalStore, where A<B<C.
52 * @tc.expected: step1. GetSyncData The number of output parameter
53 * in the output parameter OK, dataItems is 1.
54 */
55 IOption option;
56 option.dataType = IOption::SYNC_DATA;
57 Timestamp timeBegin;
58 store->GetMaxTimestamp(timeBegin);
59 Key key1;
60 Value value1;
61 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
62 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
63
64 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
65 Timestamp timeEnd;
66 store->GetMaxTimestamp(timeEnd);
67 EXPECT_GT(timeEnd, timeBegin);
68
69 std::vector<DataItem> vect;
70 ContinueToken token = nullptr;
71 SyncInputArg inputArg(timeBegin, timeEnd + 1, 1024); // no more than 1024
72 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg, store, vect, token), E_OK);
73
74 EXPECT_EQ(token, nullptr);
75 DataItem item = {key1, value1, 0, 0};
76 EXPECT_EQ(DistributedDBToolsUnitTest::IsItemValueExist(item, vect), true);
77 }
78
79 /**
80 * @tc.name: GetSyncData002
81 * @tc.desc: Test the function that the database does not query the data in the time stamp range.
82 * @tc.type: FUNC
83 * @tc.require: AR000CCPOM
84 * @tc.author: wangbingquan
85 */
GetSyncData002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)86 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData002(SQLiteSingleVerNaturalStore *&store,
87 SQLiteSingleVerNaturalStoreConnection *&connection)
88 {
89 /**
90 * @tc.steps:step1. Obtain the data within the time stamp range
91 * through the GetSyncData(A, B) interface of the NaturalStore,
92 * where A<B<C and interference data processing are added.
93 * @tc.expected: step1. GetSyncData The number of output parameters
94 * in the output parameter E_NOT_FOUND,dataItems is 0.
95 */
96 IOption option;
97 option.dataType = IOption::SYNC_DATA;
98
99 Key key;
100 Value value;
101 DistributedDBToolsUnitTest::GetRandomKeyValue(key);
102 DistributedDBToolsUnitTest::GetRandomKeyValue(value);
103
104 EXPECT_EQ(connection->Put(option, key, value), E_OK);
105 Timestamp timestamp;
106 store->GetMaxTimestamp(timestamp);
107
108 std::vector<DataItem> vect;
109 ContinueToken token = nullptr;
110 SyncInputArg inputArg(timestamp + 1, timestamp + 1000, 1024); // no more than 1024
111 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg, store, vect, token), E_OK);
112
113 EXPECT_EQ(token, nullptr);
114 EXPECT_EQ(vect.size(), 0UL);
115 }
116
117 /**
118 * @tc.name: GetSyncData003
119 * @tc.desc: To test the function of querying data when the timestamp range
120 * in the data obtaining interface is invalid.
121 * @tc.type: FUNC
122 * @tc.require: AR000CCPOM
123 * @tc.author: wangbingquan
124 */
GetSyncData003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)125 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData003(SQLiteSingleVerNaturalStore *&store,
126 SQLiteSingleVerNaturalStoreConnection *&connection)
127 {
128 /**
129 * @tc.steps:step1. Obtain the data within the time stamp range
130 * through the GetSyncData(A, B) interface of the NaturalStore, where A>B
131 * @tc.expected: step1. The value of GetSyncData is E_INVALID_ARG.
132 */
133 IOption option;
134 option.dataType = IOption::SYNC_DATA;
135 Timestamp timeBegin = 1000; // random
136 Timestamp timeEnd = 700; // random
137 std::vector<DataItem> vect;
138 ContinueToken token = nullptr;
139 SyncInputArg inputArg1(timeBegin, timeEnd, MAX_TEST_VAL_SIZE);
140 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg1, store, vect, token), -E_INVALID_ARGS);
141
142 timeEnd = timeBegin;
143 SyncInputArg inputArg2(timeBegin, timeEnd, MAX_TEST_VAL_SIZE);
144 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg2, store, vect, token), -E_INVALID_ARGS);
145
146 store->GetMaxTimestamp(timeBegin);
147 Key key1;
148 Value value1;
149 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
150 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
151
152 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
153 store->GetMaxTimestamp(timeEnd);
154
155 SyncInputArg inputArg3(timeEnd, timeBegin, MAX_TEST_VAL_SIZE);
156 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg3, store, vect, token), -E_INVALID_ARGS);
157
158 EXPECT_EQ(token, nullptr);
159 }
160
161 /**
162 * @tc.name: GetSyncData004
163 * @tc.desc: To the test database Subcon reading, a large number of data records exist in the time stamp range.
164 * @tc.type: FUNC
165 * @tc.require: AR000CCPOM
166 * @tc.author: wangbingquan
167 */
GetSyncData004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)168 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData004(SQLiteSingleVerNaturalStore *&store,
169 SQLiteSingleVerNaturalStoreConnection *&connection)
170 {
171 Key key;
172 Value value;
173 IOption option;
174 option.dataType = IOption::SYNC_DATA;
175 // The test assumes that there are ten data records
176 for (int i = 0; i < 10; i++) {
177 DistributedDBToolsUnitTest::GetRandomKeyValue(key, 100 + i); // random size
178 DistributedDBToolsUnitTest::GetRandomKeyValue(value, 9900 + i); // random size
179 EXPECT_EQ(connection->Put(option, key, value), E_OK);
180 }
181
182 Timestamp timestamp = 0;
183 store->GetMaxTimestamp(timestamp);
184
185 /**
186 * @tc.steps:step1. Obtain the data within the time stamp range
187 * through the GetSyncData(A, B) interface of the NaturalStore.
188 * @tc.expected: step1. Return E_GET_UNFINISHED.
189 */
190 ContinueToken token = nullptr;
191 std::vector<DataItem> dataItems;
192 SyncInputArg inputArg(0, timestamp + 1, 30 * 1024); // 30k per block
193 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg, store, dataItems, token), -E_UNFINISHED);
194
195 EXPECT_NE(token, nullptr);
196 std::size_t countNum = dataItems.size();
197 int count = 1;
198 do {
199 /**
200 * @tc.steps:step2. Continue to obtain data through the GetSyncDataNext() interface
201 * of the NaturalStore until the E_GET_FINISHED message is returned.
202 * @tc.expected: step2. When the GetSyncDataNext returns E_GET_FINISHED,
203 * the total number of obtained data is the number of inserted data and the data is consistent.
204 */
205 dataItems.clear();
206 int errCode = DistributedDBToolsUnitTest::GetSyncDataNextTest(store, 30 * 1024, dataItems, token); // 30k block
207
208 countNum += dataItems.size();
209 count++;
210 if (errCode == -E_UNFINISHED) {
211 continue;
212 } else if (errCode == -E_FINISHED || errCode == E_OK) {
213 break;
214 } else {
215 count = 0;
216 break;
217 }
218 } while (true);
219 EXPECT_EQ(token, nullptr);
220 EXPECT_EQ(countNum, 10UL); // 10 entries
221 EXPECT_EQ(count, 4); // 4 blocks
222 }
223
224 /**
225 * @tc.name: GetSyncData005
226 * @tc.desc: In the test database, if a large number of data records exist
227 * in the time stamp range, a packet is read successfully.
228 * @tc.type: FUNC
229 * @tc.require: AR000CCPOM
230 * @tc.author: wangbingquan
231 */
GetSyncData005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)232 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData005(SQLiteSingleVerNaturalStore *&store,
233 SQLiteSingleVerNaturalStoreConnection *&connection)
234 {
235 Key key;
236 Value value;
237 IOption option;
238 option.dataType = IOption::SYNC_DATA;
239 for (int i = 0; i < 10; i++) { // 10 entries
240 DistributedDBToolsUnitTest::GetRandomKeyValue(key, 100 + i); // about 100 byte
241 DistributedDBToolsUnitTest::GetRandomKeyValue(value, 9900 + i); // about 9900 byte
242 EXPECT_EQ(connection->Put(option, key, value), E_OK);
243 }
244
245 Timestamp timestamp = 0;
246 store->GetMaxTimestamp(timestamp);
247
248 ContinueToken token = nullptr;
249 std::vector<DataItem> dataItems;
250 /**
251 * @tc.steps:step1. Obtain the data within the time stamp range
252 * through the GetSyncData(A, B) interface of the NaturalStore.
253 * @tc.expected: step1. The total size of all data in OK, dataItems is 99K.
254 */
255 SyncInputArg inputArg(0, timestamp + 1, 100 * 1024); // for 100k
256 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg, store, dataItems, token), E_OK);
257
258 EXPECT_EQ(token, nullptr);
259 EXPECT_EQ(dataItems.size(), 10UL);
260 }
261
262 /**
263 * @tc.name: GetSyncData006
264 * @tc.desc: To test the function of reading data when the time stamp range in the database
265 * is greater than the value of blockSize.
266 * @tc.type: FUNC
267 * @tc.require: AR000CCPOM
268 * @tc.author: wangbingquan
269 */
GetSyncData006(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)270 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetSyncData006(SQLiteSingleVerNaturalStore *&store,
271 SQLiteSingleVerNaturalStoreConnection *&connection)
272 {
273 Key key;
274 Value value;
275 DistributedDBToolsUnitTest::GetRandomKeyValue(key, MAX_TEST_KEY_SIZE);
276 DistributedDBToolsUnitTest::GetRandomKeyValue(value, MAX_TEST_VAL_SIZE);
277
278 IOption option;
279 option.dataType = IOption::SYNC_DATA;
280 EXPECT_EQ(connection->Put(option, key, value), E_OK);
281 Timestamp timestamp = 0;
282 store->GetMaxTimestamp(timestamp);
283
284 ContinueToken token = nullptr;
285 std::vector<DataItem> dataItems;
286
287 /**
288 * @tc.steps:step1. Use the GetSyncData(A, B) interface of the NaturalStore
289 * and set blockSize to 50 kb to obtain the data within the time stamp range.
290 * @tc.expected: step1. The system returns E_GET_FINISHED. The size of the obtained data is 1 kb.
291 */
292 SyncInputArg inputArg(0, timestamp + 1, 1000); // get size for 1k
293 EXPECT_EQ(DistributedDBToolsUnitTest::GetSyncDataTest(inputArg, store, dataItems, token), E_OK);
294
295 EXPECT_EQ(token, nullptr);
296 DataItem item = {key, value, 0, 0};
297 EXPECT_EQ(DistributedDBToolsUnitTest::IsItemValueExist(item, dataItems), true);
298 }
299
300 /**
301 * @tc.name: PutSyncData001
302 * @tc.desc: To test the function of synchronizing the new data of the remote device that synchronizes the database.
303 * @tc.type: FUNC
304 * @tc.require: AR000CCPOM
305 * @tc.author: wangbingquan
306 */
PutSyncData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)307 void DistributedDBStorageSingleVerNaturalStoreTestCase::PutSyncData001(SQLiteSingleVerNaturalStore *&store,
308 SQLiteSingleVerNaturalStoreConnection *&connection)
309 {
310 IOption option;
311 option.dataType = IOption::SYNC_DATA;
312 Timestamp timeBegin;
313 store->GetMaxTimestamp(timeBegin);
314 Key key1;
315 Value value1;
316 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, 13); // random size
317 DistributedDBToolsUnitTest::GetRandomKeyValue(value1, 20); // random size
318
319 /**
320 * @tc.steps:step1/2. Set Ioption to synchronous data and insert a (key1, value1) data record by put interface.
321 */
322 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
323 Timestamp timeEnd;
324 store->GetMaxTimestamp(timeEnd);
325 EXPECT_GT(timeEnd, timeBegin);
326
327 DataItem item1;
328 std::vector<DataItem> vect;
329 item1.key = key1;
330 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.value, 18); // random size
331 item1.timestamp = timeBegin;
332 item1.writeTimestamp = item1.timestamp;
333 item1.flag = 0;
334 vect.push_back(item1);
335
336 /**
337 * @tc.steps:step3. Insert a (key1, value2!=value1, timestamp, false) data record
338 * through the PutSyncData interface. The value of timestamp is less than or equal
339 * to the value of timestamp. For Compare the timestamp to determine whether to synchronization data.
340 * @tc.expected: step3. Return OK.
341 */
342 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
343
344 /**
345 * @tc.steps:step4. The Ioption is set to synchronize data
346 * through the Get interface to obtain the value data of the key1.
347 * @tc.expected: step4. Return OK.The obtained value is value1.
348 */
349 Value valueRead;
350 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
351 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
352
353 item1.timestamp = timeEnd + 1;
354 item1.writeTimestamp = item1.timestamp;
355 vect.clear();
356 vect.push_back(item1);
357
358 /**
359 * @tc.steps:step5. Insert a (key1, value3!=value1, timestamp, false) data record
360 * through the PutSyncData interface of the NaturalStore. The value of timestamp
361 * is greater than that of timestamp inserted in 2.
362 * @tc.expected: step5. Return OK.
363 */
364 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
365
366 /**
367 * @tc.steps:step6. The Ioption is set to synchronize data through the Get interface
368 * to obtain the value data of the key1.
369 * @tc.expected: step6. Return OK.
370 */
371 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
372 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(item1.value, valueRead), true);
373
374 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.key, 35); // random size
375 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.value, 47); // random size
376 vect.clear();
377 vect.push_back(item1);
378
379 /**
380 * @tc.steps:step7. Insert a (key2, value4) data record through the PutSyncData interface.
381 * @tc.expected: step7. Return OK.
382 */
383 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
384
385 /**
386 * @tc.steps:step8. The Ioption is set to synchronize data
387 * through the Get interface to obtain the value data of the key2.
388 * @tc.expected: step8. Returns OK, and the obtained data is value4.
389 */
390 EXPECT_EQ(connection->Get(option, item1.key, valueRead), E_OK);
391 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(item1.value, valueRead), true);
392 }
393
394 /**
395 * @tc.name: PutSyncData002
396 * @tc.desc: To test the function of synchronizing data from the remote device
397 * to the local device after the data is deleted from the remote device.
398 * @tc.type: FUNC
399 * @tc.require: AR000CCPOM
400 * @tc.author: wangbingquan
401 */
PutSyncData002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)402 void DistributedDBStorageSingleVerNaturalStoreTestCase::PutSyncData002(SQLiteSingleVerNaturalStore *&store,
403 SQLiteSingleVerNaturalStoreConnection *&connection)
404 {
405 IOption option;
406 option.dataType = IOption::SYNC_DATA;
407 Timestamp timeBegin;
408 store->GetMaxTimestamp(timeBegin);
409 Key key1;
410 Value value1;
411 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, 37); // random size
412 DistributedDBToolsUnitTest::GetRandomKeyValue(value1, 19); // random size
413
414 /**
415 * @tc.steps:step1/2. Set Ioption to synchronous data and insert a (key1, value1) data record by put interface.
416 */
417 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
418 Timestamp timeEnd;
419 store->GetMaxTimestamp(timeEnd);
420 EXPECT_GT(timeEnd, timeBegin);
421
422 DataItem item1;
423 std::vector<DataItem> vect;
424 item1.key = key1;
425 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.value, 18); // random size
426 item1.timestamp = timeBegin;
427 item1.writeTimestamp = item1.timestamp;
428 item1.flag = 1;
429 DistributedDBToolsUnitTest::CalcHash(key1, item1.key);
430 vect.push_back(item1);
431 /**
432 * @tc.steps:step3. Insert a (key1, value2!=value1, timestamp, false) data record
433 * through the PutSyncData interface. The value of timestamp is less than or equal
434 * to the value of timestamp. For Compare the timestamp to determine whether delete data.
435 * @tc.expected: step3. Return OK.
436 */
437 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
438
439 /**
440 * @tc.steps:step4. The Ioption is set to synchronize data
441 * through the Get interface to obtain the value data of the key1.
442 * @tc.expected: step4. Return OK.The obtained value is value1.
443 */
444 Value valueRead;
445 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
446 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
447
448 item1.timestamp = timeEnd + 1;
449 item1.writeTimestamp = item1.timestamp;
450 vect.clear();
451 vect.push_back(item1);
452
453 /**
454 * @tc.steps:step5. Insert a (key1, value3!=value1, timestamp, false) data record
455 * through the PutSyncData interfac. The value of timestamp
456 * is greater than that of timestamp inserted in step2.
457 * @tc.expected: step5. Return OK.
458 */
459 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
460
461 /**
462 * @tc.steps:step6. The Ioption is set to synchronize data through the Get interface
463 * to obtain the value data of the key1.
464 * @tc.expected: step6. Return E_NOT_FOUND.
465 */
466 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_NOT_FOUND);
467
468 // put remote deleted data which not existed locally.
469 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.key, 35); // random size
470 DistributedDBToolsUnitTest::GetRandomKeyValue(item1.value, 47); // random size
471 vect.clear();
472 vect.push_back(item1);
473 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
474
475 EXPECT_EQ(connection->Get(option, item1.key, valueRead), -E_NOT_FOUND);
476 }
477
478 /**
479 * @tc.name: PutSyncData003
480 * @tc.desc: To test the function of synchronizing the mixed data of the added
481 * and deleted data from the remote device to the local device.
482 * @tc.type: FUNC
483 * @tc.require: AR000CCPOM
484 * @tc.author: wangbingquan
485 */
PutSyncData003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)486 void DistributedDBStorageSingleVerNaturalStoreTestCase::PutSyncData003(SQLiteSingleVerNaturalStore *&store,
487 SQLiteSingleVerNaturalStoreConnection *&connection)
488 {
489 IOption option;
490 option.dataType = IOption::SYNC_DATA;
491 Timestamp timeBegin;
492 store->GetMaxTimestamp(timeBegin);
493 DataItem dataItem1;
494 DataItem dataItem2;
495 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key, 23); // random size
496 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.key, 15); // random size
497 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
498 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.value);
499 dataItem1.timestamp = timeBegin + 1; // ensure bigger timestamp
500 dataItem1.writeTimestamp = dataItem1.timestamp;
501 dataItem2.timestamp = timeBegin + 2; // ensure bigger timestamp
502 dataItem2.writeTimestamp = dataItem2.timestamp;
503 dataItem1.flag = dataItem2.flag = 0;
504
505 /**
506 * @tc.steps:step1. Insert a data record (key1,value1 is not null) and (key2, value2 is not null)
507 * through the PutSyncData interface.
508 * @tc.expected: step1. Return OK.
509 */
510 std::vector<DataItem> vect = {dataItem1, dataItem2};
511 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
512
513 /**
514 * @tc.steps:step2. Set Ioption as the synchronization data to obtain the data of key1 and key2.
515 * @tc.expected: step2. The Get interface returns OK. The value of key1 is value1,
516 * and the value of key2 is value2.
517 */
518 Value valueRead1;
519 Value valueRead2;
520 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead1), E_OK);
521 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead2), E_OK);
522 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead1, dataItem1.value), true);
523 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead2, dataItem2.value), true);
524
525 /**
526 * @tc.steps:step3. Insert a (key3, value3) and delete the data of the (key1, value1).
527 * @tc.expected: step3. The PutSyncData returns OK.
528 */
529 DataItem dataItem3 = dataItem1;
530 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem3.key, 38); // random size
531 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem3.value, 27); // random size
532
533 DataItem dataItem4 = dataItem1;
534 dataItem4.flag = 1;
535 dataItem4.timestamp += 1;
536 dataItem4.writeTimestamp = dataItem4.timestamp;
537 DistributedDBToolsUnitTest::CalcHash(dataItem1.key, dataItem4.key);
538 vect = {dataItem4, dataItem3};
539 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
540
541 /**
542 * @tc.steps:step4. Set Ioption to the synchronization data and obtain the data of key1, key2, and key3.
543 * @tc.expected: step4. Get key1 returns E_NOT_FOUND,Get key2.
544 * The value of OK,value is value2, the value of Get key3 is OK,
545 * and the value of value is value3.
546 */
547 valueRead1.clear();
548 valueRead2.clear();
549 Value valueRead3;
550 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead1), -E_NOT_FOUND);
551 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead2), E_OK);
552 EXPECT_EQ(connection->Get(option, dataItem3.key, valueRead3), E_OK);
553 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead2, dataItem2.value), true);
554 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead3, dataItem3.value), true);
555 }
556
557 /**
558 * @tc.name: PutMetaData001
559 * @tc.desc: Test metadata insertion and modification.
560 * @tc.type: FUNC
561 * @tc.require: AR000CCPOM
562 * @tc.author: wangbingquan
563 */
PutMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)564 void DistributedDBStorageSingleVerNaturalStoreTestCase::PutMetaData001(SQLiteSingleVerNaturalStore *&store,
565 SQLiteSingleVerNaturalStoreConnection *&connection)
566 {
567 TestMetaDataPutAndGet(store, connection);
568 }
569
570 /**
571 * @tc.name: GetMetaData001
572 * @tc.desc: To test the function of reading the metadata of a key in the database.
573 * @tc.type: FUNC
574 * @tc.require: AR000CCPOM
575 * @tc.author: wangbingquan
576 */
GetMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)577 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetMetaData001(SQLiteSingleVerNaturalStore *&store,
578 SQLiteSingleVerNaturalStoreConnection *&connection)
579 {
580 /**
581 * @tc.steps:step1. Use GetMetaData in NaturalStore to obtain the value of key1.
582 * Check whether the value is the same as the value of value1.
583 * @tc.expected: step1. Return OK, and the value is the same as the value of value1.
584 */
585 TestMetaDataPutAndGet(store, connection);
586 }
587
588 /**
589 * @tc.name: DeleteMetaData001
590 * @tc.desc: To test the function of deleting the metadata with prefix key in the database.
591 * @tc.type: FUNC
592 * @tc.require: AR000CCPOM
593 * @tc.author: wangbingquan
594 */
DeleteMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)595 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteMetaData001(SQLiteSingleVerNaturalStore *&store,
596 SQLiteSingleVerNaturalStoreConnection *&connection)
597 {
598 /**
599 * @tc.steps:step1. Put 2 mete data with prefix key 'a', 2 meta data with prefix key 'b'.
600 And delete meta data with prefix key 'b'.
601 * @tc.expected: step1. Get all meta data and will get 2 data with prefix key 'a'.
602 */
603 TestMetaDataDeleteByPrefixKey(store, connection);
604 }
605
606 /**
607 * @tc.name: GetCurrentMaxTimestamp001
608 * @tc.desc: To test the function of obtaining the maximum timestamp when a record exists in the database.
609 * @tc.type: FUNC
610 * @tc.require: AR000CCPOM
611 * @tc.author: wangbingquan
612 */
GetCurrentMaxTimestamp001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)613 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetCurrentMaxTimestamp001(SQLiteSingleVerNaturalStore *&store,
614 SQLiteSingleVerNaturalStoreConnection *&connection)
615 {
616 Key key1;
617 Value value1;
618 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
619 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
620 Timestamp timeBegin = 0;
621 Timestamp timeMiddle = 0;
622 Timestamp timeEnd = 0;
623
624 /**
625 * @tc.steps:step1/2. Insert a data record into the synchronization database.
626 */
627 store->GetMaxTimestamp(timeBegin);
628 IOption option;
629 option.dataType = IOption::SYNC_DATA;
630 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
631
632 /**
633 * @tc.steps:step3. The current maximum timestamp is A.
634 */
635 store->GetMaxTimestamp(timeMiddle);
636 EXPECT_GT(timeMiddle, timeBegin);
637
638 /**
639 * @tc.steps:step4. Insert a data record into the synchronization database.
640 */
641 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
642
643 /**
644 * @tc.steps:step5. Obtain the maximum timestamp B and check whether B>=A exists.
645 * @tc.expected: step5. The obtained timestamp is B>=A.
646 */
647 store->GetMaxTimestamp(timeEnd);
648 EXPECT_GT(timeEnd, timeMiddle);
649 }
650
651 /**
652 * @tc.name: GetCurrentMaxTimestamp002
653 * @tc.desc: Obtain the maximum timestamp when no record exists in the test record library.
654 * @tc.type: FUNC
655 * @tc.require: AR000CCPOM
656 * @tc.author: wangbingquan
657 */
GetCurrentMaxTimestamp002(SQLiteSingleVerNaturalStore * & store)658 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetCurrentMaxTimestamp002(SQLiteSingleVerNaturalStore *&store)
659 {
660 /**
661 * @tc.steps:step1. Obtains the maximum timestamp in the current database record.
662 * @tc.expected: step1. Return timestamp is 0.
663 */
664 Timestamp timestamp = 10; // non-zero
665 store->GetMaxTimestamp(timestamp);
666 EXPECT_EQ(timestamp, 0UL);
667 }
668
669 /**
670 * @tc.name: LocalDatabaseOperate001
671 * @tc.desc: Test the function of inserting data in the local database of the NaturalStore.
672 * @tc.type: FUNC
673 * @tc.require: AR000CCPOM
674 * @tc.author: wangbingquan
675 */
LocalDatabaseOperate001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)676 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate001(SQLiteSingleVerNaturalStore *&store,
677 SQLiteSingleVerNaturalStoreConnection *&connection)
678 {
679 IOption option;
680 option.dataType = IOption::LOCAL_DATA;
681 DataBaseCommonPutOperate(store, connection, option);
682 }
683
684 /**
685 * @tc.name: LocalDatabaseOperate002
686 * @tc.desc: Test the function of deleting data from the local database of the NaturalStore.
687 * @tc.type: FUNC
688 * @tc.require: AR000CCPOM
689 * @tc.author: wangbingquan
690 */
LocalDatabaseOperate002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)691 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate002(SQLiteSingleVerNaturalStore *&store,
692 SQLiteSingleVerNaturalStoreConnection *&connection)
693 {
694 IOption option;
695 option.dataType = IOption::LOCAL_DATA;
696 DataBaseCommonDeleteOperate(store, connection, option);
697 }
698
699 /**
700 * @tc.name: LocalDatabaseOperate003
701 * @tc.desc: To test the function of reading data from the local database of the NaturalStore.
702 * @tc.type: FUNC
703 * @tc.require: AR000CCPOM
704 * @tc.author: wangbingquan
705 */
LocalDatabaseOperate003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)706 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate003(SQLiteSingleVerNaturalStore *&store,
707 SQLiteSingleVerNaturalStoreConnection *&connection)
708 {
709 IOption option;
710 option.dataType = IOption::LOCAL_DATA;
711 DataBaseCommonGetOperate(store, connection, option);
712 }
713
714 /**
715 * @tc.name: SyncDatabaseOperate001
716 * @tc.desc: To test the function of inserting data of the local device in the synchronization database.
717 * @tc.type: FUNC
718 * @tc.require: AR000CCPOM
719 * @tc.author: wangbingquan
720 */
SyncDatabaseOperate001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)721 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate001(SQLiteSingleVerNaturalStore *&store,
722 SQLiteSingleVerNaturalStoreConnection *&connection)
723 {
724 IOption option;
725 option.dataType = IOption::SYNC_DATA;
726 DataBaseCommonPutOperate(store, connection, option);
727 }
728
729 /**
730 * @tc.name: SyncDatabaseOperate002
731 * @tc.desc: test the put operation after data synced from other devices.
732 * @tc.type: FUNC
733 * @tc.require: AR000CCPOM
734 * @tc.author: wangbingquan
735 */
SyncDatabaseOperate002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)736 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate002(SQLiteSingleVerNaturalStore *&store,
737 SQLiteSingleVerNaturalStoreConnection *&connection)
738 {
739 IOption option;
740 option.dataType = IOption::SYNC_DATA;
741 DataItem dataItem1;
742 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
743 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
744 dataItem1.timestamp = 1001; // 1001 as random timestamp
745 dataItem1.writeTimestamp = dataItem1.timestamp;
746 dataItem1.flag = 0;
747
748 /**
749 * @tc.steps: step1/2. Add a remote synchronization data record. (key1, value1).
750 */
751 std::vector<DataItem> vect = {dataItem1};
752 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
753
754 /**
755 * @tc.steps: step3. Ioption is set to synchronous data. Obtains the value data of the key1.
756 * @tc.expected: step3. Return OK. The value is the same as the value of value1.
757 */
758 Value valueRead;
759 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
760 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
761
762 Value value2;
763 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, dataItem1.value.size() + 1);
764
765 /**
766 * @tc.steps: step4. Ioption Set the data to be synchronized and insert the data of key1,value2.
767 * @tc.expected: step4. Return OK.
768 */
769 EXPECT_EQ(connection->Put(option, dataItem1.key, value2), E_OK);
770 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
771
772 /**
773 * @tc.steps: step3. Ioption is set to synchronous data. Obtains the value data of the key1.
774 * @tc.expected: step3. Return OK. The value is the same as the value of value2.
775 */
776 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
777 }
778
779 /**
780 * @tc.name: SyncDatabaseOperate003
781 * @tc.desc: test the delete operation in sync database.
782 * @tc.type: FUNC
783 * @tc.require: AR000CCPOM
784 * @tc.author: wangbingquan
785 */
SyncDatabaseOperate003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)786 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate003(SQLiteSingleVerNaturalStore *&store,
787 SQLiteSingleVerNaturalStoreConnection *&connection)
788 {
789 IOption option;
790 option.dataType = IOption::SYNC_DATA;
791 DataBaseCommonDeleteOperate(store, connection, option);
792 }
793
794 /**
795 * @tc.name: SyncDatabaseOperate004
796 * @tc.desc: test the delete for the data from other devices in sync database.
797 * @tc.type: FUNC
798 * @tc.require: AR000CCPOM
799 * @tc.author: wangbingquan
800 */
SyncDatabaseOperate004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)801 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate004(SQLiteSingleVerNaturalStore *&store,
802 SQLiteSingleVerNaturalStoreConnection *&connection)
803 {
804 IOption option;
805 option.dataType = IOption::SYNC_DATA;
806 DataItem dataItem1;
807 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
808 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
809 dataItem1.timestamp = 1997; // 1997 as random timestamp
810 dataItem1.writeTimestamp = dataItem1.timestamp;
811 dataItem1.flag = 0;
812
813 std::vector<DataItem> vect = {dataItem1};
814 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
815
816 /**
817 * @tc.steps: step2. The Ioption parameter is set to synchronize data to obtain the value data of the key1.
818 * @tc.expected: step2. Return OK. The value is the same as the value of value1.
819 */
820 Value valueRead;
821 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
822 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
823
824 Key key2;
825 DistributedDBToolsUnitTest::GetRandomKeyValue(key2);
826 EXPECT_EQ(connection->Delete(option, key2), E_OK);
827
828 /**
829 * @tc.steps: step3. The Ioption parameter is set to synchronize data, and the key1 data is deleted.
830 * @tc.expected: step3. Return OK.
831 */
832 EXPECT_EQ(connection->Delete(option, dataItem1.key), E_OK);
833
834 /**
835 * @tc.steps: step4. The Ioption parameter is set to synchronize data to obtain the value data of the key1.
836 * @tc.expected: step4. Return E_NOT_FOUND.
837 */
838 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), -E_NOT_FOUND);
839 }
840
841 /**
842 * @tc.name: SyncDatabaseOperate005
843 * @tc.desc: test the reading for sync database.
844 * @tc.type: FUNC
845 * @tc.require: AR000CCPOM
846 * @tc.author: wangbingquan
847 */
SyncDatabaseOperate005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)848 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate005(SQLiteSingleVerNaturalStore *&store,
849 SQLiteSingleVerNaturalStoreConnection *&connection)
850 {
851 IOption option;
852 option.dataType = IOption::SYNC_DATA;
853 DataBaseCommonGetOperate(store, connection, option);
854 }
855
856 /**
857 * @tc.name: SyncDatabaseOperate006
858 * @tc.desc: test the get entries for sync database
859 * @tc.type: FUNC
860 * @tc.require: AR000CCPOM
861 * @tc.author: wangbingquan
862 */
SyncDatabaseOperate006(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)863 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate006(SQLiteSingleVerNaturalStore *&store,
864 SQLiteSingleVerNaturalStoreConnection *&connection)
865 {
866 IOption option;
867 option.dataType = IOption::SYNC_DATA;
868
869 /**
870 * @tc.steps: step2/3/4. Set Ioption to synchronous data.
871 * Insert the data of key=keyPrefix + 'a', value1.
872 * Insert the data of key=keyPrefix + 'c', value2.
873 * Insert the data of key length=keyPrefix length - 1, value3.
874 * @tc.expected: step2/3/4. Return E_NOT_FOUND.
875 */
876 Key key1;
877 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, 30); // 30 as random size
878 Key key2 = key1;
879 key2.push_back('C');
880 Key key3 = key1;
881 key3.pop_back();
882 Value value1;
883 DistributedDBToolsUnitTest::GetRandomKeyValue(value1, 84); // 84 as random size
884 Value value2;
885 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, 101); // 101 as random size
886 Value value3;
887 DistributedDBToolsUnitTest::GetRandomKeyValue(value3, 37); // 37 as random size
888 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
889 EXPECT_EQ(connection->Put(option, key2, value2), E_OK);
890 EXPECT_EQ(connection->Put(option, key3, value3), E_OK);
891
892 /**
893 * @tc.steps: step5. Obtain all data whose prefixKey is keyPrefix.
894 * @tc.expected: step5. Return OK. The number of obtained data records is 2.
895 */
896 std::vector<Entry> entriesRead;
897 EXPECT_EQ(connection->GetEntries(option, key1, entriesRead), E_OK);
898 EXPECT_EQ(entriesRead.size(), 2UL);
899
900 /**
901 * @tc.steps: step6. Obtain all data whose prefixKey is empty.
902 * @tc.expected: step6. Return OK. The number of obtained data records is 3.
903 */
904 entriesRead.clear();
905 Key emptyKey;
906 EXPECT_EQ(connection->GetEntries(option, emptyKey, entriesRead), E_OK);
907 EXPECT_EQ(entriesRead.size(), 3UL);
908
909 /**
910 * @tc.steps: step7. Obtain all data whose prefixKey is keyPrefix.
911 * @tc.expected: step7. Return E_NOT_SUPPORT.
912 */
913 option.dataType = IOption::LOCAL_DATA;
914 EXPECT_EQ(connection->GetEntries(option, emptyKey, entriesRead), -E_NOT_FOUND);
915 }
916
917 /**
918 * @tc.name: ClearRemoteData001
919 * @tc.desc: test the clear data synced from the remote by device.
920 * @tc.type: FUNC
921 * @tc.require: AR000CIFDA AR000CQS3T
922 * @tc.author: wangbingquan
923 */
ClearRemoteData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)924 void DistributedDBStorageSingleVerNaturalStoreTestCase::ClearRemoteData001(SQLiteSingleVerNaturalStore *&store,
925 SQLiteSingleVerNaturalStoreConnection *&connection)
926 {
927 IOption option;
928 option.dataType = IOption::SYNC_DATA;
929 DataItem dataItem1;
930 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
931 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
932 dataItem1.timestamp = 1997; // 1997 as random timestamp
933 dataItem1.writeTimestamp = dataItem1.timestamp;
934 dataItem1.flag = 0;
935
936 DataItem dataItem2;
937 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.key, dataItem1.key.size() + 1);
938 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.value);
939 dataItem2.timestamp = 2019; // 2019 as random timestamp
940 dataItem2.writeTimestamp = dataItem2.timestamp;
941 dataItem2.flag = 0;
942
943 /**
944 * @tc.steps: step1. New data is inserted to the B end of the device. [keyB, valueB].
945 */
946 std::vector<DataItem> vect = {dataItem1};
947 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceA"), E_OK);
948
949 /**
950 * @tc.steps: step2. The device pulls the data of the device B, and the device inserts the [keyA, valueA].
951 */
952 vect.clear();
953 vect.push_back(dataItem2);
954 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
955
956 /**
957 * @tc.steps: step3. The device obtains the data of keyA and valueB.
958 * @tc.expected: step3. Obtain [keyA, valueA] and [keyB, valueB].
959 */
960 Value valueRead;
961 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
962 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
963 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), E_OK);
964 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem2.value), true);
965
966 /**
967 * @tc.steps: step4.Invoke the interface for clearing the synchronization data of the B device.
968 */
969 if (RuntimeContext::GetInstance()->IsCommunicatorAggregatorValid()) {
970 return;
971 }
972 EXPECT_EQ(store->RemoveDeviceData("deviceA", false), E_OK);
973
974 /**
975 * @tc.steps: step5. The device obtains the data of keyA and valueB.
976 * @tc.expected: step5. The value of [keyA, valueA] is obtained,
977 * and the value of NOT_FOUND is obtained by querying keyB.
978 */
979 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), -E_NOT_FOUND);
980 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), E_OK);
981 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem2.value), true);
982
983 EXPECT_EQ(store->RemoveDeviceData("deviceB", false), E_OK);
984 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), -E_NOT_FOUND);
985 }
986
987 /**
988 * @tc.name: DeleteUserKeyValue001
989 * @tc.desc: When a user deletes a data record, the system clears the user record.
990 * @tc.type: FUNC
991 * @tc.require: AR000CKRTC AR000CQE0D
992 * @tc.author: sunpeng
993 */
DeleteUserKeyValue001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)994 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue001(SQLiteSingleVerNaturalStore *&store,
995 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
996 {
997 // StoreID::TestGeneralNB
998 IOption option;
999 option.dataType = IOption::SYNC_DATA;
1000
1001 // per-set data
1002 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1003 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1004
1005 /**
1006 * @tc.steps: step1. delete K1.
1007 * @tc.expected: step1. delete K1 successfully.
1008 */
1009 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1010
1011 // Close database
1012 connection->Close();
1013 connection = nullptr;
1014 store = nullptr;
1015
1016 /**
1017 * @tc.steps: step2. Real query by sqlite3.
1018 * @tc.expected: step2. Find KEY_1, not find K2.
1019 */
1020 std::vector<SyncData> vecSyncData;
1021 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1022
1023 bool isFound = false;
1024 EXPECT_EQ(numSelect, 2); // 2 as entry size
1025 isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1026 EXPECT_EQ(isFound, false);
1027 isFound = IsSqlinteExistKey(vecSyncData, KEY_2);
1028 EXPECT_EQ(isFound, true);
1029 }
1030
1031 /**
1032 * @tc.name: MemoryDbDeleteUserKeyValue001
1033 * @tc.desc: When a user deletes a data record, the system clears the user record.
1034 * @tc.type: FUNC
1035 * @tc.require: AR000CKRTC AR000CQE0D
1036 * @tc.author: sunpeng
1037 */
MemoryDbDeleteUserKeyValue001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1038 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue001(
1039 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1040 {
1041 // StoreID::TestGeneralNB
1042 IOption option;
1043 option.dataType = IOption::SYNC_DATA;
1044
1045 // per-set data
1046 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1047 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1048
1049 /**
1050 * @tc.steps: step1. delete K1.
1051 * @tc.expected: step1. delete K1 successfully.
1052 */
1053 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1054
1055 /**
1056 * @tc.steps: step3. Real query by sqlite3.
1057 * @tc.expected: step3. Find KEY_1, not find K2.
1058 */
1059 std::vector<SyncData> vecSyncData;
1060 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1061
1062 bool isFound = false;
1063 EXPECT_EQ(numSelect, 2); // 2 as entry size
1064 isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1065 EXPECT_EQ(isFound, false);
1066 isFound = IsSqlinteExistKey(vecSyncData, KEY_2);
1067 EXPECT_EQ(isFound, true);
1068
1069 // Close database
1070 connection->Close();
1071 connection = nullptr;
1072 store = nullptr;
1073 }
1074
1075 /**
1076 * @tc.name: DeleteUserKeyValue002
1077 * @tc.desc: After the synchronization library data is deleted locally, add the same key data locally.
1078 * @tc.type: FUNC
1079 * @tc.require: AR000CKRTC AR000CQE0D
1080 * @tc.author: sunpeng
1081 */
DeleteUserKeyValue002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1082 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue002(SQLiteSingleVerNaturalStore *&store,
1083 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1084 {
1085 IOption option;
1086 option.dataType = IOption::SYNC_DATA;
1087
1088 // pre-set data
1089 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1090 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1091
1092 /**
1093 * @tc.steps: step1. Delete key1 data via Delete interface.
1094 * @tc.expected: step1. Delete successfully.
1095 */
1096 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1097
1098 /**
1099 * @tc.steps: step2. New data from key1, value3 via Put interface.
1100 * @tc.expected: step2. New data from key1, value3 via Put interface successfully.
1101 */
1102 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_3), E_OK);
1103
1104 /**
1105 * @tc.steps: step3. Query key1 data via Get interface.
1106 * @tc.expected: step3. Query key1 data via Get interface successfully, get value3 by key1.
1107 */
1108 Value valueRead;
1109 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1110 EXPECT_EQ(valueRead, VALUE_3);
1111
1112 /**
1113 * @tc.steps: step4. Query key1 real data by sqlite3.
1114 * @tc.expected: step4. Two records were found.
1115 */
1116 std::vector<SyncData> vecSyncData;
1117 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1118
1119 EXPECT_EQ(numSelect, 2); // 2 as entry size
1120 }
1121
1122 /**
1123 * @tc.name: DeleteUserKeyValue003
1124 * @tc.desc: After the synchronization database data is deleted locally, the same key data is added from the remote end.
1125 * @tc.type: FUNC
1126 * @tc.require: AR000CKRTC AR000CQE0D
1127 * @tc.author: sunpeng
1128 */
DeleteUserKeyValue003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1129 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue003(SQLiteSingleVerNaturalStore *&store,
1130 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1131 {
1132 IOption option;
1133 option.dataType = IOption::SYNC_DATA;
1134
1135 // ready data
1136 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1137
1138 /**
1139 * @tc.steps: step1. Delete data by key1.
1140 * @tc.expected: step1. Delete successfully.
1141 */
1142 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1143
1144 /**
1145 * @tc.steps: step2. Get data by key1.
1146 * @tc.expected: step1. Key1 not exist in database.
1147 */
1148 Value valueRead;
1149 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1150
1151 Timestamp timestamp = 0;
1152 store->GetMaxTimestamp(timestamp);
1153
1154 DataItem dataItem1;
1155 dataItem1.key = KV_ENTRY_1.key;
1156 dataItem1.value = KV_ENTRY_3.value;
1157 dataItem1.timestamp = timestamp - 100UL; // less than current timestamp
1158 dataItem1.writeTimestamp = dataItem1.timestamp;
1159 dataItem1.flag = 0;
1160
1161 DataItem dataItem2;
1162 dataItem2.key = KV_ENTRY_1.key;
1163 dataItem2.value = KV_ENTRY_4.value;
1164 dataItem2.timestamp = timestamp + 100UL; // bigger than current timestamp
1165 dataItem2.writeTimestamp = dataItem2.timestamp;
1166 dataItem2.flag = 0;
1167 std::vector<DataItem> vect = {dataItem1};
1168
1169 /**
1170 * @tc.steps: step3. Get a new data from remote device B , key1, value3,
1171 * with a smaller timestamp than the current timestamp.
1172 */
1173 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1174
1175 /**
1176 * @tc.steps: step4. Get data by key1.
1177 * @tc.expected: step4. Key1 not exist in database.
1178 */
1179 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1180
1181 /**
1182 * @tc.steps: step5. Get a new data from remote device C , key1, value4,
1183 * and the timestamp is larger than the current timestamp.
1184 */
1185 vect.clear();
1186 vect.push_back(dataItem2);
1187 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceC"), E_OK);
1188
1189 /**
1190 * @tc.steps: step6. Get data by key1.
1191 * @tc.expected: step6. Key1 not exist in database.
1192 */
1193 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1194
1195 /**
1196 * @tc.steps: step7. Get real data by key1.
1197 * @tc.expected: step7. Get 1 record.
1198 */
1199 std::vector<SyncData> vecSyncData;
1200 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1201
1202 EXPECT_EQ(numSelect, 1);
1203 }
1204
1205 /**
1206 * @tc.name: DeleteUserKeyValue004
1207 * @tc.desc: Changes in key after remote delete data syncs to local
1208 * @tc.type: FUNC
1209 * @tc.require: AR000CKRTC AR000CQE0D
1210 * @tc.author: sunpeng
1211 */
DeleteUserKeyValue004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1212 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue004(SQLiteSingleVerNaturalStore *&store,
1213 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1214 {
1215 // pre-set data
1216 IOption option;
1217 option.dataType = IOption::SYNC_DATA;
1218 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1219
1220 DataItem dataItem1;
1221 dataItem1.key = KV_ENTRY_1.key;
1222 dataItem1.value = KV_ENTRY_1.value;
1223 store->GetMaxTimestamp(dataItem1.timestamp);
1224 dataItem1.flag = 1;
1225 dataItem1.timestamp += 1;
1226 dataItem1.writeTimestamp = dataItem1.timestamp;
1227 /**
1228 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1229 * pull the action of key1 to local.
1230 */
1231 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1232 std::vector<DataItem> vect = {dataItem1};
1233 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1234
1235 /**
1236 * @tc.steps: step4. Close database.
1237 */
1238 connection->Close();
1239 connection = nullptr;
1240 store = nullptr;
1241
1242 /**
1243 * @tc.steps: step5 6. Get real data by key1;and get the number of records.
1244 * @tc.expected: step5 6. Not exist key1 real data in database;Get 1 record.
1245 */
1246 std::vector<SyncData> vecSyncData;
1247 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1248
1249 EXPECT_EQ(numSelect, 1);
1250 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1251 EXPECT_EQ(isFound, false);
1252 }
1253
1254 /**
1255 * @tc.name: MemoryDbDeleteUserKeyValue004
1256 * @tc.desc: Changes in key after remote delete data syncs to local
1257 * @tc.type: FUNC
1258 * @tc.require: AR000CKRTC AR000CQE0D
1259 * @tc.author: sunpeng
1260 */
MemoryDbDeleteUserKeyValue004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1261 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue004(
1262 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1263 {
1264 // pre-set data
1265 IOption option;
1266 option.dataType = IOption::SYNC_DATA;
1267 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1268
1269 DataItem dataItem1;
1270 dataItem1.key = KV_ENTRY_1.key;
1271 dataItem1.value = KV_ENTRY_1.value;
1272 store->GetMaxTimestamp(dataItem1.timestamp);
1273 dataItem1.flag = 1;
1274 dataItem1.timestamp += 1;
1275 dataItem1.writeTimestamp = dataItem1.timestamp;
1276 /**
1277 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1278 * pull the action of key1 to local.
1279 */
1280 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1281 std::vector<DataItem> vect = {dataItem1};
1282 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1283
1284 /**
1285 * @tc.steps: step4 5. Get real data by key1;and get the number of records.
1286 * @tc.expected: step 4 5. Not exist key1 real data in database;Get 1 record.
1287 */
1288 std::vector<SyncData> vecSyncData;
1289 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1290
1291 EXPECT_EQ(numSelect, 1);
1292 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1293 EXPECT_EQ(isFound, false);
1294
1295 connection->Close();
1296 connection = nullptr;
1297 store = nullptr;
1298 }
1299
1300 /**
1301 * @tc.name: DeleteUserKeyValue005
1302 * @tc.desc: New unified key data locally after remote delete data syncs to local
1303 * @tc.type: FUNC
1304 * @tc.require: AR000CKRTC AR000CQE0D
1305 * @tc.author: sunpeng
1306 */
DeleteUserKeyValue005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1307 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue005(SQLiteSingleVerNaturalStore *&store,
1308 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1309 {
1310 // pre-set data
1311 IOption option;
1312 option.dataType = IOption::SYNC_DATA;
1313 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1314 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1315
1316 DataItem dataItem1;
1317 dataItem1.key = KV_ENTRY_1.key;
1318 dataItem1.value = KV_ENTRY_1.value;
1319 store->GetMaxTimestamp(dataItem1.timestamp);
1320 dataItem1.timestamp = dataItem1.timestamp + 10UL;
1321 dataItem1.writeTimestamp = dataItem1.timestamp;
1322 dataItem1.flag = 1;
1323
1324 /**
1325 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1326 * pull the action of key1 to local.
1327 */
1328 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1329 std::vector<DataItem> vect = {dataItem1};
1330 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1331
1332 /**
1333 * @tc.steps: step4. Put K1 V1 to database.
1334 * @tc.expected: step4. Put successfully.
1335 */
1336 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1337
1338 /**
1339 * @tc.steps: step5. Close database.
1340 */
1341 connection->Close();
1342 connection = nullptr;
1343 store = nullptr;
1344
1345 /**
1346 * @tc.steps: step6 7. Get real data by key1;and get the number of records.
1347 * @tc.expected: step6 7. Not exist key1 real data in database;Get 2 record.
1348 */
1349 std::vector<SyncData> vecSyncData;
1350 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1351
1352 EXPECT_EQ(numSelect, 2); // 2 as entry size
1353 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1354 EXPECT_EQ(isFound, true);
1355 }
1356
1357 /**
1358 * @tc.name: MemoryDbDeleteUserKeyValue005
1359 * @tc.desc: New unified key data locally after remote delete data syncs to local
1360 * @tc.type: FUNC
1361 * @tc.require: AR000CKRTC AR000CQE0D
1362 * @tc.author: sunpeng
1363 */
MemoryDbDeleteUserKeyValue005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1364 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue005(
1365 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1366 {
1367 // pre-set data
1368 IOption option;
1369 option.dataType = IOption::SYNC_DATA;
1370 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1371 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1372
1373 DataItem dataItem1;
1374 dataItem1.key = KV_ENTRY_1.key;
1375 dataItem1.value = KV_ENTRY_1.value;
1376 store->GetMaxTimestamp(dataItem1.timestamp);
1377 dataItem1.timestamp = TimeHelper::GetSysCurrentTime();
1378 dataItem1.writeTimestamp = dataItem1.timestamp;
1379 dataItem1.flag = 1;
1380
1381 /**
1382 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1383 * pull the action of key1 to local.
1384 */
1385 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1386 std::vector<DataItem> vect = {dataItem1};
1387 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1388
1389 /**
1390 * @tc.steps: step4. Put K1 V1 to database.
1391 * @tc.expected: step4. Put successfully.
1392 */
1393 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1394
1395 /**
1396 * @tc.steps: step5 6. Get real data by key1;and get the number of records.
1397 * @tc.expected: step5 6. Not exist key1 real data in database;Get 2 record.
1398 */
1399 std::vector<SyncData> vecSyncData;
1400 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1401
1402 EXPECT_EQ(numSelect, 2); // 2 as entry size
1403 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1404 EXPECT_EQ(isFound, true);
1405
1406 connection->Close();
1407 connection = nullptr;
1408 store = nullptr;
1409 }
1410
1411 /**
1412 * @tc.name: DeleteUserKeyValue006
1413 * @tc.desc: After the remote delete data is synced to the local,
1414 * the same key data is added from the remote other devices
1415 * @tc.type: FUNC
1416 * @tc.require: AR000CKRTC AR000CQE0D
1417 * @tc.author: sunpeng
1418 */
DeleteUserKeyValue006(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1419 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue006(SQLiteSingleVerNaturalStore *&store,
1420 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1421 {
1422 // pre-set data
1423 IOption option;
1424 option.dataType = IOption::SYNC_DATA;
1425 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1426
1427 DataItem dataItem1;
1428 dataItem1.key = KV_ENTRY_1.key;
1429 dataItem1.value = KV_ENTRY_1.value;
1430 store->GetMaxTimestamp(dataItem1.timestamp);
1431 dataItem1.timestamp = dataItem1.timestamp + 10UL;
1432 dataItem1.writeTimestamp = dataItem1.timestamp;
1433 dataItem1.flag = 1;
1434
1435 /**
1436 * @tc.steps: step1. Remote device B sync deletes data key1 and pushes to local.
1437 */
1438 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1439 std::vector<DataItem> vect = {dataItem1};
1440 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1441
1442 /**
1443 * @tc.steps: step2. Get key1 from database.
1444 * @tc.expected: step2. Not exist key1.
1445 */
1446 Value valueRead;
1447 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1448
1449 dataItem1.key = KV_ENTRY_1.key;
1450 dataItem1.flag = 0;
1451 dataItem1.value = KV_ENTRY_2.value;
1452 dataItem1.timestamp = dataItem1.timestamp - 100UL; // less than current timestamp
1453 dataItem1.writeTimestamp = dataItem1.timestamp;
1454 /**
1455 * @tc.steps: step3. Remote device C syncs new data (key1, value2),
1456 * timestamp is less than delete timestamp, to local.
1457 */
1458 vect = {dataItem1};
1459 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceC"), E_OK);
1460
1461 /**
1462 * @tc.steps: step4. Get key1 from database.
1463 * @tc.expected: step4. Not exist key1.
1464 */
1465 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1466
1467 dataItem1.value = KV_ENTRY_3.value;
1468 dataItem1.timestamp = dataItem1.timestamp + 200UL; // bigger than current timestamp
1469 dataItem1.writeTimestamp = dataItem1.timestamp;
1470 /**
1471 * @tc.steps: step5. Remote device C syncs new data (key1, value2),
1472 * timestamp is bigger than delete timestamp, to local.
1473 */
1474 vect = {dataItem1};
1475 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceD"), E_OK);
1476
1477 /**
1478 * @tc.steps: step6. Get key1 from database.
1479 * @tc.expected: step6. Exist key1.
1480 */
1481 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1482 EXPECT_EQ(valueRead, VALUE_3);
1483
1484 /**
1485 * @tc.steps: step7. Get real data from database.
1486 * @tc.expected: step7. Get 1 record.
1487 */
1488 std::vector<SyncData> vecSyncData;
1489 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1490
1491 EXPECT_EQ(numSelect, 1);
1492 }
1493
1494 // param [in] dbName:Database name,strSql: The sql statement executed,[out],vecSyncData:SYNC_DATA table data
1495 // Real query sync-DATA table data via sqlite. return query data row number
GetRawSyncData(const std::string & dbName,const std::string & strSql,std::vector<SyncData> & vecSyncData)1496 int DistributedDBStorageSingleVerNaturalStoreTestCase::GetRawSyncData(const std::string &dbName,
1497 const std::string &strSql, std::vector<SyncData> &vecSyncData)
1498 {
1499 uint64_t flag = SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE;
1500 flag |= SQLITE_OPEN_CREATE;
1501
1502 sqlite3* db = nullptr;
1503 int nResult = sqlite3_open_v2(dbName.c_str(), &db, flag, nullptr);
1504 if (nResult != SQLITE_OK) {
1505 return -nResult;
1506 }
1507
1508 sqlite3_stmt *statement = nullptr;
1509
1510 nResult = sqlite3_prepare(db, strSql.c_str(), -1, &statement, NULL);
1511 if (nResult != SQLITE_OK) {
1512 (void)sqlite3_close_v2(db);
1513 return -1;
1514 }
1515
1516 while (sqlite3_step(statement) == SQLITE_ROW) {
1517 SyncData stuSyncData;
1518 const uint8_t *blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_KEY_INDEX));
1519 int valueLength = sqlite3_column_bytes(statement, SYNC_RES_KEY_INDEX);
1520 if (blobValue == nullptr) {
1521 stuSyncData.key.clear();
1522 } else {
1523 stuSyncData.key.resize(valueLength);
1524 stuSyncData.key.assign(blobValue, blobValue + valueLength);
1525 }
1526
1527 blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_HASH_KEY_INDEX));
1528 valueLength = sqlite3_column_bytes(statement, SYNC_RES_HASH_KEY_INDEX);
1529 stuSyncData.hashKey.resize(valueLength);
1530 stuSyncData.hashKey.assign(blobValue, blobValue + valueLength);
1531
1532 blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_VAL_INDEX));
1533 valueLength = sqlite3_column_bytes(statement, SYNC_RES_VAL_INDEX);
1534 if (blobValue == nullptr) {
1535 stuSyncData.value.clear();
1536 } else {
1537 stuSyncData.value.resize(valueLength);
1538 stuSyncData.value.assign(blobValue, blobValue + valueLength);
1539 }
1540
1541 stuSyncData.timestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1542 stuSyncData.flag = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX));
1543 vecSyncData.push_back(stuSyncData);
1544 }
1545
1546 sqlite3_finalize(statement);
1547 statement = nullptr;
1548 (void)sqlite3_close_v2(db);
1549 return static_cast<int>(vecSyncData.size());
1550 }
1551
1552 // @Real query sync-DATA table by key, judge is exist.
IsSqlinteExistKey(const std::vector<SyncData> & vecSyncData,const std::vector<uint8_t> & key)1553 bool DistributedDBStorageSingleVerNaturalStoreTestCase::IsSqlinteExistKey(const std::vector<SyncData> &vecSyncData,
1554 const std::vector<uint8_t> &key)
1555 {
1556 for (const auto &iter : vecSyncData) {
1557 if (key == iter.key) {
1558 return true;
1559 }
1560 }
1561 return false;
1562 }
1563
TestMetaDataPutAndGet(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)1564 void DistributedDBStorageSingleVerNaturalStoreTestCase::TestMetaDataPutAndGet(SQLiteSingleVerNaturalStore *&store,
1565 SQLiteSingleVerNaturalStoreConnection *&connection)
1566 {
1567 Key key1;
1568 Value value1;
1569 Key emptyKey;
1570 Value emptyValue;
1571 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1572 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1573
1574 /**
1575 * @tc.steps:step1. Run the PutMetaData command to insert a non-empty key1 non-empty value1 data record.
1576 * @tc.expected: step1. Return OK.
1577 */
1578 EXPECT_EQ(store->PutMetaData(key1, value1, false), E_OK);
1579
1580 /**
1581 * @tc.steps:step2. Run the PutMetaData command to insert a non-empty key1 non-empty value1 data record.
1582 * @tc.expected: step2. The obtained value is the same as the value of value1.
1583 */
1584 Value valueRead;
1585 EXPECT_EQ(store->GetMetaData(key1, valueRead), E_OK);
1586 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1587 Value value2;
1588 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, static_cast<int>(value1.size() + 3)); // 3 as random size
1589
1590 /**
1591 * @tc.steps:step3. The key value is key1, the value is not empty,
1592 * and the value of value2 is different from the value of value1 through the PutMetaData interface.
1593 * @tc.expected: step3. Return OK.
1594 */
1595 EXPECT_EQ(store->PutMetaData(key1, value2, false), E_OK);
1596
1597 /**
1598 * @tc.steps:step4. Run the GetMetaData command to obtain the value of key1
1599 * and check whether the value is the same as the value of value2.
1600 * @tc.expected: step4. The obtained value is the same as the value of value2.
1601 */
1602 EXPECT_EQ(store->GetMetaData(key1, valueRead), E_OK);
1603 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1604
1605 /**
1606 * @tc.steps:step5. Use PutMetaData to insert a record whose key is empty and value is not empty.
1607 * @tc.expected: step5. Return E_INVALID_ARGS.
1608 */
1609 EXPECT_EQ(store->PutMetaData(emptyKey, value1, false), -E_INVALID_ARGS);
1610
1611 /**
1612 * @tc.steps:step6. Use PutMetaData in NaturalStore to insert data whose key2(!=key1)
1613 * is not empty and value is empty.
1614 * @tc.expected: step6. Return OK.
1615 */
1616 Key key2;
1617 DistributedDBToolsUnitTest::GetRandomKeyValue(key2, static_cast<int>(key1.size() + 1));
1618 EXPECT_EQ(store->PutMetaData(key2, emptyValue, false), E_OK);
1619
1620 /**
1621 * @tc.steps:step7. Obtain the value of key2 and check whether the value is empty.
1622 * @tc.expected: step7. The obtained value is empty.
1623 */
1624 EXPECT_EQ(store->GetMetaData(key2, valueRead), E_OK);
1625 EXPECT_EQ(valueRead.empty(), true);
1626
1627 /**
1628 * @tc.steps:step8. Insert the data whose key size is 1024 and value size is 4Mb
1629 * through PutMetaData of NaturalStore.
1630 * @tc.expected: step8. Return OK.
1631 */
1632 Key sizeKey;
1633 Value sizeValue;
1634 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeKey, MAX_TEST_KEY_SIZE);
1635 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeValue, MAX_TEST_VAL_SIZE);
1636 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue, false), E_OK);
1637 EXPECT_EQ(store->GetMetaData(sizeKey, valueRead), E_OK);
1638 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, sizeValue), true);
1639
1640 /**
1641 * @tc.steps:step9/10. Insert data items whose key size is greater than 1 kb
1642 * or value size greater than 4Mb through PutMetaData of NaturalStore.
1643 * @tc.expected: step9/10. Return E_INVALID_ARGS.
1644 */
1645 sizeKey.push_back(249); // 249 as random size
1646 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue, false), -E_INVALID_ARGS);
1647 sizeKey.pop_back();
1648 sizeValue.push_back(174); // 174 as random size
1649 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue, false), -E_INVALID_ARGS);
1650
1651 /**
1652 * @tc.steps:step11. Delete key1 and key2 successfully.
1653 * @tc.expected: step11. Cannot find key1 and key2 in DB anymore.
1654 */
1655 EXPECT_EQ(store->DeleteMetaData(std::vector<Key> {key1, key2}), E_OK);
1656 EXPECT_EQ(store->GetMetaData(key1, valueRead), -E_NOT_FOUND);
1657 EXPECT_EQ(store->GetMetaData(key2, valueRead), -E_NOT_FOUND);
1658
1659 /**
1660 * @tc.steps:step12. Get metadata use read handle
1661 * @tc.expected: step12. Cannot find key1 and key2 in DB anymore.
1662 */
1663 int errCode = E_OK;
1664 auto handle = store->GetHandle(true, errCode);
1665 EXPECT_EQ(store->GetMetaData(key2, valueRead), -E_NOT_FOUND);
1666 store->ReleaseHandle(handle);
1667 }
1668
DataBaseCommonPutOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1669 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonPutOperate(SQLiteSingleVerNaturalStore *&store,
1670 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1671 {
1672 Key key1;
1673 Value value1;
1674
1675 /**
1676 * @tc.steps: step1/2. Set Ioption to the local data and insert a record of key1 and value1.
1677 * @tc.expected: step1/2. Return OK.
1678 */
1679 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1680 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1681 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1682
1683 /**
1684 * @tc.steps: step3. Set Ioption to the local data and obtain the value of key1.
1685 * Check whether the value is the same as the value of value1.
1686 * @tc.expected: step3. The obtained value and value2 are the same.
1687 */
1688 Value valueRead;
1689 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1690 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1691 Value value2;
1692 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, static_cast<int>(value1.size() + 3)); // 3 more for diff
1693
1694 /**
1695 * @tc.steps: step4. Ioption Set this parameter to the local data. Insert key1.
1696 * The value cannot be empty. value2(!=value1)
1697 * @tc.expected: step4. Return OK.
1698 */
1699 EXPECT_EQ(connection->Put(option, key1, value2), E_OK);
1700
1701 /**
1702 * @tc.steps: step5. Set Ioption to the local data, GetMetaData to obtain the value of key1,
1703 * and check whether the value is the same as the value of value2.
1704 * @tc.expected: step5. The obtained value and value2 are the same.
1705 */
1706 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1707 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1708
1709 /**
1710 * @tc.steps: step6. The Ioption parameter is set to the local data.
1711 * The data record whose key is empty and value is not empty is inserted.
1712 * @tc.expected: step6. Return E_INVALID_DATA.
1713 */
1714 Key emptyKey;
1715 Value emptyValue;
1716 EXPECT_EQ(connection->Put(option, emptyKey, value1), -E_INVALID_ARGS);
1717
1718 /**
1719 * @tc.steps: step7. Set Ioption to the local data, insert data
1720 * whose key2(!=key1) is not empty, and value is empty.
1721 * @tc.expected: step7. Return OK.
1722 */
1723 Key key2;
1724 DistributedDBToolsUnitTest::GetRandomKeyValue(key2, static_cast<int>(key1.size() + 1));
1725 EXPECT_EQ(connection->Put(option, key2, emptyValue), E_OK);
1726
1727 /**
1728 * @tc.steps: step8. Set option to local data, obtain the value of key2,
1729 * and check whether the value is empty.
1730 * @tc.expected: step8. Return OK, value is empty.
1731 */
1732 EXPECT_EQ(connection->Get(option, key2, valueRead), E_OK);
1733 EXPECT_EQ(valueRead.empty(), true);
1734
1735 /**
1736 * @tc.steps: step9. Ioption Set the local data.
1737 * Insert the data whose key size is 1024 and value size is 4Mb.
1738 * @tc.expected: step9. Return OK.
1739 */
1740 Key sizeKey;
1741 Value sizeValue;
1742 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeKey, MAX_TEST_KEY_SIZE);
1743 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeValue, MAX_TEST_VAL_SIZE);
1744 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), E_OK);
1745 EXPECT_EQ(connection->Get(option, sizeKey, valueRead), E_OK);
1746 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, sizeValue), true);
1747
1748 /**
1749 * @tc.steps: step10/11. Set Ioption to the local data and insert data items
1750 * whose value is greater than 4Mb or key is bigger than 1Kb
1751 * @tc.expected: step10/11. Return E_INVALID_ARGS.
1752 */
1753 sizeKey.push_back(std::rand()); // random size
1754 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), -E_INVALID_ARGS);
1755 sizeKey.pop_back();
1756 sizeValue.push_back(174); // 174 as random size
1757 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), -E_INVALID_ARGS);
1758 }
1759
DataBaseCommonDeleteOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1760 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonDeleteOperate(SQLiteSingleVerNaturalStore *&store,
1761 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1762 {
1763 /**
1764 * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
1765 * @tc.expected: step2. Return E_INVALID_ARGS.
1766 */
1767 Key key1;
1768 EXPECT_EQ(connection->Delete(option, key1), -E_INVALID_ARGS);
1769 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE + 1);
1770 EXPECT_EQ(connection->Delete(option, key1), -E_INVALID_ARGS);
1771 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1772 EXPECT_EQ(connection->Delete(option, key1), E_OK);
1773
1774 /**
1775 * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
1776 * @tc.expected: step3. Return E_OK.
1777 */
1778 Value value1;
1779 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1780 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1781
1782 /**
1783 * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
1784 * and check whether the value is the same as that of value1.
1785 * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
1786 */
1787 Value valueRead;
1788 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1789 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1790
1791 /**
1792 * @tc.steps: step5. Set Ioption to the local data and delete the data whose key is key1.
1793 * @tc.expected: step5. Return E_OK.
1794 */
1795 EXPECT_EQ(connection->Delete(option, key1), E_OK);
1796
1797 /**
1798 * @tc.steps: step5. Set Ioption to the local data and obtain the value of Key1.
1799 * @tc.expected: step5. Return E_NOT_FOUND.
1800 */
1801 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_NOT_FOUND);
1802 }
1803
DataBaseCommonGetOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1804 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonGetOperate(SQLiteSingleVerNaturalStore *&store,
1805 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1806 {
1807 /**
1808 * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
1809 * @tc.expected: step2. Return E_INVALID_ARGS.
1810 */
1811 Key key1;
1812 Value valueRead;
1813 // empty key
1814 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_INVALID_ARGS);
1815
1816 // invalid key
1817 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE + 1);
1818 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_INVALID_ARGS);
1819
1820 // non-exist key
1821 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE);
1822 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_NOT_FOUND);
1823
1824 /**
1825 * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
1826 * @tc.expected: step3. Return E_OK.
1827 */
1828 Value value1;
1829 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1830 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1831
1832 /**
1833 * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
1834 * and check whether the value is the same as that of value1.
1835 * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
1836 */
1837 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1838 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1839
1840 Key key2;
1841 DistributedDBToolsUnitTest::GetRandomKeyValue(key2);
1842 EXPECT_EQ(connection->Get(option, key2, valueRead), -E_NOT_FOUND);
1843
1844 /**
1845 * @tc.steps: step5. Set Ioption to the local data and obtain the value data of Key1.
1846 * Check whether the value is the same as the value of value2.
1847 * @tc.expected: step4. Return E_OK, and the value is the same as the value of value2.
1848 */
1849 Value value2;
1850 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, value1.size() + 1);
1851 EXPECT_EQ(connection->Put(option, key1, value2), E_OK);
1852
1853 /**
1854 * @tc.steps: step5. The Ioption is set to the local.
1855 * The data of the key1 and value2(!=value1) is inserted.
1856 * @tc.expected: step4. Return E_OK.
1857 */
1858 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1859 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1860 }
1861
TestMetaDataDeleteByPrefixKey(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)1862 void DistributedDBStorageSingleVerNaturalStoreTestCase::TestMetaDataDeleteByPrefixKey(
1863 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection)
1864 {
1865 /**
1866 * @tc.steps:step1. Put a1, b1, a2, b2.
1867 * @tc.expected: step1. Return OK.
1868 */
1869 ASSERT_EQ(store->PutMetaData(Key {'a', '1'}, Value {'a', '1'}, false), E_OK);
1870 ASSERT_EQ(store->PutMetaData(Key {'b', '1'}, Value {'b', '1'}, false), E_OK);
1871 ASSERT_EQ(store->PutMetaData(Key {'a', '2'}, Value {'a', '2'}, false), E_OK);
1872 ASSERT_EQ(store->PutMetaData(Key {'b', '2'}, Value {'b', '2'}, false), E_OK);
1873
1874 /**
1875 * @tc.steps:step2. Delete meta data with prefix key 'b'.
1876 * @tc.expected: step2. Return OK.
1877 */
1878 ASSERT_EQ(store->DeleteMetaDataByPrefixKey(Key {'b'}), E_OK);
1879 ASSERT_EQ(store->DeleteMetaDataByPrefixKey(Key {'c'}), E_OK);
1880
1881 /**
1882 * @tc.steps:step3. Get a1, b1, a2, b2.
1883 * @tc.expected: step3. Get a1, a2 successfully, and get b1, b2 failed.
1884 */
1885 Value value;
1886 EXPECT_EQ(store->GetMetaData(Key {'a', '1'}, value), E_OK);
1887 EXPECT_EQ(store->GetMetaData(Key {'a', '2'}, value), E_OK);
1888 EXPECT_EQ(store->GetMetaData(Key {'b', '1'}, value), -E_NOT_FOUND);
1889 EXPECT_EQ(store->GetMetaData(Key {'b', '2'}, value), -E_NOT_FOUND);
1890 }