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, valueRead2;
519 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead1), E_OK);
520 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead2), E_OK);
521 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead1, dataItem1.value), true);
522 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead2, dataItem2.value), true);
523
524 /**
525 * @tc.steps:step3. Insert a (key3, value3) and delete the data of the (key1, value1).
526 * @tc.expected: step3. The PutSyncData returns OK.
527 */
528 DataItem dataItem3 = dataItem1;
529 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem3.key, 38); // random size
530 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem3.value, 27); // random size
531
532 DataItem dataItem4 = dataItem1;
533 dataItem4.flag = 1;
534 dataItem4.timestamp += 1;
535 dataItem4.writeTimestamp = dataItem4.timestamp;
536 DistributedDBToolsUnitTest::CalcHash(dataItem1.key, dataItem4.key);
537 vect = {dataItem4, dataItem3};
538 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
539
540 /**
541 * @tc.steps:step4. Set Ioption to the synchronization data and obtain the data of key1, key2, and key3.
542 * @tc.expected: step4. Get key1 returns E_NOT_FOUND,Get key2.
543 * The value of OK,value is value2, the value of Get key3 is OK,
544 * and the value of value is value3.
545 */
546 valueRead1.clear();
547 valueRead2.clear();
548 Value valueRead3;
549 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead1), -E_NOT_FOUND);
550 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead2), E_OK);
551 EXPECT_EQ(connection->Get(option, dataItem3.key, valueRead3), E_OK);
552 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead2, dataItem2.value), true);
553 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead3, dataItem3.value), true);
554 }
555
556 /**
557 * @tc.name: PutMetaData001
558 * @tc.desc: Test metadata insertion and modification.
559 * @tc.type: FUNC
560 * @tc.require: AR000CCPOM
561 * @tc.author: wangbingquan
562 */
PutMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)563 void DistributedDBStorageSingleVerNaturalStoreTestCase::PutMetaData001(SQLiteSingleVerNaturalStore *&store,
564 SQLiteSingleVerNaturalStoreConnection *&connection)
565 {
566 TestMetaDataPutAndGet(store, connection);
567 }
568
569 /**
570 * @tc.name: GetMetaData001
571 * @tc.desc: To test the function of reading the metadata of a key in the database.
572 * @tc.type: FUNC
573 * @tc.require: AR000CCPOM
574 * @tc.author: wangbingquan
575 */
GetMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)576 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetMetaData001(SQLiteSingleVerNaturalStore *&store,
577 SQLiteSingleVerNaturalStoreConnection *&connection)
578 {
579 /**
580 * @tc.steps:step1. Use GetMetaData in NaturalStore to obtain the value of key1.
581 * Check whether the value is the same as the value of value1.
582 * @tc.expected: step1. Return OK, and the value is the same as the value of value1.
583 */
584 TestMetaDataPutAndGet(store, connection);
585 }
586
587 /**
588 * @tc.name: DeleteMetaData001
589 * @tc.desc: To test the function of deleting the metadata with prefix key in the database.
590 * @tc.type: FUNC
591 * @tc.require: AR000CCPOM
592 * @tc.author: wangbingquan
593 */
DeleteMetaData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)594 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteMetaData001(SQLiteSingleVerNaturalStore *&store,
595 SQLiteSingleVerNaturalStoreConnection *&connection)
596 {
597 /**
598 * @tc.steps:step1. Put 2 mete data with prefix key 'a', 2 meta data with prefix key 'b'.
599 And delete meta data with prefix key 'b'.
600 * @tc.expected: step1. Get all meta data and will get 2 data with prefix key 'a'.
601 */
602 TestMetaDataDeleteByPrefixKey(store, connection);
603 }
604
605 /**
606 * @tc.name: GetCurrentMaxTimestamp001
607 * @tc.desc: To test the function of obtaining the maximum timestamp when a record exists in the database.
608 * @tc.type: FUNC
609 * @tc.require: AR000CCPOM
610 * @tc.author: wangbingquan
611 */
GetCurrentMaxTimestamp001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)612 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetCurrentMaxTimestamp001(SQLiteSingleVerNaturalStore *&store,
613 SQLiteSingleVerNaturalStoreConnection *&connection)
614 {
615 Key key1;
616 Value value1;
617 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
618 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
619 Timestamp timeBegin = 0;
620 Timestamp timeMiddle = 0;
621 Timestamp timeEnd = 0;
622
623 /**
624 * @tc.steps:step1/2. Insert a data record into the synchronization database.
625 */
626 store->GetMaxTimestamp(timeBegin);
627 IOption option;
628 option.dataType = IOption::SYNC_DATA;
629 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
630
631 /**
632 * @tc.steps:step3. The current maximum timestamp is A.
633 */
634 store->GetMaxTimestamp(timeMiddle);
635 EXPECT_GT(timeMiddle, timeBegin);
636
637 /**
638 * @tc.steps:step4. Insert a data record into the synchronization database.
639 */
640 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
641
642 /**
643 * @tc.steps:step5. Obtain the maximum timestamp B and check whether B>=A exists.
644 * @tc.expected: step5. The obtained timestamp is B>=A.
645 */
646 store->GetMaxTimestamp(timeEnd);
647 EXPECT_GT(timeEnd, timeMiddle);
648 }
649
650 /**
651 * @tc.name: GetCurrentMaxTimestamp002
652 * @tc.desc: Obtain the maximum timestamp when no record exists in the test record library.
653 * @tc.type: FUNC
654 * @tc.require: AR000CCPOM
655 * @tc.author: wangbingquan
656 */
GetCurrentMaxTimestamp002(SQLiteSingleVerNaturalStore * & store)657 void DistributedDBStorageSingleVerNaturalStoreTestCase::GetCurrentMaxTimestamp002(SQLiteSingleVerNaturalStore *&store)
658 {
659 /**
660 * @tc.steps:step1. Obtains the maximum timestamp in the current database record.
661 * @tc.expected: step1. Return timestamp is 0.
662 */
663 Timestamp timestamp = 10; // non-zero
664 store->GetMaxTimestamp(timestamp);
665 EXPECT_EQ(timestamp, 0UL);
666 }
667
668 /**
669 * @tc.name: LocalDatabaseOperate001
670 * @tc.desc: Test the function of inserting data in the local database of the NaturalStore.
671 * @tc.type: FUNC
672 * @tc.require: AR000CCPOM
673 * @tc.author: wangbingquan
674 */
LocalDatabaseOperate001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)675 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate001(SQLiteSingleVerNaturalStore *&store,
676 SQLiteSingleVerNaturalStoreConnection *&connection)
677 {
678 IOption option;
679 option.dataType = IOption::LOCAL_DATA;
680 DataBaseCommonPutOperate(store, connection, option);
681 }
682
683 /**
684 * @tc.name: LocalDatabaseOperate002
685 * @tc.desc: Test the function of deleting data from the local database of the NaturalStore.
686 * @tc.type: FUNC
687 * @tc.require: AR000CCPOM
688 * @tc.author: wangbingquan
689 */
LocalDatabaseOperate002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)690 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate002(SQLiteSingleVerNaturalStore *&store,
691 SQLiteSingleVerNaturalStoreConnection *&connection)
692 {
693 IOption option;
694 option.dataType = IOption::LOCAL_DATA;
695 DataBaseCommonDeleteOperate(store, connection, option);
696 }
697
698 /**
699 * @tc.name: LocalDatabaseOperate003
700 * @tc.desc: To test the function of reading data from the local database of the NaturalStore.
701 * @tc.type: FUNC
702 * @tc.require: AR000CCPOM
703 * @tc.author: wangbingquan
704 */
LocalDatabaseOperate003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)705 void DistributedDBStorageSingleVerNaturalStoreTestCase::LocalDatabaseOperate003(SQLiteSingleVerNaturalStore *&store,
706 SQLiteSingleVerNaturalStoreConnection *&connection)
707 {
708 IOption option;
709 option.dataType = IOption::LOCAL_DATA;
710 DataBaseCommonGetOperate(store, connection, option);
711 }
712
713 /**
714 * @tc.name: SyncDatabaseOperate001
715 * @tc.desc: To test the function of inserting data of the local device in the synchronization database.
716 * @tc.type: FUNC
717 * @tc.require: AR000CCPOM
718 * @tc.author: wangbingquan
719 */
SyncDatabaseOperate001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)720 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate001(SQLiteSingleVerNaturalStore *&store,
721 SQLiteSingleVerNaturalStoreConnection *&connection)
722 {
723 IOption option;
724 option.dataType = IOption::SYNC_DATA;
725 DataBaseCommonPutOperate(store, connection, option);
726 }
727
728 /**
729 * @tc.name: SyncDatabaseOperate002
730 * @tc.desc: test the put operation after data synced from other devices.
731 * @tc.type: FUNC
732 * @tc.require: AR000CCPOM
733 * @tc.author: wangbingquan
734 */
SyncDatabaseOperate002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)735 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate002(SQLiteSingleVerNaturalStore *&store,
736 SQLiteSingleVerNaturalStoreConnection *&connection)
737 {
738 IOption option;
739 option.dataType = IOption::SYNC_DATA;
740 DataItem dataItem1;
741 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
742 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
743 dataItem1.timestamp = 1001; // 1001 as random timestamp
744 dataItem1.writeTimestamp = dataItem1.timestamp;
745 dataItem1.flag = 0;
746
747 /**
748 * @tc.steps: step1/2. Add a remote synchronization data record. (key1, value1).
749 */
750 std::vector<DataItem> vect = {dataItem1};
751 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
752
753 /**
754 * @tc.steps: step3. Ioption is set to synchronous data. Obtains the value data of the key1.
755 * @tc.expected: step3. Return OK. The value is the same as the value of value1.
756 */
757 Value valueRead;
758 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
759 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
760
761 Value value2;
762 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, dataItem1.value.size() + 1);
763
764 /**
765 * @tc.steps: step4. Ioption Set the data to be synchronized and insert the data of key1,value2.
766 * @tc.expected: step4. Return OK.
767 */
768 EXPECT_EQ(connection->Put(option, dataItem1.key, value2), E_OK);
769 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
770
771 /**
772 * @tc.steps: step3. Ioption is set to synchronous data. Obtains the value data of the key1.
773 * @tc.expected: step3. Return OK. The value is the same as the value of value2.
774 */
775 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
776 }
777
778 /**
779 * @tc.name: SyncDatabaseOperate003
780 * @tc.desc: test the delete operation in sync database.
781 * @tc.type: FUNC
782 * @tc.require: AR000CCPOM
783 * @tc.author: wangbingquan
784 */
SyncDatabaseOperate003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)785 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate003(SQLiteSingleVerNaturalStore *&store,
786 SQLiteSingleVerNaturalStoreConnection *&connection)
787 {
788 IOption option;
789 option.dataType = IOption::SYNC_DATA;
790 DataBaseCommonDeleteOperate(store, connection, option);
791 }
792
793 /**
794 * @tc.name: SyncDatabaseOperate004
795 * @tc.desc: test the delete for the data from other devices in sync database.
796 * @tc.type: FUNC
797 * @tc.require: AR000CCPOM
798 * @tc.author: wangbingquan
799 */
SyncDatabaseOperate004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)800 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate004(SQLiteSingleVerNaturalStore *&store,
801 SQLiteSingleVerNaturalStoreConnection *&connection)
802 {
803 IOption option;
804 option.dataType = IOption::SYNC_DATA;
805 DataItem dataItem1;
806 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
807 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
808 dataItem1.timestamp = 1997; // 1997 as random timestamp
809 dataItem1.writeTimestamp = dataItem1.timestamp;
810 dataItem1.flag = 0;
811
812 std::vector<DataItem> vect = {dataItem1};
813 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
814
815 /**
816 * @tc.steps: step2. The Ioption parameter is set to synchronize data to obtain the value data of the key1.
817 * @tc.expected: step2. Return OK. The value is the same as the value of value1.
818 */
819 Value valueRead;
820 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
821 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
822
823 Key key2;
824 DistributedDBToolsUnitTest::GetRandomKeyValue(key2);
825 EXPECT_EQ(connection->Delete(option, key2), E_OK);
826
827 /**
828 * @tc.steps: step3. The Ioption parameter is set to synchronize data, and the key1 data is deleted.
829 * @tc.expected: step3. Return OK.
830 */
831 EXPECT_EQ(connection->Delete(option, dataItem1.key), E_OK);
832
833 /**
834 * @tc.steps: step4. The Ioption parameter is set to synchronize data to obtain the value data of the key1.
835 * @tc.expected: step4. Return E_NOT_FOUND.
836 */
837 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), -E_NOT_FOUND);
838 }
839
840 /**
841 * @tc.name: SyncDatabaseOperate005
842 * @tc.desc: test the reading for sync database.
843 * @tc.type: FUNC
844 * @tc.require: AR000CCPOM
845 * @tc.author: wangbingquan
846 */
SyncDatabaseOperate005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)847 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate005(SQLiteSingleVerNaturalStore *&store,
848 SQLiteSingleVerNaturalStoreConnection *&connection)
849 {
850 IOption option;
851 option.dataType = IOption::SYNC_DATA;
852 DataBaseCommonGetOperate(store, connection, option);
853 }
854
855 /**
856 * @tc.name: SyncDatabaseOperate006
857 * @tc.desc: test the get entries for sync database
858 * @tc.type: FUNC
859 * @tc.require: AR000CCPOM
860 * @tc.author: wangbingquan
861 */
SyncDatabaseOperate006(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)862 void DistributedDBStorageSingleVerNaturalStoreTestCase::SyncDatabaseOperate006(SQLiteSingleVerNaturalStore *&store,
863 SQLiteSingleVerNaturalStoreConnection *&connection)
864 {
865 IOption option;
866 option.dataType = IOption::SYNC_DATA;
867 Key key1, key2, key3;
868 Value value1, value2, value3;
869
870 /**
871 * @tc.steps: step2/3/4. Set Ioption to synchronous data.
872 * Insert the data of key=keyPrefix + 'a', value1.
873 * Insert the data of key=keyPrefix + 'c', value2.
874 * Insert the data of key length=keyPrefix length - 1, value3.
875 * @tc.expected: step2/3/4. Return E_NOT_FOUND.
876 */
877 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, 30); // 30 as random size
878 key3 = key2 = key1;
879 key2.push_back('C');
880 key3.pop_back();
881 DistributedDBToolsUnitTest::GetRandomKeyValue(value1, 84); // 84 as random size
882 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, 101); // 101 as random size
883 DistributedDBToolsUnitTest::GetRandomKeyValue(value3, 37); // 37 as random size
884 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
885 EXPECT_EQ(connection->Put(option, key2, value2), E_OK);
886 EXPECT_EQ(connection->Put(option, key3, value3), E_OK);
887
888 /**
889 * @tc.steps: step5. Obtain all data whose prefixKey is keyPrefix.
890 * @tc.expected: step5. Return OK. The number of obtained data records is 2.
891 */
892 std::vector<Entry> entriesRead;
893 EXPECT_EQ(connection->GetEntries(option, key1, entriesRead), E_OK);
894 EXPECT_EQ(entriesRead.size(), 2UL);
895
896 /**
897 * @tc.steps: step6. Obtain all data whose prefixKey is empty.
898 * @tc.expected: step6. Return OK. The number of obtained data records is 3.
899 */
900 entriesRead.clear();
901 Key emptyKey;
902 EXPECT_EQ(connection->GetEntries(option, emptyKey, entriesRead), E_OK);
903 EXPECT_EQ(entriesRead.size(), 3UL);
904
905 /**
906 * @tc.steps: step7. Obtain all data whose prefixKey is keyPrefix.
907 * @tc.expected: step7. Return E_NOT_SUPPORT.
908 */
909 option.dataType = IOption::LOCAL_DATA;
910 EXPECT_EQ(connection->GetEntries(option, emptyKey, entriesRead), -E_NOT_FOUND);
911 }
912
913 /**
914 * @tc.name: ClearRemoteData001
915 * @tc.desc: test the clear data synced from the remote by device.
916 * @tc.type: FUNC
917 * @tc.require: AR000CIFDA AR000CQS3T
918 * @tc.author: wangbingquan
919 */
ClearRemoteData001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)920 void DistributedDBStorageSingleVerNaturalStoreTestCase::ClearRemoteData001(SQLiteSingleVerNaturalStore *&store,
921 SQLiteSingleVerNaturalStoreConnection *&connection)
922 {
923 IOption option;
924 option.dataType = IOption::SYNC_DATA;
925 DataItem dataItem1;
926 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.key);
927 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem1.value);
928 dataItem1.timestamp = 1997; // 1997 as random timestamp
929 dataItem1.writeTimestamp = dataItem1.timestamp;
930 dataItem1.flag = 0;
931
932 DataItem dataItem2;
933 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.key, dataItem1.key.size() + 1);
934 DistributedDBToolsUnitTest::GetRandomKeyValue(dataItem2.value);
935 dataItem2.timestamp = 2019; // 2019 as random timestamp
936 dataItem2.writeTimestamp = dataItem2.timestamp;
937 dataItem2.flag = 0;
938
939 /**
940 * @tc.steps: step1. New data is inserted to the B end of the device. [keyB, valueB].
941 */
942 std::vector<DataItem> vect = {dataItem1};
943 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceA"), E_OK);
944
945 /**
946 * @tc.steps: step2. The device pulls the data of the device B, and the device inserts the [keyA, valueA].
947 */
948 vect.clear();
949 vect.push_back(dataItem2);
950 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
951
952 /**
953 * @tc.steps: step3. The device obtains the data of keyA and valueB.
954 * @tc.expected: step3. Obtain [keyA, valueA] and [keyB, valueB].
955 */
956 Value valueRead;
957 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), E_OK);
958 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem1.value), true);
959 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), E_OK);
960 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem2.value), true);
961
962 /**
963 * @tc.steps: step4.Invoke the interface for clearing the synchronization data of the B device.
964 */
965 if (RuntimeContext::GetInstance()->IsCommunicatorAggregatorValid()) {
966 return;
967 }
968 EXPECT_EQ(store->RemoveDeviceData("deviceA", false), E_OK);
969
970 /**
971 * @tc.steps: step5. The device obtains the data of keyA and valueB.
972 * @tc.expected: step5. The value of [keyA, valueA] is obtained,
973 * and the value of NOT_FOUND is obtained by querying keyB.
974 */
975 EXPECT_EQ(connection->Get(option, dataItem1.key, valueRead), -E_NOT_FOUND);
976 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), E_OK);
977 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, dataItem2.value), true);
978
979 EXPECT_EQ(store->RemoveDeviceData("deviceB", false), E_OK);
980 EXPECT_EQ(connection->Get(option, dataItem2.key, valueRead), -E_NOT_FOUND);
981 }
982
983 /**
984 * @tc.name: DeleteUserKeyValue001
985 * @tc.desc: When a user deletes a data record, the system clears the user record.
986 * @tc.type: FUNC
987 * @tc.require: AR000CKRTC AR000CQE0D
988 * @tc.author: sunpeng
989 */
DeleteUserKeyValue001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)990 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue001(SQLiteSingleVerNaturalStore *&store,
991 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
992 {
993 // StoreID::TestGeneralNB
994 IOption option;
995 option.dataType = IOption::SYNC_DATA;
996
997 // per-set data
998 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
999 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1000
1001 /**
1002 * @tc.steps: step1. delete K1.
1003 * @tc.expected: step1. delete K1 successfully.
1004 */
1005 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1006
1007 // Close database
1008 connection->Close();
1009 connection = nullptr;
1010 store = nullptr;
1011
1012 /**
1013 * @tc.steps: step2. Real query by sqlite3.
1014 * @tc.expected: step2. Find KEY_1, not find K2.
1015 */
1016 std::vector<SyncData> vecSyncData;
1017 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1018
1019 bool isFound = false;
1020 EXPECT_EQ(numSelect, 2); // 2 as entry size
1021 isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1022 EXPECT_EQ(isFound, false);
1023 isFound = IsSqlinteExistKey(vecSyncData, KEY_2);
1024 EXPECT_EQ(isFound, true);
1025 }
1026
1027 /**
1028 * @tc.name: MemoryDbDeleteUserKeyValue001
1029 * @tc.desc: When a user deletes a data record, the system clears the user record.
1030 * @tc.type: FUNC
1031 * @tc.require: AR000CKRTC AR000CQE0D
1032 * @tc.author: sunpeng
1033 */
MemoryDbDeleteUserKeyValue001(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1034 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue001(
1035 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1036 {
1037 // StoreID::TestGeneralNB
1038 IOption option;
1039 option.dataType = IOption::SYNC_DATA;
1040
1041 // per-set data
1042 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1043 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1044
1045 /**
1046 * @tc.steps: step1. delete K1.
1047 * @tc.expected: step1. delete K1 successfully.
1048 */
1049 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1050
1051 /**
1052 * @tc.steps: step3. Real query by sqlite3.
1053 * @tc.expected: step3. Find KEY_1, not find K2.
1054 */
1055 std::vector<SyncData> vecSyncData;
1056 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1057
1058 bool isFound = false;
1059 EXPECT_EQ(numSelect, 2); // 2 as entry size
1060 isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1061 EXPECT_EQ(isFound, false);
1062 isFound = IsSqlinteExistKey(vecSyncData, KEY_2);
1063 EXPECT_EQ(isFound, true);
1064
1065 // Close database
1066 connection->Close();
1067 connection = nullptr;
1068 store = nullptr;
1069 }
1070
1071 /**
1072 * @tc.name: DeleteUserKeyValue002
1073 * @tc.desc: After the synchronization library data is deleted locally, add the same key data locally.
1074 * @tc.type: FUNC
1075 * @tc.require: AR000CKRTC AR000CQE0D
1076 * @tc.author: sunpeng
1077 */
DeleteUserKeyValue002(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1078 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue002(SQLiteSingleVerNaturalStore *&store,
1079 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1080 {
1081 IOption option;
1082 option.dataType = IOption::SYNC_DATA;
1083
1084 // pre-set data
1085 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1086 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1087
1088 /**
1089 * @tc.steps: step1. Delete key1 data via Delete interface.
1090 * @tc.expected: step1. Delete successfully.
1091 */
1092 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1093
1094 /**
1095 * @tc.steps: step2. New data from key1, value3 via Put interface.
1096 * @tc.expected: step2. New data from key1, value3 via Put interface successfully.
1097 */
1098 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_3), E_OK);
1099
1100 /**
1101 * @tc.steps: step3. Query key1 data via Get interface.
1102 * @tc.expected: step3. Query key1 data via Get interface successfully, get value3 by key1.
1103 */
1104 Value valueRead;
1105 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1106 EXPECT_EQ(valueRead, VALUE_3);
1107
1108 /**
1109 * @tc.steps: step4. Query key1 real data by sqlite3.
1110 * @tc.expected: step4. Two records were found.
1111 */
1112 std::vector<SyncData> vecSyncData;
1113 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1114
1115 EXPECT_EQ(numSelect, 2); // 2 as entry size
1116 }
1117
1118 /**
1119 * @tc.name: DeleteUserKeyValue003
1120 * @tc.desc: After the synchronization database data is deleted locally, the same key data is added from the remote end.
1121 * @tc.type: FUNC
1122 * @tc.require: AR000CKRTC AR000CQE0D
1123 * @tc.author: sunpeng
1124 */
DeleteUserKeyValue003(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1125 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue003(SQLiteSingleVerNaturalStore *&store,
1126 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1127 {
1128 IOption option;
1129 option.dataType = IOption::SYNC_DATA;
1130
1131 // ready data
1132 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1133
1134 /**
1135 * @tc.steps: step1. Delete data by key1.
1136 * @tc.expected: step1. Delete successfully.
1137 */
1138 EXPECT_EQ(connection->Delete(option, KEY_1), E_OK);
1139
1140 /**
1141 * @tc.steps: step2. Get data by key1.
1142 * @tc.expected: step1. Key1 not exist in database.
1143 */
1144 Value valueRead;
1145 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1146
1147 Timestamp timestamp = 0;
1148 store->GetMaxTimestamp(timestamp);
1149
1150 DataItem dataItem1;
1151 dataItem1.key = KV_ENTRY_1.key;
1152 dataItem1.value = KV_ENTRY_3.value;
1153 dataItem1.timestamp = timestamp - 100UL; // less than current timestamp
1154 dataItem1.writeTimestamp = dataItem1.timestamp;
1155 dataItem1.flag = 0;
1156
1157 DataItem dataItem2;
1158 dataItem2.key = KV_ENTRY_1.key;
1159 dataItem2.value = KV_ENTRY_4.value;
1160 dataItem2.timestamp = timestamp + 100UL; // bigger than current timestamp
1161 dataItem2.writeTimestamp = dataItem2.timestamp;
1162 dataItem2.flag = 0;
1163 std::vector<DataItem> vect = {dataItem1};
1164
1165 /**
1166 * @tc.steps: step3. Get a new data from remote device B , key1, value3,
1167 * with a smaller timestamp than the current timestamp.
1168 */
1169 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1170
1171 /**
1172 * @tc.steps: step4. Get data by key1.
1173 * @tc.expected: step4. Key1 not exist in database.
1174 */
1175 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1176
1177 /**
1178 * @tc.steps: step5. Get a new data from remote device C , key1, value4,
1179 * and the timestamp is larger than the current timestamp.
1180 */
1181 vect.clear();
1182 vect.push_back(dataItem2);
1183 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceC"), E_OK);
1184
1185 /**
1186 * @tc.steps: step6. Get data by key1.
1187 * @tc.expected: step6. Key1 not exist in database.
1188 */
1189 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1190
1191 /**
1192 * @tc.steps: step7. Get real data by key1.
1193 * @tc.expected: step7. Get 1 record.
1194 */
1195 std::vector<SyncData> vecSyncData;
1196 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1197
1198 EXPECT_EQ(numSelect, 1);
1199 }
1200
1201 /**
1202 * @tc.name: DeleteUserKeyValue004
1203 * @tc.desc: Changes in key after remote delete data syncs to local
1204 * @tc.type: FUNC
1205 * @tc.require: AR000CKRTC AR000CQE0D
1206 * @tc.author: sunpeng
1207 */
DeleteUserKeyValue004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1208 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue004(SQLiteSingleVerNaturalStore *&store,
1209 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1210 {
1211 // pre-set data
1212 IOption option;
1213 option.dataType = IOption::SYNC_DATA;
1214 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1215
1216 DataItem dataItem1;
1217 dataItem1.key = KV_ENTRY_1.key;
1218 dataItem1.value = KV_ENTRY_1.value;
1219 store->GetMaxTimestamp(dataItem1.timestamp);
1220 dataItem1.flag = 1;
1221 dataItem1.timestamp += 1;
1222 dataItem1.writeTimestamp = dataItem1.timestamp;
1223 /**
1224 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1225 * pull the action of key1 to local.
1226 */
1227 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1228 std::vector<DataItem> vect = {dataItem1};
1229 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1230
1231 /**
1232 * @tc.steps: step4. Close database.
1233 */
1234 connection->Close();
1235 connection = nullptr;
1236 store = nullptr;
1237
1238 /**
1239 * @tc.steps: step5 6. Get real data by key1;and get the number of records.
1240 * @tc.expected: step5 6. Not exist key1 real data in database;Get 1 record.
1241 */
1242 std::vector<SyncData> vecSyncData;
1243 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1244
1245 EXPECT_EQ(numSelect, 1);
1246 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1247 EXPECT_EQ(isFound, false);
1248 }
1249
1250 /**
1251 * @tc.name: MemoryDbDeleteUserKeyValue004
1252 * @tc.desc: Changes in key after remote delete data syncs to local
1253 * @tc.type: FUNC
1254 * @tc.require: AR000CKRTC AR000CQE0D
1255 * @tc.author: sunpeng
1256 */
MemoryDbDeleteUserKeyValue004(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1257 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue004(
1258 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1259 {
1260 // pre-set data
1261 IOption option;
1262 option.dataType = IOption::SYNC_DATA;
1263 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1264
1265 DataItem dataItem1;
1266 dataItem1.key = KV_ENTRY_1.key;
1267 dataItem1.value = KV_ENTRY_1.value;
1268 store->GetMaxTimestamp(dataItem1.timestamp);
1269 dataItem1.flag = 1;
1270 dataItem1.timestamp += 1;
1271 dataItem1.writeTimestamp = dataItem1.timestamp;
1272 /**
1273 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1274 * pull the action of key1 to local.
1275 */
1276 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1277 std::vector<DataItem> vect = {dataItem1};
1278 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1279
1280 /**
1281 * @tc.steps: step4 5. Get real data by key1;and get the number of records.
1282 * @tc.expected: step 4 5. Not exist key1 real data in database;Get 1 record.
1283 */
1284 std::vector<SyncData> vecSyncData;
1285 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1286
1287 EXPECT_EQ(numSelect, 1);
1288 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1289 EXPECT_EQ(isFound, false);
1290
1291 connection->Close();
1292 connection = nullptr;
1293 store = nullptr;
1294 }
1295
1296 /**
1297 * @tc.name: DeleteUserKeyValue005
1298 * @tc.desc: New unified key data locally after remote delete data syncs to local
1299 * @tc.type: FUNC
1300 * @tc.require: AR000CKRTC AR000CQE0D
1301 * @tc.author: sunpeng
1302 */
DeleteUserKeyValue005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1303 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue005(SQLiteSingleVerNaturalStore *&store,
1304 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1305 {
1306 // pre-set data
1307 IOption option;
1308 option.dataType = IOption::SYNC_DATA;
1309 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1310 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1311
1312 DataItem dataItem1;
1313 dataItem1.key = KV_ENTRY_1.key;
1314 dataItem1.value = KV_ENTRY_1.value;
1315 store->GetMaxTimestamp(dataItem1.timestamp);
1316 dataItem1.timestamp = dataItem1.timestamp + 10UL;
1317 dataItem1.writeTimestamp = dataItem1.timestamp;
1318 dataItem1.flag = 1;
1319
1320 /**
1321 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1322 * pull the action of key1 to local.
1323 */
1324 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1325 std::vector<DataItem> vect = {dataItem1};
1326 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1327
1328 /**
1329 * @tc.steps: step4. Put K1 V1 to database.
1330 * @tc.expected: step4. Put successfully.
1331 */
1332 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1333
1334 /**
1335 * @tc.steps: step5. Close database.
1336 */
1337 connection->Close();
1338 connection = nullptr;
1339 store = nullptr;
1340
1341 /**
1342 * @tc.steps: step6 7. Get real data by key1;and get the number of records.
1343 * @tc.expected: step6 7. Not exist key1 real data in database;Get 2 record.
1344 */
1345 std::vector<SyncData> vecSyncData;
1346 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1347
1348 EXPECT_EQ(numSelect, 2); // 2 as entry size
1349 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1350 EXPECT_EQ(isFound, true);
1351 }
1352
1353 /**
1354 * @tc.name: MemoryDbDeleteUserKeyValue005
1355 * @tc.desc: New unified key data locally after remote delete data syncs to local
1356 * @tc.type: FUNC
1357 * @tc.require: AR000CKRTC AR000CQE0D
1358 * @tc.author: sunpeng
1359 */
MemoryDbDeleteUserKeyValue005(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1360 void DistributedDBStorageSingleVerNaturalStoreTestCase::MemoryDbDeleteUserKeyValue005(
1361 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1362 {
1363 // pre-set data
1364 IOption option;
1365 option.dataType = IOption::SYNC_DATA;
1366 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1367 EXPECT_EQ(connection->Put(option, KEY_2, VALUE_2), E_OK);
1368
1369 DataItem dataItem1;
1370 dataItem1.key = KV_ENTRY_1.key;
1371 dataItem1.value = KV_ENTRY_1.value;
1372 store->GetMaxTimestamp(dataItem1.timestamp);
1373 dataItem1.timestamp = TimeHelper::GetSysCurrentTime();
1374 dataItem1.writeTimestamp = dataItem1.timestamp;
1375 dataItem1.flag = 1;
1376
1377 /**
1378 * @tc.steps: step1 2 3. Synchronize data to another device B; delete key1 data from device B;
1379 * pull the action of key1 to local.
1380 */
1381 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1382 std::vector<DataItem> vect = {dataItem1};
1383 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1384
1385 /**
1386 * @tc.steps: step4. Put K1 V1 to database.
1387 * @tc.expected: step4. Put successfully.
1388 */
1389 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1390
1391 /**
1392 * @tc.steps: step5 6. Get real data by key1;and get the number of records.
1393 * @tc.expected: step5 6. Not exist key1 real data in database;Get 2 record.
1394 */
1395 std::vector<SyncData> vecSyncData;
1396 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1397
1398 EXPECT_EQ(numSelect, 2); // 2 as entry size
1399 bool isFound = IsSqlinteExistKey(vecSyncData, KEY_1);
1400 EXPECT_EQ(isFound, true);
1401
1402 connection->Close();
1403 connection = nullptr;
1404 store = nullptr;
1405 }
1406
1407 /**
1408 * @tc.name: DeleteUserKeyValue006
1409 * @tc.desc: After the remote delete data is synced to the local,
1410 * the same key data is added from the remote other devices
1411 * @tc.type: FUNC
1412 * @tc.require: AR000CKRTC AR000CQE0D
1413 * @tc.author: sunpeng
1414 */
DeleteUserKeyValue006(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,const std::string & url)1415 void DistributedDBStorageSingleVerNaturalStoreTestCase::DeleteUserKeyValue006(SQLiteSingleVerNaturalStore *&store,
1416 SQLiteSingleVerNaturalStoreConnection *&connection, const std::string &url)
1417 {
1418 // pre-set data
1419 IOption option;
1420 option.dataType = IOption::SYNC_DATA;
1421 EXPECT_EQ(connection->Put(option, KEY_1, VALUE_1), E_OK);
1422
1423 DataItem dataItem1;
1424 dataItem1.key = KV_ENTRY_1.key;
1425 dataItem1.value = KV_ENTRY_1.value;
1426 store->GetMaxTimestamp(dataItem1.timestamp);
1427 dataItem1.timestamp = dataItem1.timestamp + 10UL;
1428 dataItem1.writeTimestamp = dataItem1.timestamp;
1429 dataItem1.flag = 1;
1430
1431 /**
1432 * @tc.steps: step1. Remote device B sync deletes data key1 and pushes to local.
1433 */
1434 DistributedDBToolsUnitTest::CalcHash(KV_ENTRY_1.key, dataItem1.key);
1435 std::vector<DataItem> vect = {dataItem1};
1436 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceB"), E_OK);
1437
1438 /**
1439 * @tc.steps: step2. Get key1 from database.
1440 * @tc.expected: step2. Not exist key1.
1441 */
1442 Value valueRead;
1443 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1444
1445 dataItem1.key = KV_ENTRY_1.key;
1446 dataItem1.flag = 0;
1447 dataItem1.value = KV_ENTRY_2.value;
1448 dataItem1.timestamp = dataItem1.timestamp - 100UL; // less than current timestamp
1449 dataItem1.writeTimestamp = dataItem1.timestamp;
1450 /**
1451 * @tc.steps: step3. Remote device C syncs new data (key1, value2),
1452 * timestamp is less than delete timestamp, to local.
1453 */
1454 vect = {dataItem1};
1455 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceC"), E_OK);
1456
1457 /**
1458 * @tc.steps: step4. Get key1 from database.
1459 * @tc.expected: step4. Not exist key1.
1460 */
1461 EXPECT_NE(connection->Get(option, KEY_1, valueRead), E_OK);
1462
1463 dataItem1.value = KV_ENTRY_3.value;
1464 dataItem1.timestamp = dataItem1.timestamp + 200UL; // bigger than current timestamp
1465 dataItem1.writeTimestamp = dataItem1.timestamp;
1466 /**
1467 * @tc.steps: step5. Remote device C syncs new data (key1, value2),
1468 * timestamp is bigger than delete timestamp, to local.
1469 */
1470 vect = {dataItem1};
1471 EXPECT_EQ(DistributedDBToolsUnitTest::PutSyncDataTest(store, vect, "deviceD"), E_OK);
1472
1473 /**
1474 * @tc.steps: step6. Get key1 from database.
1475 * @tc.expected: step6. Exist key1.
1476 */
1477 EXPECT_EQ(connection->Get(option, KEY_1, valueRead), E_OK);
1478 EXPECT_EQ(valueRead, VALUE_3);
1479
1480 /**
1481 * @tc.steps: step7. Get real data from database.
1482 * @tc.expected: step7. Get 1 record.
1483 */
1484 std::vector<SyncData> vecSyncData;
1485 int numSelect = GetRawSyncData(url, SYNC_DATA_DEFAULT_SQL, vecSyncData);
1486
1487 EXPECT_EQ(numSelect, 1);
1488 }
1489
1490 // param [in] dbName:Database name,strSql: The sql statement executed,[out],vecSyncData:SYNC_DATA table data
1491 // 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)1492 int DistributedDBStorageSingleVerNaturalStoreTestCase::GetRawSyncData(const std::string &dbName,
1493 const std::string &strSql, std::vector<SyncData> &vecSyncData)
1494 {
1495 uint64_t flag = SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE;
1496 flag |= SQLITE_OPEN_CREATE;
1497
1498 sqlite3* db = nullptr;
1499 int nResult = sqlite3_open_v2(dbName.c_str(), &db, flag, nullptr);
1500 if (nResult != SQLITE_OK) {
1501 return -nResult;
1502 }
1503
1504 sqlite3_stmt *statement = nullptr;
1505
1506 nResult = sqlite3_prepare(db, strSql.c_str(), -1, &statement, NULL);
1507 if (nResult != SQLITE_OK) {
1508 (void)sqlite3_close_v2(db);
1509 return -1;
1510 }
1511
1512 while (sqlite3_step(statement) == SQLITE_ROW) {
1513 SyncData stuSyncData;
1514 const uint8_t *blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_KEY_INDEX));
1515 int valueLength = sqlite3_column_bytes(statement, SYNC_RES_KEY_INDEX);
1516 if (blobValue == nullptr) {
1517 stuSyncData.key.clear();
1518 } else {
1519 stuSyncData.key.resize(valueLength);
1520 stuSyncData.key.assign(blobValue, blobValue + valueLength);
1521 }
1522
1523 blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_HASH_KEY_INDEX));
1524 valueLength = sqlite3_column_bytes(statement, SYNC_RES_HASH_KEY_INDEX);
1525 stuSyncData.hashKey.resize(valueLength);
1526 stuSyncData.hashKey.assign(blobValue, blobValue + valueLength);
1527
1528 blobValue = static_cast<const uint8_t *>(sqlite3_column_blob(statement, SYNC_RES_VAL_INDEX));
1529 valueLength = sqlite3_column_bytes(statement, SYNC_RES_VAL_INDEX);
1530 if (blobValue == nullptr) {
1531 stuSyncData.value.clear();
1532 } else {
1533 stuSyncData.value.resize(valueLength);
1534 stuSyncData.value.assign(blobValue, blobValue + valueLength);
1535 }
1536
1537 stuSyncData.timestamp = static_cast<uint64_t>(sqlite3_column_int64(statement, SYNC_RES_TIME_INDEX));
1538 stuSyncData.flag = sqlite3_column_int64(statement, SYNC_RES_FLAG_INDEX);
1539 vecSyncData.push_back(stuSyncData);
1540 }
1541
1542 sqlite3_finalize(statement);
1543 statement = nullptr;
1544 (void)sqlite3_close_v2(db);
1545 return static_cast<int>(vecSyncData.size());
1546 }
1547
1548 // @Real query sync-DATA table by key, judge is exist.
IsSqlinteExistKey(const std::vector<SyncData> & vecSyncData,const std::vector<uint8_t> & key)1549 bool DistributedDBStorageSingleVerNaturalStoreTestCase::IsSqlinteExistKey(const std::vector<SyncData> &vecSyncData,
1550 const std::vector<uint8_t> &key)
1551 {
1552 for (const auto &iter : vecSyncData) {
1553 if (key == iter.key) {
1554 return true;
1555 }
1556 }
1557 return false;
1558 }
1559
TestMetaDataPutAndGet(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)1560 void DistributedDBStorageSingleVerNaturalStoreTestCase::TestMetaDataPutAndGet(SQLiteSingleVerNaturalStore *&store,
1561 SQLiteSingleVerNaturalStoreConnection *&connection)
1562 {
1563 Key key1;
1564 Value value1;
1565 Key emptyKey;
1566 Value emptyValue;
1567 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1568 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1569
1570 /**
1571 * @tc.steps:step1. Run the PutMetaData command to insert a non-empty key1 non-empty value1 data record.
1572 * @tc.expected: step1. Return OK.
1573 */
1574 EXPECT_EQ(store->PutMetaData(key1, value1), E_OK);
1575
1576 /**
1577 * @tc.steps:step2. Run the PutMetaData command to insert a non-empty key1 non-empty value1 data record.
1578 * @tc.expected: step2. The obtained value is the same as the value of value1.
1579 */
1580 Value valueRead;
1581 EXPECT_EQ(store->GetMetaData(key1, valueRead), E_OK);
1582 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1583 Value value2;
1584 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, static_cast<int>(value1.size() + 3)); // 3 as random size
1585
1586 /**
1587 * @tc.steps:step3. The key value is key1, the value is not empty,
1588 * and the value of value2 is different from the value of value1 through the PutMetaData interface.
1589 * @tc.expected: step3. Return OK.
1590 */
1591 EXPECT_EQ(store->PutMetaData(key1, value2), E_OK);
1592
1593 /**
1594 * @tc.steps:step4. Run the GetMetaData command to obtain the value of key1
1595 * and check whether the value is the same as the value of value2.
1596 * @tc.expected: step4. The obtained value is the same as the value of value2.
1597 */
1598 EXPECT_EQ(store->GetMetaData(key1, valueRead), E_OK);
1599 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1600
1601 /**
1602 * @tc.steps:step5. Use PutMetaData to insert a record whose key is empty and value is not empty.
1603 * @tc.expected: step5. Return E_INVALID_ARGS.
1604 */
1605 EXPECT_EQ(store->PutMetaData(emptyKey, value1), -E_INVALID_ARGS);
1606
1607 /**
1608 * @tc.steps:step6. Use PutMetaData in NaturalStore to insert data whose key2(!=key1)
1609 * is not empty and value is empty.
1610 * @tc.expected: step6. Return OK.
1611 */
1612 Key key2;
1613 DistributedDBToolsUnitTest::GetRandomKeyValue(key2, static_cast<int>(key1.size() + 1));
1614 EXPECT_EQ(store->PutMetaData(key2, emptyValue), E_OK);
1615
1616 /**
1617 * @tc.steps:step7. Obtain the value of key2 and check whether the value is empty.
1618 * @tc.expected: step7. The obtained value is empty.
1619 */
1620 EXPECT_EQ(store->GetMetaData(key2, valueRead), E_OK);
1621 EXPECT_EQ(valueRead.empty(), true);
1622
1623 /**
1624 * @tc.steps:step8. Insert the data whose key size is 1024 and value size is 4Mb
1625 * through PutMetaData of NaturalStore.
1626 * @tc.expected: step8. Return OK.
1627 */
1628 Key sizeKey;
1629 Value sizeValue;
1630 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeKey, MAX_TEST_KEY_SIZE);
1631 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeValue, MAX_TEST_VAL_SIZE);
1632 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue), E_OK);
1633 EXPECT_EQ(store->GetMetaData(sizeKey, valueRead), E_OK);
1634 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, sizeValue), true);
1635
1636 /**
1637 * @tc.steps:step9/10. Insert data items whose key size is greater than 1 kb
1638 * or value size greater than 4Mb through PutMetaData of NaturalStore.
1639 * @tc.expected: step9/10. Return E_INVALID_ARGS.
1640 */
1641 sizeKey.push_back(249); // 249 as random size
1642 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue), -E_INVALID_ARGS);
1643 sizeKey.pop_back();
1644 sizeValue.push_back(174); // 174 as random size
1645 EXPECT_EQ(store->PutMetaData(sizeKey, sizeValue), -E_INVALID_ARGS);
1646
1647 /**
1648 * @tc.steps:step11. Delete key1 and key2 successfully.
1649 * @tc.expected: step11. Cannot find key1 and key2 in DB anymore.
1650 */
1651 EXPECT_EQ(store->DeleteMetaData(std::vector<Key> {key1, key2}), E_OK);
1652 EXPECT_EQ(store->GetMetaData(key1, valueRead), -E_NOT_FOUND);
1653 EXPECT_EQ(store->GetMetaData(key2, valueRead), -E_NOT_FOUND);
1654 }
1655
DataBaseCommonPutOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1656 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonPutOperate(SQLiteSingleVerNaturalStore *&store,
1657 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1658 {
1659 Key key1;
1660 Value value1;
1661
1662 /**
1663 * @tc.steps: step1/2. Set Ioption to the local data and insert a record of key1 and value1.
1664 * @tc.expected: step1/2. Return OK.
1665 */
1666 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1667 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1668 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1669
1670 /**
1671 * @tc.steps: step3. Set Ioption to the local data and obtain the value of key1.
1672 * Check whether the value is the same as the value of value1.
1673 * @tc.expected: step3. The obtained value and value2 are the same.
1674 */
1675 Value valueRead;
1676 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1677 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1678 Value value2;
1679 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, static_cast<int>(value1.size() + 3)); // 3 more for diff
1680
1681 /**
1682 * @tc.steps: step4. Ioption Set this parameter to the local data. Insert key1.
1683 * The value cannot be empty. value2(!=value1)
1684 * @tc.expected: step4. Return OK.
1685 */
1686 EXPECT_EQ(connection->Put(option, key1, value2), E_OK);
1687
1688 /**
1689 * @tc.steps: step5. Set Ioption to the local data, GetMetaData to obtain the value of key1,
1690 * and check whether the value is the same as the value of value2.
1691 * @tc.expected: step5. The obtained value and value2 are the same.
1692 */
1693 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1694 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1695
1696 /**
1697 * @tc.steps: step6. The Ioption parameter is set to the local data.
1698 * The data record whose key is empty and value is not empty is inserted.
1699 * @tc.expected: step6. Return E_INVALID_DATA.
1700 */
1701 Key emptyKey;
1702 Value emptyValue;
1703 EXPECT_EQ(connection->Put(option, emptyKey, value1), -E_INVALID_ARGS);
1704
1705 /**
1706 * @tc.steps: step7. Set Ioption to the local data, insert data
1707 * whose key2(!=key1) is not empty, and value is empty.
1708 * @tc.expected: step7. Return OK.
1709 */
1710 Key key2;
1711 DistributedDBToolsUnitTest::GetRandomKeyValue(key2, static_cast<int>(key1.size() + 1));
1712 EXPECT_EQ(connection->Put(option, key2, emptyValue), E_OK);
1713
1714 /**
1715 * @tc.steps: step8. Set option to local data, obtain the value of key2,
1716 * and check whether the value is empty.
1717 * @tc.expected: step8. Return OK, value is empty.
1718 */
1719 EXPECT_EQ(connection->Get(option, key2, valueRead), E_OK);
1720 EXPECT_EQ(valueRead.empty(), true);
1721
1722 /**
1723 * @tc.steps: step9. Ioption Set the local data.
1724 * Insert the data whose key size is 1024 and value size is 4Mb.
1725 * @tc.expected: step9. Return OK.
1726 */
1727 Key sizeKey;
1728 Value sizeValue;
1729 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeKey, MAX_TEST_KEY_SIZE);
1730 DistributedDBToolsUnitTest::GetRandomKeyValue(sizeValue, MAX_TEST_VAL_SIZE);
1731 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), E_OK);
1732 EXPECT_EQ(connection->Get(option, sizeKey, valueRead), E_OK);
1733 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, sizeValue), true);
1734
1735 /**
1736 * @tc.steps: step10/11. Set Ioption to the local data and insert data items
1737 * whose value is greater than 4Mb or key is bigger than 1Kb
1738 * @tc.expected: step10/11. Return E_INVALID_ARGS.
1739 */
1740 sizeKey.push_back(std::rand()); // random size
1741 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), -E_INVALID_ARGS);
1742 sizeKey.pop_back();
1743 sizeValue.push_back(174); // 174 as random size
1744 EXPECT_EQ(connection->Put(option, sizeKey, sizeValue), -E_INVALID_ARGS);
1745 }
1746
DataBaseCommonDeleteOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1747 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonDeleteOperate(SQLiteSingleVerNaturalStore *&store,
1748 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1749 {
1750 /**
1751 * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
1752 * @tc.expected: step2. Return E_INVALID_ARGS.
1753 */
1754 Key key1;
1755 EXPECT_EQ(connection->Delete(option, key1), -E_INVALID_ARGS);
1756 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE + 1);
1757 EXPECT_EQ(connection->Delete(option, key1), -E_INVALID_ARGS);
1758 DistributedDBToolsUnitTest::GetRandomKeyValue(key1);
1759 EXPECT_EQ(connection->Delete(option, key1), E_OK);
1760
1761 /**
1762 * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
1763 * @tc.expected: step3. Return E_OK.
1764 */
1765 Value value1;
1766 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1767 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1768
1769 /**
1770 * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
1771 * and check whether the value is the same as that of value1.
1772 * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
1773 */
1774 Value valueRead;
1775 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1776 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1777
1778 /**
1779 * @tc.steps: step5. Set Ioption to the local data and delete the data whose key is key1.
1780 * @tc.expected: step5. Return E_OK.
1781 */
1782 EXPECT_EQ(connection->Delete(option, key1), E_OK);
1783
1784 /**
1785 * @tc.steps: step5. Set Ioption to the local data and obtain the value of Key1.
1786 * @tc.expected: step5. Return E_NOT_FOUND.
1787 */
1788 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_NOT_FOUND);
1789 }
1790
DataBaseCommonGetOperate(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection,IOption option)1791 void DistributedDBStorageSingleVerNaturalStoreTestCase::DataBaseCommonGetOperate(SQLiteSingleVerNaturalStore *&store,
1792 SQLiteSingleVerNaturalStoreConnection *&connection, IOption option)
1793 {
1794 /**
1795 * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
1796 * @tc.expected: step2. Return E_INVALID_ARGS.
1797 */
1798 Key key1;
1799 Value valueRead;
1800 // empty key
1801 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_INVALID_ARGS);
1802
1803 // invalid key
1804 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE + 1);
1805 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_INVALID_ARGS);
1806
1807 // non-exist key
1808 DistributedDBToolsUnitTest::GetRandomKeyValue(key1, MAX_TEST_KEY_SIZE);
1809 EXPECT_EQ(connection->Get(option, key1, valueRead), -E_NOT_FOUND);
1810
1811 /**
1812 * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
1813 * @tc.expected: step3. Return E_OK.
1814 */
1815 Value value1;
1816 DistributedDBToolsUnitTest::GetRandomKeyValue(value1);
1817 EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
1818
1819 /**
1820 * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
1821 * and check whether the value is the same as that of value1.
1822 * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
1823 */
1824 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1825 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value1), true);
1826
1827 Key key2;
1828 DistributedDBToolsUnitTest::GetRandomKeyValue(key2);
1829 EXPECT_EQ(connection->Get(option, key2, valueRead), -E_NOT_FOUND);
1830
1831 /**
1832 * @tc.steps: step5. Set Ioption to the local data and obtain the value data of Key1.
1833 * Check whether the value is the same as the value of value2.
1834 * @tc.expected: step4. Return E_OK, and the value is the same as the value of value2.
1835 */
1836 Value value2;
1837 DistributedDBToolsUnitTest::GetRandomKeyValue(value2, value1.size() + 1);
1838 EXPECT_EQ(connection->Put(option, key1, value2), E_OK);
1839
1840 /**
1841 * @tc.steps: step5. The Ioption is set to the local.
1842 * The data of the key1 and value2(!=value1) is inserted.
1843 * @tc.expected: step4. Return E_OK.
1844 */
1845 EXPECT_EQ(connection->Get(option, key1, valueRead), E_OK);
1846 EXPECT_EQ(DistributedDBToolsUnitTest::IsValueEqual(valueRead, value2), true);
1847 }
1848
TestMetaDataDeleteByPrefixKey(SQLiteSingleVerNaturalStore * & store,SQLiteSingleVerNaturalStoreConnection * & connection)1849 void DistributedDBStorageSingleVerNaturalStoreTestCase::TestMetaDataDeleteByPrefixKey(
1850 SQLiteSingleVerNaturalStore *&store, SQLiteSingleVerNaturalStoreConnection *&connection)
1851 {
1852 /**
1853 * @tc.steps:step1. Put a1, b1, a2, b2.
1854 * @tc.expected: step1. Return OK.
1855 */
1856 ASSERT_EQ(store->PutMetaData(Key {'a', '1'}, Value {'a', '1'}), E_OK);
1857 ASSERT_EQ(store->PutMetaData(Key {'b', '1'}, Value {'b', '1'}), E_OK);
1858 ASSERT_EQ(store->PutMetaData(Key {'a', '2'}, Value {'a', '2'}), E_OK);
1859 ASSERT_EQ(store->PutMetaData(Key {'b', '2'}, Value {'b', '2'}), E_OK);
1860
1861 /**
1862 * @tc.steps:step2. Delete meta data with prefix key 'b'.
1863 * @tc.expected: step2. Return OK.
1864 */
1865 ASSERT_EQ(store->DeleteMetaDataByPrefixKey(Key {'b'}), E_OK);
1866 ASSERT_EQ(store->DeleteMetaDataByPrefixKey(Key {'c'}), E_OK);
1867
1868 /**
1869 * @tc.steps:step3. Get a1, b1, a2, b2.
1870 * @tc.expected: step3. Get a1, a2 successfully, and get b1, b2 failed.
1871 */
1872 Value value;
1873 EXPECT_EQ(store->GetMetaData(Key {'a', '1'}, value), E_OK);
1874 EXPECT_EQ(store->GetMetaData(Key {'a', '2'}, value), E_OK);
1875 EXPECT_EQ(store->GetMetaData(Key {'b', '1'}, value), -E_NOT_FOUND);
1876 EXPECT_EQ(store->GetMetaData(Key {'b', '2'}, value), -E_NOT_FOUND);
1877 }