1 /*
2 * Copyright (c) 2022 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 #include <cstdint>
16 #include <gtest/gtest.h>
17
18 #include "db_constant.h"
19 #include "db_common.h"
20 #include "distributeddb_storage_single_ver_natural_store_testcase.h"
21 #include "kvdb_pragma.h"
22 #include "storage_engine_manager.h"
23 #include "sqlite_meta_executor.h"
24 #include "sqlite_single_ver_storage_executor_sql.h"
25
26 using namespace testing::ext;
27 using namespace DistributedDB;
28 using namespace DistributedDBUnitTest;
29 using namespace std;
30
31 namespace {
32 string g_testDir;
33 string g_databaseName;
34 string g_identifier;
35 KvDBProperties g_property;
36
37 SQLiteSingleVerNaturalStore *g_store = nullptr;
38 SQLiteSingleVerNaturalStoreConnection *g_connection = nullptr;
39 SQLiteSingleVerStorageExecutor *g_handle = nullptr;
40 SQLiteSingleVerStorageExecutor *g_nullHandle = nullptr;
41
42 const char * const ADD_SYNC = "ALTER TABLE sync_data ADD column version INT";
43 const char * const DROP_CREATE = "ALTER TABLE sync_data DROP column create_time";
44 const char * const DROP_MODIFY = "ALTER TABLE sync_data DROP column modify_time";
45 const char * const ADD_LOCAL = "ALTER TABLE local_data ADD column flag INT";
46 const char * const INSERT_SQL = "INSERT INTO sync_data VALUES('a', 'b', 1, 2, '', '', 'efdef', 100 , 1);";
47 const int SQL_STATE_ERR = -1;
48 }
49
50 class DistributedDBStorageSQLiteSingleVerNaturalExecutorTest : public testing::Test {
51 public:
52 static void SetUpTestCase(void);
53 static void TearDownTestCase(void);
54 void SetUp();
55 void TearDown();
56 };
57
SetUpTestCase(void)58 void DistributedDBStorageSQLiteSingleVerNaturalExecutorTest::SetUpTestCase(void)
59 {
60 DistributedDBToolsUnitTest::TestDirInit(g_testDir);
61 LOGI("DistributedDBStorageSQLiteSingleVerNaturalExecutorTest dir is %s", g_testDir.c_str());
62 std::string oriIdentifier = APP_ID + "-" + USER_ID + "-" + "TestGeneralNBExecutor";
63 std::string identifier = DBCommon::TransferHashString(oriIdentifier);
64 g_identifier = DBCommon::TransferStringToHex(identifier);
65
66 g_databaseName = "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR + "/" + DBConstant::MAINDB_DIR + "/" +
67 DBConstant::SINGLE_VER_DATA_STORE + DBConstant::DB_EXTENSION;
68 g_property.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
69 g_property.SetStringProp(KvDBProperties::STORE_ID, "TestGeneralNBExecutor");
70 g_property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, g_identifier);
71 g_property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
72 }
73
TearDownTestCase(void)74 void DistributedDBStorageSQLiteSingleVerNaturalExecutorTest::TearDownTestCase(void)
75 {
76 DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR);
77 }
78
SetUp(void)79 void DistributedDBStorageSQLiteSingleVerNaturalExecutorTest::SetUp(void)
80 {
81 DistributedDBToolsUnitTest::PrintTestCaseInfo();
82 DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR);
83 g_store = new (std::nothrow) SQLiteSingleVerNaturalStore;
84 ASSERT_NE(g_store, nullptr);
85 ASSERT_EQ(g_store->Open(g_property), E_OK);
86
87 int erroCode = E_OK;
88 g_connection = static_cast<SQLiteSingleVerNaturalStoreConnection *>(g_store->GetDBConnection(erroCode));
89 ASSERT_NE(g_connection, nullptr);
90 RefObject::DecObjRef(g_store);
91 EXPECT_EQ(erroCode, E_OK);
92
93 g_handle = static_cast<SQLiteSingleVerStorageExecutor *>(
94 g_store->GetHandle(true, erroCode, OperatePerm::NORMAL_PERM));
95 ASSERT_EQ(erroCode, E_OK);
96 ASSERT_NE(g_handle, nullptr);
97
98 g_nullHandle = new (nothrow) SQLiteSingleVerStorageExecutor(nullptr, false, false);
99 ASSERT_NE(g_nullHandle, nullptr);
100 }
101
TearDown(void)102 void DistributedDBStorageSQLiteSingleVerNaturalExecutorTest::TearDown(void)
103 {
104 if (g_nullHandle != nullptr) {
105 delete g_nullHandle;
106 g_nullHandle = nullptr;
107 }
108 if (g_store != nullptr) {
109 g_store->ReleaseHandle(g_handle);
110 }
111 if (g_connection != nullptr) {
112 g_connection->Close();
113 g_connection = nullptr;
114 }
115 g_store = nullptr;
116 g_handle = nullptr;
117 }
118
119 /**
120 * @tc.name: InvalidParam001
121 * @tc.desc: Get Kv Data with Invalid condition
122 * @tc.type: FUNC
123 * @tc.require:
124 * @tc.author: bty
125 */
126 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam001, TestSize.Level1)
127 {
128 /**
129 * @tc.steps: step1. The Data type is invalid
130 * @tc.expected: step1. Expect -E_INVALID_ARGS
131 */
132 Timestamp timestamp = 0;
133 Key key;
134 Value value;
135 int type = static_cast<int>(SingleVerDataType::SYNC_TYPE);
136 EXPECT_EQ(g_nullHandle->GetKvData(SingleVerDataType(type + 1), key, value, timestamp), -E_INVALID_ARGS);
137
138 /**
139 * @tc.steps: step2. The db is null
140 * @tc.expected: step2. Expect -E_INVALID_DB
141 */
142 EXPECT_EQ(g_nullHandle->GetKvData(SingleVerDataType(type), key, value, timestamp), -E_INVALID_DB);
143
144 /**
145 * @tc.steps: step3. The key is empty
146 * @tc.expected: step3. Expect -E_INVALID_ARGS
147 */
148 EXPECT_EQ(g_handle->GetKvData(SingleVerDataType(type), key, value, timestamp), -E_INVALID_ARGS);
149 }
150
151 /**
152 * @tc.name: InvalidParam002
153 * @tc.desc: Put Kv Data with Invalid condition
154 * @tc.type: FUNC
155 * @tc.require:
156 * @tc.author: bty
157 */
158 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam002, TestSize.Level1)
159 {
160 /**
161 * @tc.steps: step1. The Data type is invalid
162 * @tc.expected: step1. Expect -E_INVALID_ARGS
163 */
164 Value value;
165 EXPECT_EQ(g_nullHandle->PutKvData(SingleVerDataType::SYNC_TYPE, KEY_1, value, 0, nullptr), -E_INVALID_ARGS);
166
167 /**
168 * @tc.steps: step2. The db is null
169 * @tc.expected: step2. Expect -E_INVALID_DB
170 */
171 EXPECT_EQ(g_nullHandle->PutKvData(SingleVerDataType::META_TYPE, KEY_1, value, 0, nullptr), -E_INVALID_DB);
172
173 /**
174 * @tc.steps: step3. The key is null
175 * @tc.expected: step3. Expect -E_INVALID_ARGS
176 */
177 Key key;
178 EXPECT_EQ(g_handle->PutKvData(SingleVerDataType::META_TYPE, key, value, 0, nullptr), -E_INVALID_ARGS);
179 }
180
181 /**
182 * @tc.name: InvalidParam003
183 * @tc.desc: Get entries with Invalid condition
184 * @tc.type: FUNC
185 * @tc.require:
186 * @tc.author: bty
187 */
188 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam003, TestSize.Level1)
189 {
190 /**
191 * @tc.steps: step1. The Data type is invalid
192 * @tc.expected: step1. Expect -E_INVALID_ARGS
193 */
194 vector<Entry> entries;
195 EXPECT_EQ(g_nullHandle->GetEntries(false, SingleVerDataType::META_TYPE, KEY_1, entries), -E_INVALID_ARGS);
196
197 /**
198 * @tc.steps: step2. The db is null
199 * @tc.expected: step2.. Expect -E_INVALID_DB
200 */
201 EXPECT_EQ(g_nullHandle->GetEntries(false, SingleVerDataType::LOCAL_TYPE_SQLITE, KEY_1, entries), -E_INVALID_DB);
202
203 /**
204 * @tc.steps: step3. This key does not exist
205 * @tc.expected: step3. Expect -E_NOT_FOUND
206 */
207 Key key;
208 EXPECT_EQ(g_handle->GetEntries(false, SingleVerDataType::LOCAL_TYPE_SQLITE, KEY_1, entries), -E_NOT_FOUND);
209 }
210
211 /**
212 * @tc.name: InvalidParam004
213 * @tc.desc: Get count with Invalid condition
214 * @tc.type: FUNC
215 * @tc.require:
216 * @tc.author: bty
217 */
218 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam004, TestSize.Level1)
219 {
220 /**
221 * @tc.steps: step1. The db is null
222 * @tc.expected: step1. Expect -E_INVALID_DB
223 */
224 Query query = Query::Select().OrderBy("abc", false);
225 QueryObject object(query);
226 int count;
227 EXPECT_EQ(g_nullHandle->GetCount(object, count), -E_INVALID_DB);
228
229 /**
230 * @tc.steps: step2. The query condition is invalid
231 * @tc.expected: step2. Expect -E_NOT_SUPPORT
232 */
233 EXPECT_EQ(g_handle->GetCount(object, count), -E_NOT_SUPPORT);
234 }
235
236 /**
237 * @tc.name: InvalidParam005
238 * @tc.desc: Test timestamp with Invalid condition
239 * @tc.type: FUNC
240 * @tc.require:
241 * @tc.author: bty
242 */
243 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam005, TestSize.Level1)
244 {
245 /**
246 * @tc.steps: step1. The db is null
247 * @tc.expected: step1. Expect return 0
248 */
249 Timestamp timestamp = 0;
250 g_nullHandle->InitCurrentMaxStamp(timestamp);
251 EXPECT_EQ(timestamp, 0u);
252
253 /**
254 * @tc.steps: step2. Get timestamp when The db is null
255 * @tc.expected: step2. Expect -E_INVALID_DB
256 */
257 std::vector<DataItem> dataItems;
258 Timestamp begin = 0;
259 Timestamp end = INT64_MAX;
260 DataSizeSpecInfo info;
261 EXPECT_EQ(g_nullHandle->GetSyncDataByTimestamp(dataItems, sizeof("time"), begin, end, info), -E_INVALID_DB);
262 EXPECT_EQ(g_nullHandle->GetDeletedSyncDataByTimestamp(dataItems, sizeof("time"), begin, end, info), -E_INVALID_DB);
263 }
264
265 /**
266 * @tc.name: InvalidParam006
267 * @tc.desc: Open and get resultSet with Invalid condition
268 * @tc.type: FUNC
269 * @tc.require:
270 * @tc.author: bty
271 */
272 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam006, TestSize.Level1)
273 {
274 /**
275 * @tc.steps: step1. The db is null
276 * @tc.expected: step1. Expect -E_INVALID_DB
277 */
278 int count;
279 EXPECT_EQ(g_nullHandle->OpenResultSet(KEY_1, count), -E_INVALID_DB);
280 vector<int64_t> cache;
281 Key key;
282 EXPECT_EQ(g_nullHandle->OpenResultSetForCacheRowIdMode(KEY_1, cache, 0, count), -E_INVALID_DB);
283 Query query = Query::Select();
284 QueryObject object(query);
285 EXPECT_EQ(g_nullHandle->OpenResultSet(object, count), -E_INVALID_DB);
286 EXPECT_EQ(g_nullHandle->OpenResultSetForCacheRowIdMode(object, cache, 0, count), -E_INVALID_DB);
287
288 /**
289 * @tc.steps: step2. Then get
290 * @tc.expected: step2. Expect -E_RESULT_SET_STATUS_INVALID
291 */
292 Value value;
293 EXPECT_EQ(g_nullHandle->GetNextEntryFromResultSet(key, value, false), -E_RESULT_SET_STATUS_INVALID);
294
295 /**
296 * @tc.steps: step3. The db is valid,open
297 * @tc.expected: step3. Expect E_OK
298 */
299 EXPECT_EQ(g_handle->OpenResultSetForCacheRowIdMode(object, cache, 0, count), E_OK);
300
301 /**
302 * @tc.steps: step4. Then get
303 * @tc.expected: step4. Expect -E_RESULT_SET_STATUS_INVALID
304 */
305 Entry entry;
306 EXPECT_EQ(g_handle->GetEntryByRowId(0, entry), -E_UNEXPECTED_DATA);
307 }
308
309 /**
310 * @tc.name: InvalidParam007
311 * @tc.desc: Reload resultSet with Invalid condition
312 * @tc.type: FUNC
313 * @tc.require:
314 * @tc.author: bty
315 */
316 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam007, TestSize.Level1)
317 {
318 /**
319 * @tc.steps: step1. Reload,but the db is null
320 * @tc.expected: step1. Expect -E_INVALID_ARGS
321 */
322 Key key;
323 EXPECT_EQ(g_nullHandle->ReloadResultSet(key), -E_INVALID_ARGS);
324
325 /**
326 * @tc.steps: step2. Reload,but the key is empty
327 * @tc.expected: step2. Expect -E_INVALID_ARGS
328 */
329 vector<int64_t> cache;
330 EXPECT_EQ(g_handle->ReloadResultSet(key), -E_INVALID_ARGS);
331 EXPECT_EQ(g_nullHandle->ReloadResultSetForCacheRowIdMode(key, cache, 0, 0), -E_INVALID_ARGS);
332
333 /**
334 * @tc.steps: step3. Reload by object,but the db is null
335 * @tc.expected: step3. Expect -E_INVALID_QUERY_FORMAT
336 */
337 Query query = Query::Select();
338 QueryObject object(query);
339 EXPECT_EQ(g_nullHandle->ReloadResultSet(object), -E_INVALID_QUERY_FORMAT);
340 EXPECT_EQ(g_nullHandle->ReloadResultSetForCacheRowIdMode(object, cache, 0, 0), -E_INVALID_QUERY_FORMAT);
341
342 /**
343 * @tc.steps: step4. Reload with the valid db
344 * @tc.expected: step4. Expect E_OK
345 */
346 EXPECT_EQ(g_handle->ReloadResultSetForCacheRowIdMode(object, cache, 0, 0), E_OK);
347 }
348
349 /**
350 * @tc.name: InvalidParam008
351 * @tc.desc: Test transaction with Invalid condition
352 * @tc.type: FUNC
353 * @tc.require:
354 * @tc.author: bty
355 */
356 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam008, TestSize.Level1)
357 {
358 EXPECT_EQ(g_nullHandle->StartTransaction(TransactType::DEFERRED), -E_INVALID_DB);
359 EXPECT_EQ(g_nullHandle->Commit(), -E_INVALID_DB);
360 EXPECT_EQ(g_nullHandle->Rollback(), -E_INVALID_DB);
361
362 EXPECT_EQ(g_handle->StartTransaction(TransactType::DEFERRED), E_OK);
363 EXPECT_EQ(g_handle->Reset(), E_OK);
364 }
365
366 /**
367 * @tc.name: InvalidParam009
368 * @tc.desc: Get identifier with Invalid condition
369 * @tc.type: FUNC
370 * @tc.require:
371 * @tc.author: bty
372 */
373 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam009, TestSize.Level1)
374 {
375 /**
376 * @tc.steps: step1. The parameter is null
377 * @tc.expected: step1. Expect -E_INVALID_ARGS
378 */
379 EXPECT_EQ(g_nullHandle->GetDeviceIdentifier(nullptr), -E_INVALID_ARGS);
380
381 /**
382 * @tc.steps: step2. The db is null
383 * @tc.expected: step2. Expect -E_INVALID_DB
384 */
385 PragmaEntryDeviceIdentifier identifier;
386 EXPECT_EQ(g_nullHandle->GetDeviceIdentifier(&identifier), -E_INVALID_DB);
387
388 /**
389 * @tc.steps: step3. The identifier is empty
390 * @tc.expected: step3. Expect -E_INVALID_ARGS
391 */
392 EXPECT_EQ(g_handle->GetDeviceIdentifier(&identifier), -E_INVALID_ARGS);
393 }
394
395 /**
396 * @tc.name: InvalidParam010
397 * @tc.desc: Fail to call function with Invalid condition
398 * @tc.type: FUNC
399 * @tc.require:
400 * @tc.author: bty
401 */
402 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam010, TestSize.Level1)
403 {
404 vector<Key> keys;
405 EXPECT_EQ(g_nullHandle->GetAllMetaKeys(keys), -E_INVALID_DB);
406 string devName;
407 vector<Entry> entries;
408 EXPECT_EQ(g_nullHandle->GetAllSyncedEntries(devName, entries), -E_INVALID_DB);
409 EXPECT_EQ(g_nullHandle->ForceCheckPoint(), -E_INVALID_DB);
410 EXPECT_EQ(g_nullHandle->CheckIntegrity(), -E_INVALID_DB);
411 }
412
413 /**
414 * @tc.name: InvalidParam011
415 * @tc.desc: Change executor state to operate data
416 * @tc.type: FUNC
417 * @tc.require:
418 * @tc.author: bty
419 */
420 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidParam011, TestSize.Level1)
421 {
422 /**
423 * @tc.steps: step1. put local kv data
424 * @tc.expected: step1. Expect E_OK
425 */
426 Key key = KEY_1;
427 Value value;
428 Timestamp timestamp = 0;
429 EXPECT_EQ(g_handle->PutKvData(SingleVerDataType::LOCAL_TYPE_SQLITE, key, value, timestamp, nullptr), E_OK);
430
431 /**
432 * @tc.steps: step2. Get sqlite3 handle,then create executor for state CACHE_ATTACH_MAIN
433 * @tc.expected: step2. Expect not null
434 */
435 sqlite3 *sqlHandle = nullptr;
436 std::string dbPath = g_testDir + g_databaseName;
437 OpenDbProperties property = {dbPath, false, false};
438 EXPECT_EQ(SQLiteUtils::OpenDatabase(property, sqlHandle), E_OK);
439 ASSERT_NE(sqlHandle, nullptr);
440
441 auto executor = std::make_unique<SQLiteSingleVerStorageExecutor>(
442 sqlHandle, false, false, ExecutorState::CACHE_ATTACH_MAIN);
443 ASSERT_NE(executor, nullptr);
444
445 /**
446 * @tc.steps: step3. The singleVerNaturalStoreCommitNotifyData is null,delete
447 * @tc.expected: step3. Expect SQL_STATE_ERR
448 */
449 EXPECT_EQ(executor->DeleteLocalKvData(key, nullptr, value, timestamp), SQL_STATE_ERR);
450
451 /**
452 * @tc.steps: step4. Update sync_data table and insert a sync data
453 * @tc.expected: step4. Expect E_OK
454 */
455 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(sqlHandle, DROP_MODIFY) == E_OK);
456 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(sqlHandle, DROP_CREATE) == E_OK);
457 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(sqlHandle, ADD_SYNC) == E_OK);
458 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(sqlHandle, INSERT_SQL) == E_OK);
459 std::vector<DataItem> vec;
460 uint64_t version = 0u;
461 EXPECT_EQ(executor->GetMinVersionCacheData(vec, version), E_OK);
462 EXPECT_EQ(executor->GetMaxVersionInCacheDb(version), E_OK);
463 std::string hashDev = DBCommon::TransferHashString("device1");
464 EXPECT_EQ(executor->RemoveDeviceDataInCacheMode(hashDev, true, 0u), E_OK);
465 sqlite3_close_v2(sqlHandle);
466 sqlHandle = nullptr;
467 }
468
469 /**
470 * @tc.name: InvalidSync001
471 * @tc.desc: Save sync data with Invalid condition
472 * @tc.type: FUNC
473 * @tc.require:
474 * @tc.author: bty
475 */
476 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, InvalidSync001, TestSize.Level1)
477 {
478 /**
479 * @tc.steps: step1. The saveSyncStatements_ is not prepare
480 * @tc.expected: step1. Expect -E_INVALID_ARGS
481 */
482 DataItem item;
483 DeviceInfo info;
484 Timestamp time = 0;
485 EXPECT_EQ(g_handle->SaveSyncDataItem(item, info, time, nullptr, false), -E_INVALID_ARGS);
486
487 /**
488 * @tc.steps: step2. Try to prepare when the db is null
489 * @tc.expected: step2. Expect -E_INVALID_DB
490 */
491 EXPECT_EQ(g_nullHandle->PrepareForSavingData(SingleVerDataType::LOCAL_TYPE_SQLITE), -E_INVALID_DB);
492
493 /**
494 * @tc.steps: step3. The data item key is empty
495 * @tc.expected: step3. Expect -E_INVALID_ARGS
496 */
497 EXPECT_EQ(g_handle->PrepareForSavingData(SingleVerDataType::SYNC_TYPE), E_OK);
498 EXPECT_EQ(g_handle->SaveSyncDataItem(item, info, time, nullptr, false), -E_INVALID_ARGS);
499
500 /**
501 * @tc.steps: step4. The committedData is null
502 * @tc.expected: step4. Expect return E_OK
503 */
504 item.key = KEY_1;
505 EXPECT_EQ(g_handle->SaveSyncDataItem(item, info, time, nullptr, false), E_OK);
506
507 /**
508 * @tc.steps: step5. Into EraseSyncData
509 * @tc.expected: step5. Expect return E_OK
510 */
511 SingleVerNaturalStoreCommitNotifyData data;
512 item.writeTimestamp = 1;
513 item.flag = DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
514 EXPECT_EQ(g_handle->SaveSyncDataItem(item, info, time, &data, true), E_OK);
515 }
516
517 /**
518 * @tc.name: ConnectionTest001
519 * @tc.desc: Failed to get the keys
520 * @tc.type: FUNC
521 * @tc.require:
522 * @tc.author: bty
523 */
524 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest001, TestSize.Level1)
525 {
526 /**
527 * @tc.steps: step1. the dataType is error
528 * @tc.expected: step1. Expect -E_INVALID_ARGS
529 */
530 IOption option;
531 option.dataType = IOption::SYNC_DATA + 1;
532 vector<Key> keys;
533 EXPECT_EQ(g_connection->GetKeys(option, KEY_1, keys), -E_INVALID_ARGS);
534
535 /**
536 * @tc.steps: step2. Get keys in cacheDB state
537 * @tc.expected: step2. Expect -E_EKEYREVOKED
538 */
539 int errCode = E_OK;
540 SQLiteSingleVerStorageEngine *storageEngine =
541 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
542 ASSERT_EQ(errCode, E_OK);
543 ASSERT_NE(storageEngine, nullptr);
544 storageEngine->SetEngineState(EngineState::CACHEDB);
545 option.dataType = IOption::LOCAL_DATA;
546 EXPECT_EQ(g_connection->GetKeys(option, KEY_1, keys), -E_EKEYREVOKED);
547 storageEngine->Release();
548
549 /**
550 * @tc.steps: step3. Get keys in null db connection
551 * @tc.expected: step3. Expect -E_NOT_INIT
552 */
553 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
554 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
555 ASSERT_NE(emptyConn, nullptr);
556 EXPECT_EQ(emptyConn->GetKeys(option, KEY_1, keys), -E_NOT_INIT);
557 }
558
559 /**
560 * @tc.name: ConnectionTest002
561 * @tc.desc: Push and delete on empty connect
562 * @tc.type: FUNC
563 * @tc.require:
564 * @tc.author: bty
565 */
566 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest002, TestSize.Level1)
567 {
568 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
569 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
570 IOption option = {IOption::LOCAL_DATA};
571 std::vector<Entry> entries;
572 EXPECT_EQ(emptyConn->PutBatch(option, entries), -E_INVALID_DB);
573 std::vector<Key> keys;
574 EXPECT_EQ(emptyConn->DeleteBatch(option, keys), -E_INVALID_DB);
575 option.dataType = IOption::SYNC_DATA;
576 EXPECT_EQ(emptyConn->PutBatch(option, entries), -E_INVALID_DB);
577 EXPECT_EQ(emptyConn->DeleteBatch(option, keys), -E_INVALID_DB);
578 option.dataType = IOption::SYNC_DATA + 1;
579 EXPECT_EQ(emptyConn->PutBatch(option, entries), -E_NOT_SUPPORT);
580 }
581
582 /**
583 * @tc.name: ConnectionTest003
584 * @tc.desc: Failed to Put and Delete
585 * @tc.type: FUNC
586 * @tc.require:
587 * @tc.author: bty
588 */
589 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest003, TestSize.Level1)
590 {
591 /**
592 * @tc.steps: step1. Only change the storageEngine to cacheDB
593 * @tc.expected: step1. Expect SQL_STATE_ERR
594 */
595 int errCode = E_OK;
596 SQLiteSingleVerStorageEngine *storageEngine =
597 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
598 ASSERT_EQ(errCode, E_OK);
599 ASSERT_NE(storageEngine, nullptr);
600 storageEngine->SetEngineState(EngineState::CACHEDB);
601 IOption option = {IOption::SYNC_DATA};
602 std::vector<Entry> entries;
603 entries.push_back(ENTRY_1);
604 g_store->ReleaseHandle(g_handle);
605 EXPECT_EQ(g_connection->PutBatch(option, entries), SQL_STATE_ERR);
606 std::vector<Key> keys;
607 keys.push_back(KEY_1);
608 EXPECT_EQ(g_connection->DeleteBatch(option, keys), SQL_STATE_ERR);
609
610 /**
611 * @tc.steps: step2.Change to LOCAL_DATA option
612 * @tc.expected: step2. Expect SQL_STATE_ERR
613 */
614 option.dataType = IOption::LOCAL_DATA;
615 EXPECT_EQ(g_connection->PutBatch(option, entries), SQL_STATE_ERR);
616 EXPECT_EQ(g_connection->DeleteBatch(option, keys), SQL_STATE_ERR);
617
618 /**
619 * @tc.steps: step3. Table sync_data adds a column to make the num of cols equal to the cacheDB
620 * @tc.expected: step3. Expect E_OK
621 */
622 sqlite3 *db;
623 ASSERT_TRUE(sqlite3_open_v2((g_testDir + g_databaseName).c_str(),
624 &db, SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) == SQLITE_OK);
625 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, DROP_MODIFY) == E_OK);
626 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, DROP_CREATE) == E_OK);
627 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_SYNC) == E_OK);
628 sqlite3_close_v2(db);
629 option.dataType = IOption::SYNC_DATA;
630 EXPECT_EQ(g_connection->PutBatch(option, entries), E_OK);
631 storageEngine->Release();
632 }
633
634 /**
635 * @tc.name: ConnectionTest004
636 * @tc.desc: Failed to GetResultSet
637 * @tc.type: FUNC
638 * @tc.require:
639 * @tc.author: bty
640 */
641 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest004, TestSize.Level1)
642 {
643 /**
644 * @tc.steps: step1. the db is null
645 * @tc.expected: step1. Expect -E_INVALID_DB
646 */
647 g_store->ReleaseHandle(g_handle);
648 IOption option;
649 option.dataType = IOption::SYNC_DATA;
650 IKvDBResultSet *set = nullptr;
651 Query query = Query::Select();
652 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
653 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
654 EXPECT_EQ(emptyConn->GetResultSet(option, KEY_1, set), -E_INVALID_DB);
655
656 /**
657 * @tc.steps: step2. get in transaction
658 * @tc.expected: step2. Expect -E_BUSY
659 */
660 g_connection->StartTransaction();
661 EXPECT_EQ(g_connection->GetResultSet(option, query, set), -E_BUSY);
662 g_connection->RollBack();
663
664 /**
665 * @tc.steps: step3. change the storageEngine to cacheDB
666 * @tc.expected: step3. Expect -E_EKEYREVOKED
667 */
668 int errCode = E_OK;
669 SQLiteSingleVerStorageEngine *storageEngine =
670 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
671 ASSERT_EQ(errCode, E_OK);
672 ASSERT_NE(storageEngine, nullptr);
673 storageEngine->SetEngineState(EngineState::CACHEDB);
674 EXPECT_EQ(g_connection->GetResultSet(option, query, set), -E_EKEYREVOKED);
675 EXPECT_EQ(g_connection->GetResultSet(option, KEY_1, set), -E_EKEYREVOKED);
676 storageEngine->Release();
677 }
678
679 /**
680 * @tc.name: ConnectionTest005
681 * @tc.desc: Failed to Get entries,value and count
682 * @tc.type: FUNC
683 * @tc.require:
684 * @tc.author: bty
685 */
686 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest005, TestSize.Level1)
687 {
688 /**
689 * @tc.steps: step1. the db is null
690 * @tc.expected: step1. Expect -E_INVALID_DB, Get return -E_NOT_INIT
691 */
692 g_store->ReleaseHandle(g_handle);
693 IOption option;
694 option.dataType = IOption::SYNC_DATA;
695 Query query = Query::Select();
696 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
697 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
698 ASSERT_NE(emptyConn, nullptr);
699 int count;
700 EXPECT_EQ(emptyConn->GetCount(option, query, count), -E_INVALID_DB);
701 std::vector<Entry> entries;
702 EXPECT_EQ(emptyConn->GetEntries(option, query, entries), -E_INVALID_DB);
703 Value value;
704 EXPECT_EQ(emptyConn->Get(option, KEY_1, value), -E_NOT_INIT);
705
706 /**
707 * @tc.steps: step2. the dataType is not SYNC_DATA
708 * @tc.expected: step2. Expect -E_NOT_SUPPORT
709 */
710 option.dataType = IOption::SYNC_DATA + 1;
711 EXPECT_EQ(emptyConn->GetCount(option, query, count), -E_NOT_SUPPORT);
712 EXPECT_EQ(emptyConn->GetEntries(option, query, entries), -E_NOT_SUPPORT);
713 EXPECT_EQ(emptyConn->Get(option, KEY_1, value), -E_NOT_SUPPORT);
714
715 /**
716 * @tc.steps: step3. get in transaction
717 * @tc.expected: step3. Expect GetEntries -E_NOT_FOUND, GetCount E_OK
718 */
719 option.dataType = IOption::SYNC_DATA;
720 g_connection->StartTransaction();
721 EXPECT_EQ(g_connection->GetEntries(option, query, entries), -E_NOT_FOUND);
722 EXPECT_EQ(g_connection->GetCount(option, query, count), E_OK);
723 g_connection->RollBack();
724
725 /**
726 * @tc.steps: step4. change the storageEngine to cacheDB
727 * @tc.expected: step4. Expect -E_EKEYREVOKED
728 */
729 int errCode = E_OK;
730 SQLiteSingleVerStorageEngine *storageEngine =
731 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
732 ASSERT_EQ(errCode, E_OK);
733 ASSERT_NE(storageEngine, nullptr);
734 storageEngine->SetEngineState(EngineState::CACHEDB);
735 EXPECT_EQ(g_connection->GetCount(option, query, count), -E_EKEYREVOKED);
736 EXPECT_EQ(g_connection->GetEntries(option, query, entries), -E_EKEYREVOKED);
737 EXPECT_EQ(g_connection->Get(option, KEY_1, value), -E_EKEYREVOKED);
738 storageEngine->Release();
739 }
740
741 /**
742 * @tc.name: ConnectionTest006
743 * @tc.desc: Test force release engine
744 * @tc.type: FUNC
745 * @tc.require:
746 * @tc.author: zhangqiquan
747 */
748 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ConnectionTest006, TestSize.Level0)
749 {
750 /**
751 * @tc.steps: step1. open storage engine
752 * @tc.expected: step1. open ok
753 */
754 auto property = g_property;
755 property.SetStringProp(KvDBProperties::STORE_ID, "ConnectionTest006");
756 property.SetStringProp(KvDBProperties::IDENTIFIER_DATA, "ConnectionTest006ID");
757 int errCode = E_OK;
758 auto storageEngine =
759 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(property, errCode));
760 ASSERT_EQ(errCode, E_OK);
761 ASSERT_NE(storageEngine, nullptr);
762 /**
763 * @tc.steps: step2. inc ref count and release it
764 */
765 RefObject::IncObjRef(storageEngine);
766 const std::string identifier = property.GetStringProp(KvDBProperties::IDENTIFIER_DATA, "");
767 (void)StorageEngineManager::ForceReleaseStorageEngine(identifier);
768 /**
769 * @tc.steps: step3. try use engine api and dec ref count
770 * @tc.expected: step3. call api ok
771 */
772 EXPECT_FALSE(storageEngine->IsEngineCorrupted());
773 RefObject::DecObjRef(storageEngine);
774 }
775
776 /**
777 * @tc.name: PragmaTest001
778 * @tc.desc: Calling Pragma incorrectly
779 * @tc.type: FUNC
780 * @tc.require:
781 * @tc.author: bty
782 */
783 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, PragmaTest001, TestSize.Level1)
784 {
785 /**
786 * @tc.steps: step1. the parameter is null
787 * @tc.expected: step1. Expect -E_INVALID_ARGS
788 */
789 EXPECT_EQ(g_connection->Pragma(PRAGMA_RESULT_SET_CACHE_MAX_SIZE, nullptr), -E_INVALID_ARGS);
790 EXPECT_EQ(g_connection->Pragma(PRAGMA_RESULT_SET_CACHE_MODE, nullptr), -E_INVALID_ARGS);
791 EXPECT_EQ(g_connection->Pragma(PRAGMA_SET_AUTO_LIFE_CYCLE, nullptr), -E_INVALID_ARGS);
792 EXPECT_EQ(g_connection->Pragma(PRAGMA_UNPUBLISH_SYNC, nullptr), -E_INVALID_ARGS);
793 EXPECT_EQ(g_connection->Pragma(PRAGMA_PUBLISH_LOCAL, nullptr), -E_INVALID_ARGS);
794 EXPECT_EQ(g_connection->Pragma(PRAGMA_GET_DEVICE_IDENTIFIER_OF_ENTRY, nullptr), -E_INVALID_ARGS);
795 EXPECT_EQ(g_connection->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, nullptr), -E_INVALID_ARGS);
796 EXPECT_EQ(g_connection->Pragma(PRAGMA_GET_IDENTIFIER_OF_DEVICE, nullptr), -E_INVALID_ARGS);
797
798 /**
799 * @tc.steps: step2. the option is invalid
800 * @tc.expected: step2. Expect -E_INVALID_ARGS
801 */
802 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
803 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
804 ASSERT_NE(emptyConn, nullptr);
805 SecurityOption option = {S3, SECE};
806 EXPECT_EQ(emptyConn->Pragma(PRAGMA_TRIGGER_TO_MIGRATE_DATA, &option), -E_INVALID_CONNECTION);
807
808 /**
809 * @tc.steps: step3. the size is invalid
810 * @tc.expected: step3. Expect -E_INVALID_ARGS
811 */
812 int size = 0;
813 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MAX_SIZE, &size), -E_INVALID_ARGS);
814 size = 1;
815 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MAX_SIZE, &size), E_OK);
816
817 /**
818 * @tc.steps: step4. the mode is invalid
819 * @tc.expected: step4. Expect -E_INVALID_ARGS
820 */
821 ResultSetCacheMode mode = ResultSetCacheMode(2); // 2 is invalid mode
822 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MODE, &mode), -E_INVALID_ARGS);
823
824 /**
825 * @tc.steps: step5. the db is null
826 * @tc.expected: step5. Expect -E_INVALID_DB
827 */
828 int time = 6000; // 6000 is random
829 EXPECT_EQ(emptyConn->Pragma(PRAGMA_SET_AUTO_LIFE_CYCLE, &time), -E_INVALID_DB);
830 }
831
832 /**
833 * @tc.name: PragmaTest002
834 * @tc.desc: Incorrect publishing and unPublishing
835 * @tc.type: FUNC
836 * @tc.require:
837 * @tc.author: bty
838 */
839 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, PragmaTest002, TestSize.Level1)
840 {
841 /**
842 * @tc.steps: step1. the db is null
843 * @tc.expected: step1. Expect -E_INVALID_DB
844 */
845 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
846 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
847 PragmaPublishInfo info;
848 EXPECT_EQ(emptyConn->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_INVALID_DB);
849 EXPECT_EQ(emptyConn->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_INVALID_DB);
850
851 /**
852 * @tc.steps: step2. publish in transaction
853 * @tc.expected: step2. Expect -E_NOT_SUPPORT
854 */
855 g_store->ReleaseHandle(g_handle);
856 g_connection->StartTransaction();
857 EXPECT_EQ(g_connection->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_NOT_SUPPORT);
858 EXPECT_EQ(g_connection->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_NOT_SUPPORT);
859 g_connection->RollBack();
860
861 /**
862 * @tc.steps: step3. publish in cacheDB
863 * @tc.expected: step3. Expect -E_EKEYREVOKED
864 */
865 int errCode = E_OK;
866 SQLiteSingleVerStorageEngine *storageEngine =
867 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
868 ASSERT_EQ(errCode, E_OK);
869 ASSERT_NE(storageEngine, nullptr);
870 storageEngine->SetEngineState(EngineState::CACHEDB);
871 EXPECT_EQ(g_connection->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_EKEYREVOKED);
872 EXPECT_EQ(g_connection->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_EKEYREVOKED);
873 g_connection->StartTransaction();
874 g_connection->Commit();
875 storageEngine->Release();
876 }
877
878 /**
879 * @tc.name: PragmaTest003
880 * @tc.desc: Failed to call function with empty connection
881 * @tc.type: FUNC
882 * @tc.require:
883 * @tc.author: bty
884 */
885 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, PragmaTest003, TestSize.Level1)
886 {
887 auto emptyConn = std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
888 PragmaEntryDeviceIdentifier identifier = {.key = KEY_1};
889 EXPECT_EQ(emptyConn->Pragma(PRAGMA_GET_DEVICE_IDENTIFIER_OF_ENTRY, &identifier), -E_NOT_INIT);
890 EXPECT_EQ(emptyConn->Pragma(PRAGMA_EXEC_CHECKPOINT, nullptr), -E_NOT_INIT);
891 EXPECT_EQ(emptyConn->CheckIntegrity(), -E_NOT_INIT);
892
893 int limit = 0;
894 EXPECT_EQ(emptyConn->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, &limit), -E_INVALID_DB);
895 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RM_DEVICE_DATA, nullptr), -E_INVALID_DB);
896 CipherPassword pw;
897 EXPECT_EQ(emptyConn->Import("/a.b", pw), -E_INVALID_DB);
898 EXPECT_EQ(emptyConn->Export("/a.b", pw), -E_INVALID_DB);
899 DatabaseLifeCycleNotifier notifier;
900 EXPECT_EQ(emptyConn->RegisterLifeCycleCallback(notifier), -E_INVALID_DB);
901
902 EXPECT_EQ(emptyConn->SetConflictNotifier(0, nullptr), -E_INVALID_ARGS);
__anone8d596470202(const KvDBCommitNotifyData &data) 903 KvDBConflictAction func = [&](const KvDBCommitNotifyData &data) {};
904 EXPECT_EQ(emptyConn->SetConflictNotifier(0, func), -E_INVALID_DB);
905 IKvDBSnapshot *shot;
906 EXPECT_EQ(emptyConn->GetSnapshot(shot), -E_NOT_SUPPORT);
907 }
908
909 /**
910 * @tc.name: ExecutorCache001
911 * @tc.desc: Fail to operate data
912 * @tc.type: FUNC
913 * @tc.require:
914 * @tc.author: bty
915 */
916 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache001, TestSize.Level1)
917 {
918 g_handle->SetAttachMetaMode(true);
919 std::set<std::string> devices;
920 EXPECT_EQ(g_handle->GetExistsDevicesFromMeta(devices), SQL_STATE_ERR);
921 EXPECT_EQ(g_handle->DeleteMetaDataByPrefixKey(KEY_1), SQL_STATE_ERR);
922 std::vector<Key> keys;
923 EXPECT_EQ(g_handle->DeleteMetaData(keys), SQL_STATE_ERR);
924 EXPECT_EQ(g_handle->PrepareForSavingCacheData(SingleVerDataType::LOCAL_TYPE_SQLITE), SQL_STATE_ERR);
925 std::string hashDev = DBCommon::TransferHashString("device1");
926 EXPECT_EQ(g_handle->RemoveDeviceDataInCacheMode(hashDev, true, 0u), SQL_STATE_ERR);
927 Timestamp timestamp;
928 EXPECT_EQ(g_handle->GetMaxTimestampDuringMigrating(timestamp), -E_NOT_INIT);
929 EXPECT_EQ(g_handle->ResetForSavingCacheData(SingleVerDataType::LOCAL_TYPE_SQLITE), E_OK);
930 }
931
932 /**
933 * @tc.name: ExecutorCache002
934 * @tc.desc: Fail to call func in each ExecutorState
935 * @tc.type: FUNC
936 * @tc.require:
937 * @tc.author: bty
938 */
939 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache002, TestSize.Level1)
940 {
941 /**
942 * @tc.steps: step1. In MAINDB
943 * @tc.expected: step1. Expect not E_OK
944 */
945 NotifyMigrateSyncData syncData;
946 DataItem dataItem;
947 std::vector<DataItem> items;
948 items.push_back(dataItem);
949 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_DB);
950 uint64_t version;
951 EXPECT_EQ(g_handle->GetMinVersionCacheData(items, version), -E_INVALID_ARGS);
952 EXPECT_EQ(g_handle->GetMaxVersionInCacheDb(version), -E_INVALID_ARGS);
953 EXPECT_EQ(g_handle->MigrateLocalData(), -E_INVALID_ARGS);
954
955 /**
956 * @tc.steps: step2. Change executor to CACHE_ATTACH_MAIN
957 * @tc.expected: step2. Expect SQL_STATE_ERR
958 */
959 sqlite3 *sqlHandle = nullptr;
960 EXPECT_EQ(SQLiteUtils::OpenDatabase({g_testDir + g_databaseName, false, false}, sqlHandle), E_OK);
961 ASSERT_NE(sqlHandle, nullptr);
962 auto executor = std::make_unique<SQLiteSingleVerStorageExecutor>(
963 sqlHandle, false, false, ExecutorState::CACHE_ATTACH_MAIN);
964 ASSERT_NE(executor, nullptr);
965 EXPECT_EQ(executor->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
966 EXPECT_EQ(executor->GetMinVersionCacheData(items, version), SQL_STATE_ERR);
967 EXPECT_EQ(executor->GetMaxVersionInCacheDb(version), SQL_STATE_ERR);
968 EXPECT_EQ(executor->MigrateLocalData(), SQL_STATE_ERR);
969 executor->SetAttachMetaMode(true);
970 EXPECT_EQ(executor->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
971
972 /**
973 * @tc.steps: step3. Change executor to MAIN_ATTACH_CACHE
974 */
975 auto executor2 = std::make_unique<SQLiteSingleVerStorageExecutor>(
976 sqlHandle, false, false, ExecutorState::MAIN_ATTACH_CACHE);
977 ASSERT_NE(executor2, nullptr);
978 items.clear();
979 EXPECT_EQ(executor2->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
980 items.push_back(dataItem);
981 EXPECT_EQ(executor2->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
982 EXPECT_EQ(executor2->GetMinVersionCacheData(items, version), SQL_STATE_ERR);
983 EXPECT_EQ(executor2->GetMaxVersionInCacheDb(version), SQL_STATE_ERR);
984 EXPECT_EQ(executor2->MigrateLocalData(), SQL_STATE_ERR);
985 sqlite3_close_v2(sqlHandle);
986 sqlHandle = nullptr;
987 }
988
989 /**
990 * @tc.name: ExecutorCache003
991 * @tc.desc: Test different condition to attach db
992 * @tc.type: FUNC
993 * @tc.require:
994 * @tc.author: bty
995 */
996 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache003, TestSize.Level1)
997 {
998 /**
999 * @tc.steps: step1. Copy empty db, then attach
1000 */
1001 string cacheDir = g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR +
1002 "/" + DBConstant::CACHEDB_DIR + "/" + DBConstant::SINGLE_VER_CACHE_STORE + DBConstant::DB_EXTENSION;
1003 EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName, cacheDir), E_OK);
1004 CipherPassword password;
1005 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1006 CipherType::DEFAULT, password, cacheDir, EngineState::INVALID), -E_INVALID_ARGS);
1007 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1008 CipherType::DEFAULT, password, cacheDir, EngineState::CACHEDB), -E_INVALID_DB);
1009 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1010 CipherType::DEFAULT, password, cacheDir, EngineState::ATTACHING), E_OK);
1011 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1012 CipherType::DEFAULT, password, cacheDir, EngineState::MAINDB), E_OK);
1013
1014 /**
1015 * @tc.steps: step2. Try migrate data after attaching cache
1016 * @tc.expected: step2. Expect SQL_STATE_ERR
1017 */
1018 NotifyMigrateSyncData syncData;
1019 DataItem dataItem;
1020 std::vector<DataItem> items;
1021 items.push_back(dataItem);
1022 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1023 }
1024
1025 /**
1026 * @tc.name: ExecutorCache004
1027 * @tc.desc: Test migrate after attaching
1028 * @tc.type: FUNC
1029 * @tc.require:
1030 * @tc.author: bty
1031 */
1032 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache004, TestSize.Level1)
1033 {
1034 /**
1035 * @tc.steps: step1. Copy normal db, attach cache
1036 * @tc.expected: step1. Expect E_OK
1037 */
1038 string cacheDir = g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR +
1039 "/" + DBConstant::CACHEDB_DIR + "/" + DBConstant::SINGLE_VER_CACHE_STORE + DBConstant::DB_EXTENSION;
1040 EXPECT_EQ(g_handle->ForceCheckPoint(), E_OK);
1041 EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName, cacheDir), E_OK);
1042 CipherPassword password;
1043 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1044 CipherType::DEFAULT, password, cacheDir, EngineState::MAINDB), E_OK);
1045
1046 /**
1047 * @tc.steps: step2. Migrate sync data but param incomplete
1048 */
1049 NotifyMigrateSyncData syncData;
1050 DataItem dataItem;
1051 std::vector<DataItem> items;
1052 items.push_back(dataItem);
1053 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
1054 Timestamp timestamp;
1055 EXPECT_EQ(g_handle->GetMaxTimestampDuringMigrating(timestamp), E_OK);
1056 items.front().neglect = true;
1057 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1058 items.front().neglect = false;
1059 items.front().flag = DataItem::REMOVE_DEVICE_DATA_FLAG;
1060 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
1061 items.front().key = {'r', 'e', 'm', 'o', 'v', 'e'};
1062 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1063 items.front().flag = DataItem::REMOVE_DEVICE_DATA_NOTIFY_FLAG;
1064 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1065 items.front().flag = DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
1066 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_DB);
1067 string selectSync = "SELECT * FROM sync_data";
1068 Value value;
1069 value.assign(selectSync.begin(), selectSync.end());
1070 items.front().value = value;
1071 items.front().flag = DataItem::REMOVE_DEVICE_DATA_NOTIFY_FLAG;
1072 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1073 EXPECT_EQ(g_handle->MigrateLocalData(), E_OK);
1074
1075 /**
1076 * @tc.steps: step3. Attach maindb
1077 */
1078 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1079 CipherType::DEFAULT, password, cacheDir, EngineState::CACHEDB), E_OK);
1080 EXPECT_EQ(g_handle->MigrateLocalData(), E_OK);
1081 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_BUSY);
1082
1083 sqlite3 *db = nullptr;
1084 ASSERT_EQ(g_handle->GetDbHandle(db), E_OK);
1085 sqlite3_stmt *stmt = nullptr;
1086 ASSERT_EQ(SQLiteUtils::GetStatement(db, MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_CACHEHANDLE, stmt), E_OK);
1087 int errCode = E_OK;
1088 EXPECT_EQ(SQLiteUtils::BindBlobToStatement(stmt, BIND_SYNC_UPDATE_HASH_KEY_INDEX, {}), E_OK);
1089 SQLiteUtils::ResetStatement(stmt, true, errCode);
1090 EXPECT_EQ(errCode, E_OK);
1091 }
1092
1093 /**
1094 * @tc.name: ExecutorCache005
1095 * @tc.desc: Alter table then save data in cache mode
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 * @tc.author: bty
1099 */
1100 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache005, TestSize.Level1)
1101 {
1102 g_store->ReleaseHandle(g_handle);
1103 sqlite3 *db = nullptr;
1104 ASSERT_TRUE(sqlite3_open_v2((g_testDir + g_databaseName).c_str(),
1105 &db, SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) == SQLITE_OK);
1106 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_LOCAL) == E_OK);
1107 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_SYNC) == E_OK);
1108 auto executor = std::make_unique<SQLiteSingleVerStorageExecutor>(db, false, false);
1109 ASSERT_NE(executor, nullptr);
1110 LocalDataItem item;
1111 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), -E_INVALID_ARGS);
1112 item.hashKey = KEY_1;
1113 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), -E_INVALID_ARGS);
1114 item.flag = DataItem::DELETE_FLAG;
1115 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), E_OK);
1116 Query query = Query::Select();
1117 QueryObject object(query);
1118 DataItem dataItem;
1119 dataItem.flag = DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
1120 DeviceInfo info;
1121 Timestamp maxTime;
1122 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), -E_INVALID_ARGS);
1123 dataItem.key = KEY_1;
1124 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), E_OK);
1125 dataItem.flag = DataItem::DELETE_FLAG;
1126 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), E_OK);
1127 sqlite3_close_v2(db);
1128 }
1129
1130 /**
1131 * @tc.name: AbnormalSqlExecutorTest001
1132 * @tc.desc: Check SQLiteStorageExecutor interfaces abnormal scene.
1133 * @tc.type: FUNC
1134 * @tc.require:
1135 * @tc.author: suyue
1136 */
1137 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest001, TestSize.Level1)
1138 {
1139 /**
1140 * @tc.steps: step1. Call interfaces when db and para is invalid.
1141 * @tc.expected: step1. return errorCode.
1142 */
1143 SQLiteStorageExecutor storageObj(nullptr, true, true);
1144 EXPECT_EQ(storageObj.Reset(), -E_INVALID_DB);
1145 sqlite3 *dbHandle = nullptr;
1146 EXPECT_EQ(storageObj.GetDbHandle(dbHandle), -E_NOT_FOUND);
1147 SqliteMetaExecutor metaObj;
1148 std::vector<Key> keys;
1149 int ret = metaObj.GetAllKeys(nullptr, true, keys);
1150 EXPECT_EQ(ret, -E_INVALID_DB);
1151
1152 /**
1153 * @tc.steps: step2. Call GetMetaKeysByKeyPrefix interface when para metaMode is not in enum class MetaMode.
1154 * @tc.expected: step2. return -E_INVALID_ARGS.
1155 */
1156 std::set<std::string> outKeys;
1157 int metaMode = 10; // set metaMode to 10 not in enum class MetaMode
1158 ret = metaObj.GetMetaKeysByKeyPrefix("", nullptr,
1159 static_cast<SqliteMetaExecutor::MetaMode>(metaMode), true, outKeys);
1160 EXPECT_EQ(ret, -E_INVALID_ARGS);
1161 }
1162
1163 /**
1164 * @tc.name: AbnormalSqlExecutorTest002
1165 * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 * @tc.author: suyue
1169 */
1170 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest002, TestSize.Level1)
1171 {
1172 /**
1173 * @tc.steps: step1. Call interfaces when db is null.
1174 * @tc.expected: step1. return -E_INVALID_DB.
1175 */
1176 const std::vector<std::string> vec = {"test"};
1177 int ret = g_nullHandle->RemoveTrigger(vec);
1178 EXPECT_EQ(ret, -E_INVALID_DB);
1179 ret = g_nullHandle->RemoveSubscribeTriggerWaterMark(vec);
1180 EXPECT_EQ(ret, -E_INVALID_DB);
1181 std::vector<std::string> triggerNames;
1182 ret = g_nullHandle->GetTriggers("", triggerNames);
1183 EXPECT_EQ(ret, -E_INVALID_DB);
1184 std::vector<Entry> entries;
1185 ret = g_nullHandle->GetEntries("", entries);
1186 EXPECT_EQ(ret, -E_INVALID_DB);
1187 ret = g_nullHandle->RemoveDeviceData("", ClearMode::DEFAULT);
1188 EXPECT_EQ(ret, -E_INVALID_DB);
1189 ret = g_nullHandle->RemoveDeviceData("", "", ClearMode::FLAG_AND_DATA);
1190 EXPECT_EQ(ret, -E_INVALID_DB);
1191 const Key keyPrefix;
1192 SingleVerRecord result;
1193 ret = g_nullHandle->GetKvDataByHashKey(keyPrefix, result);
1194 EXPECT_EQ(ret, -E_INVALID_DB);
1195 ret = g_nullHandle->EraseSyncData(keyPrefix);
1196 EXPECT_EQ(ret, -E_INVALID_DB);
1197 ret = g_nullHandle->UpdateKey(nullptr);
1198 EXPECT_EQ(ret, -E_INVALID_DB);
1199 ret = g_nullHandle->CreateCloudLogTable();
1200 EXPECT_EQ(ret, -E_INVALID_DB);
1201 }
1202
1203 /**
1204 * @tc.name: AbnormalSqlExecutorTest003
1205 * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
1206 * @tc.type: FUNC
1207 * @tc.require:
1208 * @tc.author: suyue
1209 */
1210 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest003, TestSize.Level1)
1211 {
1212 /**
1213 * @tc.steps: step1. Call interfaces with invalid para.
1214 * @tc.expected: step1. return errCode.
1215 */
1216 QueryObjNode node;
1217 const std::list<QueryObjNode> queryObjNodes = {node};
1218 const std::vector<uint8_t> prefixKey;
1219 const std::set<Key> keys;
1220 QueryObject queryObj(queryObjNodes, prefixKey, keys);
1221 int ret = g_handle->AddSubscribeTrigger(queryObj, "");
1222 EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
1223 ret = g_handle->ReloadResultSet(queryObj);
1224 EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
1225 Entry entry;
1226 ret = g_nullHandle->GetEntryByRowId(0, entry);
1227 EXPECT_EQ(ret, -E_RESULT_SET_STATUS_INVALID);
1228
1229 /**
1230 * @tc.steps: step2. Call AddSubscribeTrigger interface when executorState is CACHEDB.
1231 * @tc.expected: step2. return -E_EKEYREVOKED.
1232 */
1233 SQLiteSingleVerStorageExecutor obj(nullptr, true, true, ExecutorState::CACHEDB);
1234 QueryObject query;
1235 ret = obj.AddSubscribeTrigger(query, "");
1236 EXPECT_EQ(ret, -E_EKEYREVOKED);
1237 }
1238