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