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 uint64_t val = 0x400000ULL;
797 PragmaData logLimit = static_cast<PragmaData>(&val);
798 EXPECT_EQ(g_connection->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, logLimit), OK);
799 EXPECT_EQ(g_connection->Pragma(PRAGMA_GET_IDENTIFIER_OF_DEVICE, nullptr), -E_INVALID_ARGS);
800 EXPECT_EQ(g_connection->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, logLimit), OK);
801
802 /**
803 * @tc.steps: step2. the option is invalid
804 * @tc.expected: step2. Expect -E_INVALID_ARGS
805 */
806 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
807 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
808 ASSERT_NE(emptyConn, nullptr);
809 SecurityOption option = {S3, SECE};
810 EXPECT_EQ(emptyConn->Pragma(PRAGMA_TRIGGER_TO_MIGRATE_DATA, &option), -E_INVALID_CONNECTION);
811
812 /**
813 * @tc.steps: step3. the size is invalid
814 * @tc.expected: step3. Expect -E_INVALID_ARGS
815 */
816 int size = 0;
817 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MAX_SIZE, &size), -E_INVALID_ARGS);
818 size = 1;
819 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MAX_SIZE, &size), E_OK);
820
821 /**
822 * @tc.steps: step4. the mode is invalid
823 * @tc.expected: step4. Expect -E_INVALID_ARGS
824 */
825 ResultSetCacheMode mode = ResultSetCacheMode(2); // 2 is invalid mode
826 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RESULT_SET_CACHE_MODE, &mode), -E_INVALID_ARGS);
827
828 /**
829 * @tc.steps: step5. the db is null
830 * @tc.expected: step5. Expect -E_INVALID_DB
831 */
832 int time = 6000; // 6000 is random
833 EXPECT_EQ(emptyConn->Pragma(PRAGMA_SET_AUTO_LIFE_CYCLE, &time), -E_INVALID_DB);
834 }
835
836 /**
837 * @tc.name: PragmaTest002
838 * @tc.desc: Incorrect publishing and unPublishing
839 * @tc.type: FUNC
840 * @tc.require:
841 * @tc.author: bty
842 */
843 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, PragmaTest002, TestSize.Level1)
844 {
845 /**
846 * @tc.steps: step1. the db is null
847 * @tc.expected: step1. Expect -E_INVALID_DB
848 */
849 std::unique_ptr<SQLiteSingleVerNaturalStoreConnection> emptyConn =
850 std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
851 PragmaPublishInfo info;
852 EXPECT_EQ(emptyConn->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_INVALID_DB);
853 EXPECT_EQ(emptyConn->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_INVALID_DB);
854
855 /**
856 * @tc.steps: step2. publish in transaction
857 * @tc.expected: step2. Expect -E_NOT_SUPPORT
858 */
859 g_store->ReleaseHandle(g_handle);
860 g_connection->StartTransaction();
861 EXPECT_EQ(g_connection->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_NOT_SUPPORT);
862 EXPECT_EQ(g_connection->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_NOT_SUPPORT);
863 g_connection->RollBack();
864
865 /**
866 * @tc.steps: step3. publish in cacheDB
867 * @tc.expected: step3. Expect -E_EKEYREVOKED
868 */
869 int errCode = E_OK;
870 SQLiteSingleVerStorageEngine *storageEngine =
871 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
872 ASSERT_EQ(errCode, E_OK);
873 ASSERT_NE(storageEngine, nullptr);
874 storageEngine->SetEngineState(EngineState::CACHEDB);
875 EXPECT_EQ(g_connection->Pragma(PRAGMA_PUBLISH_LOCAL, &info), -E_EKEYREVOKED);
876 EXPECT_EQ(g_connection->Pragma(PRAGMA_UNPUBLISH_SYNC, &info), -E_EKEYREVOKED);
877 g_connection->StartTransaction();
878 g_connection->Commit();
879 storageEngine->Release();
880 }
881
882 /**
883 * @tc.name: PragmaTest003
884 * @tc.desc: Failed to call function with empty connection
885 * @tc.type: FUNC
886 * @tc.require:
887 * @tc.author: bty
888 */
889 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, PragmaTest003, TestSize.Level1)
890 {
891 auto emptyConn = std::make_unique<SQLiteSingleVerNaturalStoreConnection>(nullptr);
892 PragmaEntryDeviceIdentifier identifier = {.key = KEY_1};
893 EXPECT_EQ(emptyConn->Pragma(PRAGMA_GET_DEVICE_IDENTIFIER_OF_ENTRY, &identifier), -E_NOT_INIT);
894 EXPECT_EQ(emptyConn->Pragma(PRAGMA_EXEC_CHECKPOINT, nullptr), -E_NOT_INIT);
895 EXPECT_EQ(emptyConn->CheckIntegrity(), -E_NOT_INIT);
896
897 int limit = 0;
898 EXPECT_EQ(emptyConn->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, &limit), -E_INVALID_DB);
899 EXPECT_EQ(emptyConn->Pragma(PRAGMA_RM_DEVICE_DATA, nullptr), -E_INVALID_DB);
900 CipherPassword pw;
901 EXPECT_EQ(emptyConn->Import("/a.b", pw), -E_INVALID_DB);
902 EXPECT_EQ(emptyConn->Export("/a.b", pw), -E_INVALID_DB);
903 DatabaseLifeCycleNotifier notifier;
904 EXPECT_EQ(emptyConn->RegisterLifeCycleCallback(notifier), -E_INVALID_DB);
905
906 EXPECT_EQ(emptyConn->SetConflictNotifier(0, nullptr), -E_INVALID_ARGS);
__anonb2168be90202(const KvDBCommitNotifyData &data) 907 KvDBConflictAction func = [&](const KvDBCommitNotifyData &data) {};
908 EXPECT_EQ(emptyConn->SetConflictNotifier(0, func), -E_INVALID_DB);
909 IKvDBSnapshot *shot;
910 EXPECT_EQ(emptyConn->GetSnapshot(shot), -E_NOT_SUPPORT);
911 }
912
913 /**
914 * @tc.name: ExecutorCache001
915 * @tc.desc: Fail to operate data
916 * @tc.type: FUNC
917 * @tc.require:
918 * @tc.author: bty
919 */
920 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache001, TestSize.Level1)
921 {
922 g_handle->SetAttachMetaMode(true);
923 std::set<std::string> devices;
924 EXPECT_EQ(g_handle->GetExistsDevicesFromMeta(devices), SQL_STATE_ERR);
925 EXPECT_EQ(g_handle->DeleteMetaDataByPrefixKey(KEY_1), SQL_STATE_ERR);
926 std::vector<Key> keys;
927 EXPECT_EQ(g_handle->DeleteMetaData(keys), SQL_STATE_ERR);
928 EXPECT_EQ(g_handle->PrepareForSavingCacheData(SingleVerDataType::LOCAL_TYPE_SQLITE), SQL_STATE_ERR);
929 std::string hashDev = DBCommon::TransferHashString("device1");
930 EXPECT_EQ(g_handle->RemoveDeviceDataInCacheMode(hashDev, true, 0u), SQL_STATE_ERR);
931 Timestamp timestamp;
932 EXPECT_EQ(g_handle->GetMaxTimestampDuringMigrating(timestamp), -E_NOT_INIT);
933 EXPECT_EQ(g_handle->ResetForSavingCacheData(SingleVerDataType::LOCAL_TYPE_SQLITE), E_OK);
934 }
935
936 /**
937 * @tc.name: ExecutorCache002
938 * @tc.desc: Fail to call func in each ExecutorState
939 * @tc.type: FUNC
940 * @tc.require:
941 * @tc.author: bty
942 */
943 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache002, TestSize.Level1)
944 {
945 /**
946 * @tc.steps: step1. In MAINDB
947 * @tc.expected: step1. Expect not E_OK
948 */
949 NotifyMigrateSyncData syncData;
950 DataItem dataItem;
951 std::vector<DataItem> items;
952 items.push_back(dataItem);
953 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_DB);
954 uint64_t version;
955 EXPECT_EQ(g_handle->GetMinVersionCacheData(items, version), -E_INVALID_ARGS);
956 EXPECT_EQ(g_handle->GetMaxVersionInCacheDb(version), -E_INVALID_ARGS);
957 EXPECT_EQ(g_handle->MigrateLocalData(), -E_INVALID_ARGS);
958
959 /**
960 * @tc.steps: step2. Change executor to CACHE_ATTACH_MAIN
961 * @tc.expected: step2. Expect SQL_STATE_ERR
962 */
963 sqlite3 *sqlHandle = nullptr;
964 EXPECT_EQ(SQLiteUtils::OpenDatabase({g_testDir + g_databaseName, false, false}, sqlHandle), E_OK);
965 ASSERT_NE(sqlHandle, nullptr);
966 auto executor = std::make_unique<SQLiteSingleVerStorageExecutor>(
967 sqlHandle, false, false, ExecutorState::CACHE_ATTACH_MAIN);
968 ASSERT_NE(executor, nullptr);
969 EXPECT_EQ(executor->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
970 EXPECT_EQ(executor->GetMinVersionCacheData(items, version), SQL_STATE_ERR);
971 EXPECT_EQ(executor->GetMaxVersionInCacheDb(version), SQL_STATE_ERR);
972 EXPECT_EQ(executor->MigrateLocalData(), SQL_STATE_ERR);
973 executor->SetAttachMetaMode(true);
974 EXPECT_EQ(executor->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
975
976 /**
977 * @tc.steps: step3. Change executor to MAIN_ATTACH_CACHE
978 */
979 auto executor2 = std::make_unique<SQLiteSingleVerStorageExecutor>(
980 sqlHandle, false, false, ExecutorState::MAIN_ATTACH_CACHE);
981 ASSERT_NE(executor2, nullptr);
982 items.clear();
983 EXPECT_EQ(executor2->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
984 items.push_back(dataItem);
985 EXPECT_EQ(executor2->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
986 EXPECT_EQ(executor2->GetMinVersionCacheData(items, version), SQL_STATE_ERR);
987 EXPECT_EQ(executor2->GetMaxVersionInCacheDb(version), SQL_STATE_ERR);
988 EXPECT_EQ(executor2->MigrateLocalData(), SQL_STATE_ERR);
989 sqlite3_close_v2(sqlHandle);
990 sqlHandle = nullptr;
991 }
992
993 /**
994 * @tc.name: ExecutorCache003
995 * @tc.desc: Test different condition to attach db
996 * @tc.type: FUNC
997 * @tc.require:
998 * @tc.author: bty
999 */
1000 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache003, TestSize.Level1)
1001 {
1002 /**
1003 * @tc.steps: step1. Copy empty db, then attach
1004 */
1005 string cacheDir = g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR +
1006 "/" + DBConstant::CACHEDB_DIR + "/" + DBConstant::SINGLE_VER_CACHE_STORE + DBConstant::DB_EXTENSION;
1007 EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName, cacheDir), E_OK);
1008 CipherPassword password;
1009 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1010 CipherType::DEFAULT, password, cacheDir, EngineState::INVALID), -E_INVALID_ARGS);
1011 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1012 CipherType::DEFAULT, password, cacheDir, EngineState::CACHEDB), -E_INVALID_DB);
1013 EXPECT_EQ(g_nullHandle->AttachMainDbAndCacheDb(
1014 CipherType::DEFAULT, password, cacheDir, EngineState::ATTACHING), E_OK);
1015 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1016 CipherType::DEFAULT, password, cacheDir, EngineState::MAINDB), E_OK);
1017
1018 /**
1019 * @tc.steps: step2. Try migrate data after attaching cache
1020 * @tc.expected: step2. Expect SQL_STATE_ERR
1021 */
1022 NotifyMigrateSyncData syncData;
1023 DataItem dataItem;
1024 std::vector<DataItem> items;
1025 items.push_back(dataItem);
1026 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1027 }
1028
1029 /**
1030 * @tc.name: ExecutorCache004
1031 * @tc.desc: Test migrate after attaching
1032 * @tc.type: FUNC
1033 * @tc.require:
1034 * @tc.author: bty
1035 */
1036 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache004, TestSize.Level1)
1037 {
1038 /**
1039 * @tc.steps: step1. Copy normal db, attach cache
1040 * @tc.expected: step1. Expect E_OK
1041 */
1042 string cacheDir = g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR +
1043 "/" + DBConstant::CACHEDB_DIR + "/" + DBConstant::SINGLE_VER_CACHE_STORE + DBConstant::DB_EXTENSION;
1044 EXPECT_EQ(g_handle->ForceCheckPoint(), E_OK);
1045 EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName, cacheDir), E_OK);
1046 CipherPassword password;
1047 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1048 CipherType::DEFAULT, password, cacheDir, EngineState::MAINDB), E_OK);
1049
1050 /**
1051 * @tc.steps: step2. Migrate sync data but param incomplete
1052 */
1053 NotifyMigrateSyncData syncData;
1054 DataItem dataItem;
1055 std::vector<DataItem> items;
1056 items.push_back(dataItem);
1057 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
1058 Timestamp timestamp;
1059 EXPECT_EQ(g_handle->GetMaxTimestampDuringMigrating(timestamp), E_OK);
1060 items.front().neglect = true;
1061 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1062 items.front().neglect = false;
1063 items.front().flag = DataItem::REMOVE_DEVICE_DATA_FLAG;
1064 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_ARGS);
1065 items.front().key = {'r', 'e', 'm', 'o', 'v', 'e'};
1066 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1067 items.front().flag = DataItem::REMOVE_DEVICE_DATA_NOTIFY_FLAG;
1068 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1069 items.front().flag = DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
1070 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_INVALID_DB);
1071 string selectSync = "SELECT * FROM sync_data";
1072 Value value;
1073 value.assign(selectSync.begin(), selectSync.end());
1074 items.front().value = value;
1075 items.front().flag = DataItem::REMOVE_DEVICE_DATA_NOTIFY_FLAG;
1076 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), SQL_STATE_ERR);
1077 EXPECT_EQ(g_handle->MigrateLocalData(), E_OK);
1078
1079 /**
1080 * @tc.steps: step3. Attach maindb
1081 */
1082 EXPECT_EQ(g_handle->AttachMainDbAndCacheDb(
1083 CipherType::DEFAULT, password, cacheDir, EngineState::CACHEDB), E_OK);
1084 EXPECT_EQ(g_handle->MigrateLocalData(), E_OK);
1085 EXPECT_EQ(g_handle->MigrateSyncDataByVersion(0u, syncData, items), -E_BUSY);
1086
1087 sqlite3 *db = nullptr;
1088 ASSERT_EQ(g_handle->GetDbHandle(db), E_OK);
1089 sqlite3_stmt *stmt = nullptr;
1090 ASSERT_EQ(SQLiteUtils::GetStatement(db, MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_CACHEHANDLE, stmt), E_OK);
1091 int errCode = E_OK;
1092 EXPECT_EQ(SQLiteUtils::BindBlobToStatement(stmt, BIND_SYNC_UPDATE_HASH_KEY_INDEX, {}), E_OK);
1093 SQLiteUtils::ResetStatement(stmt, true, errCode);
1094 EXPECT_EQ(errCode, E_OK);
1095 }
1096
1097 /**
1098 * @tc.name: ExecutorCache005
1099 * @tc.desc: Alter table then save data in cache mode
1100 * @tc.type: FUNC
1101 * @tc.require:
1102 * @tc.author: bty
1103 */
1104 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache005, TestSize.Level1)
1105 {
1106 g_store->ReleaseHandle(g_handle);
1107 sqlite3 *db = nullptr;
1108 ASSERT_TRUE(sqlite3_open_v2((g_testDir + g_databaseName).c_str(),
1109 &db, SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) == SQLITE_OK);
1110 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_LOCAL) == E_OK);
1111 ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_SYNC) == E_OK);
1112 auto executor = std::make_unique<SQLiteSingleVerStorageExecutor>(db, false, false);
1113 ASSERT_NE(executor, nullptr);
1114 LocalDataItem item;
1115 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), -E_INVALID_ARGS);
1116 item.hashKey = KEY_1;
1117 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), -E_INVALID_ARGS);
1118 item.flag = DataItem::DELETE_FLAG;
1119 EXPECT_EQ(executor->PutLocalDataToCacheDB(item), E_OK);
1120 Query query = Query::Select();
1121 QueryObject object(query);
1122 DataItem dataItem;
1123 dataItem.flag = DataItem::REMOTE_DEVICE_DATA_MISS_QUERY;
1124 DeviceInfo info;
1125 Timestamp maxTime;
1126 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), -E_INVALID_ARGS);
1127 dataItem.key = KEY_1;
1128 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), E_OK);
1129 dataItem.flag = DataItem::DELETE_FLAG;
1130 EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), E_OK);
1131 sqlite3_close_v2(db);
1132 }
1133
1134 /**
1135 * @tc.name: AbnormalSqlExecutorTest001
1136 * @tc.desc: Check SQLiteStorageExecutor interfaces abnormal scene.
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 * @tc.author: suyue
1140 */
1141 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest001, TestSize.Level1)
1142 {
1143 /**
1144 * @tc.steps: step1. Call interfaces when db and para is invalid.
1145 * @tc.expected: step1. return errorCode.
1146 */
1147 SQLiteStorageExecutor storageObj(nullptr, true, true);
1148 EXPECT_EQ(storageObj.Reset(), -E_INVALID_DB);
1149 sqlite3 *dbHandle = nullptr;
1150 EXPECT_EQ(storageObj.GetDbHandle(dbHandle), -E_NOT_FOUND);
1151 SqliteMetaExecutor metaObj;
1152 std::vector<Key> keys;
1153 int ret = metaObj.GetAllKeys(nullptr, true, keys);
1154 EXPECT_EQ(ret, -E_INVALID_DB);
1155
1156 /**
1157 * @tc.steps: step2. Call GetMetaKeysByKeyPrefix interface when para metaMode is not in enum class MetaMode.
1158 * @tc.expected: step2. return -E_INVALID_ARGS.
1159 */
1160 std::set<std::string> outKeys;
1161 int metaMode = 10; // set metaMode to 10 not in enum class MetaMode
1162 ret = metaObj.GetMetaKeysByKeyPrefix("", nullptr,
1163 static_cast<SqliteMetaExecutor::MetaMode>(metaMode), true, outKeys);
1164 EXPECT_EQ(ret, -E_INVALID_ARGS);
1165 }
1166
1167 /**
1168 * @tc.name: AbnormalSqlExecutorTest002
1169 * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
1170 * @tc.type: FUNC
1171 * @tc.require:
1172 * @tc.author: suyue
1173 */
1174 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest002, TestSize.Level1)
1175 {
1176 /**
1177 * @tc.steps: step1. Call interfaces when db is null.
1178 * @tc.expected: step1. return -E_INVALID_DB.
1179 */
1180 const std::vector<std::string> vec = {"test"};
1181 int ret = g_nullHandle->RemoveTrigger(vec);
1182 EXPECT_EQ(ret, -E_INVALID_DB);
1183 ret = g_nullHandle->RemoveSubscribeTriggerWaterMark(vec);
1184 EXPECT_EQ(ret, -E_INVALID_DB);
1185 std::vector<std::string> triggerNames;
1186 ret = g_nullHandle->GetTriggers("", triggerNames);
1187 EXPECT_EQ(ret, -E_INVALID_DB);
1188 std::vector<Entry> entries;
1189 ret = g_nullHandle->GetEntries("", entries);
1190 EXPECT_EQ(ret, -E_INVALID_DB);
1191 ret = g_nullHandle->RemoveDeviceData("", ClearMode::DEFAULT);
1192 EXPECT_EQ(ret, -E_INVALID_DB);
1193 ret = g_nullHandle->RemoveDeviceData("", "", ClearMode::FLAG_AND_DATA);
1194 EXPECT_EQ(ret, -E_INVALID_DB);
1195 const Key keyPrefix;
1196 SingleVerRecord result;
1197 ret = g_nullHandle->GetKvDataByHashKey(keyPrefix, result);
1198 EXPECT_EQ(ret, -E_INVALID_DB);
1199 ret = g_nullHandle->EraseSyncData(keyPrefix);
1200 EXPECT_EQ(ret, -E_INVALID_DB);
1201 ret = g_nullHandle->UpdateKey(nullptr);
1202 EXPECT_EQ(ret, -E_INVALID_DB);
1203 ret = g_nullHandle->CreateCloudLogTable();
1204 EXPECT_EQ(ret, -E_INVALID_DB);
1205 }
1206
1207 /**
1208 * @tc.name: AbnormalSqlExecutorTest003
1209 * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
1210 * @tc.type: FUNC
1211 * @tc.require:
1212 * @tc.author: suyue
1213 */
1214 HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest003, TestSize.Level1)
1215 {
1216 /**
1217 * @tc.steps: step1. Call interfaces with invalid para.
1218 * @tc.expected: step1. return errCode.
1219 */
1220 QueryObjNode node;
1221 const std::list<QueryObjNode> queryObjNodes = {node};
1222 const std::vector<uint8_t> prefixKey;
1223 const std::set<Key> keys;
1224 QueryObject queryObj(queryObjNodes, prefixKey, keys);
1225 int ret = g_handle->AddSubscribeTrigger(queryObj, "");
1226 EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
1227 ret = g_handle->ReloadResultSet(queryObj);
1228 EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
1229 Entry entry;
1230 ret = g_nullHandle->GetEntryByRowId(0, entry);
1231 EXPECT_EQ(ret, -E_RESULT_SET_STATUS_INVALID);
1232
1233 /**
1234 * @tc.steps: step2. Call AddSubscribeTrigger interface when executorState is CACHEDB.
1235 * @tc.expected: step2. return -E_EKEYREVOKED.
1236 */
1237 SQLiteSingleVerStorageExecutor obj(nullptr, true, true, ExecutorState::CACHEDB);
1238 QueryObject query;
1239 ret = obj.AddSubscribeTrigger(query, "");
1240 EXPECT_EQ(ret, -E_EKEYREVOKED);
1241 }
1242