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