1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <thread>
18 #include <fcntl.h>
19
20 #include "db_common.h"
21 #include "db_constant.h"
22 #include "db_errno.h"
23 #include "distributeddb_data_generate_unit_test.h"
24 #include "kv_store_nb_delegate_impl.h"
25 #include "platform_specific.h"
26 #include "process_system_api_adapter_impl.h"
27 #include "sqlite_single_ver_natural_store.h"
28 #include "sqlite_single_ver_natural_store_connection.h"
29 #include "storage_engine_manager.h"
30
31 using namespace testing::ext;
32 using namespace DistributedDB;
33 using namespace DistributedDBUnitTest;
34 using namespace std;
35
36 namespace {
37 string g_testDir;
38 KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
39 KvStoreConfig g_config;
40 KvDBProperties g_property;
41 KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
42 DBStatus g_kvDelegateStatus = INVALID_ARGS;
43 SQLiteSingleVerNaturalStore *g_store = nullptr;
44 DistributedDB::SQLiteSingleVerNaturalStoreConnection *g_connection = nullptr;
45 const string STORE_ID = STORE_ID_SYNC;
46 const int TIME_LAG = 100;
47 const std::string DEVICE_ID_1 = "ABC";
48 auto g_kvNbDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback,
49 placeholders::_1, placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvNbDelegatePtr));
50 }
51
52 class DistributedDBDeviceIdentifierTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55 static void TearDownTestCase(void);
56 void SetUp();
57 void TearDown();
58 };
59
SetUpTestCase(void)60 void DistributedDBDeviceIdentifierTest::SetUpTestCase(void)
61 {
62 DistributedDBToolsUnitTest::TestDirInit(g_testDir);
63 g_config.dataDir = g_testDir;
64 g_mgr.SetKvStoreConfig(g_config);
65
66 string dir = g_testDir + STORE_ID + "/" + DBConstant::SINGLE_SUB_DIR;
67 DIR *dirTmp = opendir(dir.c_str());
68 if (dirTmp == nullptr) {
69 OS::MakeDBDirectory(dir);
70 } else {
71 closedir(dirTmp);
72 }
73 g_property.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
74 g_property.SetStringProp(KvDBProperties::STORE_ID, STORE_ID);
75 g_property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
76 }
77
TearDownTestCase(void)78 void DistributedDBDeviceIdentifierTest::TearDownTestCase(void)
79 {
80 if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + STORE_ID + "/" + DBConstant::SINGLE_SUB_DIR) != 0) {
81 LOGE("rm test db files error!");
82 }
83 RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(nullptr);
84 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_LAG));
85 }
86
SetUp(void)87 void DistributedDBDeviceIdentifierTest::SetUp(void)
88 {
89 DistributedDBToolsUnitTest::PrintTestCaseInfo();
90 KvStoreNbDelegate::Option option = {true, false, false};
91 g_mgr.GetKvStore(STORE_ID, option, g_kvNbDelegateCallback);
92 EXPECT_TRUE(g_kvDelegateStatus == OK);
93 ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
94
95 g_store = new (std::nothrow) SQLiteSingleVerNaturalStore;
96 ASSERT_NE(g_store, nullptr);
97 ASSERT_EQ(g_store->Open(g_property), E_OK);
98
99 int erroCode = E_OK;
100 g_connection = static_cast<SQLiteSingleVerNaturalStoreConnection *>(g_store->GetDBConnection(erroCode));
101 ASSERT_NE(g_connection, nullptr);
102 RefObject::DecObjRef(g_store);
103 EXPECT_EQ(erroCode, E_OK);
104 }
105
TearDown(void)106 void DistributedDBDeviceIdentifierTest::TearDown(void)
107 {
108 if (g_connection != nullptr) {
109 g_connection->Close();
110 }
111
112 g_store = nullptr;
113
114 if (g_kvNbDelegatePtr != nullptr) {
115 EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
116 g_kvNbDelegatePtr = nullptr;
117 EXPECT_TRUE(g_mgr.DeleteKvStore(STORE_ID) == OK);
118 }
119 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_LAG));
120 }
121
122 /**
123 * @tc.name: DeviceIdentifier001
124 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY,
125 * set Key to be null and origDevice to be false, expect return INVALID_ARGS.
126 * @tc.type: FUNC
127 * @tc.require:
128 * @tc.author: maokeheng
129 */
130 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier001, TestSize.Level1)
131 {
132 /**
133 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
134 * @tc.expected: step1. Expect return true.
135 */
136 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
137
138 /**
139 * @tc.steps:step2. Set PragmaCmd to be GET_DEVICE_IDENTIFIER_OF_ENTRY, and set input key to be null
140 * @tc.expected: step2. Expect return INVALID_ARGS.
141 */
142 Key keyNull;
143 PragmaEntryDeviceIdentifier param;
144 param.key = keyNull;
145 param.origDevice = false;
146 PragmaData input = static_cast<void *>(¶m);
147 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), INVALID_ARGS);
148 }
149
150 /**
151 * @tc.name: DeviceIdentifier002
152 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY,
153 * set Key to be null and origDevice to be true, expect return INVALID_ARGS.
154 * @tc.type: FUNC
155 * @tc.require:
156 * @tc.author: maokeheng
157 */
158 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier002, TestSize.Level1)
159 {
160 /**
161 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
162 * @tc.expected: step1. Expect return true.
163 */
164 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
165
166 /**
167 * @tc.steps:step2. Set PragmaCmd to be GET_DEVICE_IDENTIFIER_OF_ENTRY, and set input key to be null
168 * @tc.expected: step2. Expect return INVALID_ARGS.
169 */
170 Key keyNull;
171 PragmaEntryDeviceIdentifier param;
172 param.key = keyNull;
173 param.origDevice = true;
174 PragmaData input = static_cast<void *>(¶m);
175 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), INVALID_ARGS);
176 }
177
178 /**
179 * @tc.name: DeviceIdentifier003
180 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY and origDevice to be false.
181 * Check if a non-existing key will return NOT_FOUND.
182 * @tc.type: FUNC
183 * @tc.require:
184 * @tc.author: maokeheng
185 */
186 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier003, TestSize.Level1)
187 {
188 /**
189 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
190 * @tc.expected: step1. Expect return true.
191 */
192 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
193 /**
194 * @tc.steps:step2. Set PragmaCmd to be GET_DEVICE_IDENTIFIER_OF_ENTRY, and set Key= Key_2
195 * @tc.expected: step2. Expect return NOT_FOUND.
196 */
197 PragmaEntryDeviceIdentifier param;
198 param.key = KEY_2;
199 param.origDevice = false;
200 PragmaData input = static_cast<void *>(¶m);
201 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), NOT_FOUND);
202 }
203
204 /**
205 * @tc.name: DeviceIdentifier004
206 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY and origDevice to be true.
207 * Check if a non-existing key will return NOT_FOUND.
208 * @tc.type: FUNC
209 * @tc.require:
210 * @tc.author: maokeheng
211 */
212 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier004, TestSize.Level1)
213 {
214 /**
215 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
216 * @tc.expected: step1. Expect return true.
217 */
218 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
219 /**
220 * @tc.steps:step2. Set PragmaCmd to be GET_DEVICE_IDENTIFIER_OF_ENTRY, and set Key= Key_2
221 * @tc.expected: step2. Expect return NOT_FOUND.
222 */
223 PragmaEntryDeviceIdentifier param;
224 param.key = KEY_2;
225 param.origDevice = true;
226 PragmaData input = static_cast<void *>(¶m);
227 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), NOT_FOUND);
228 }
229
230 /**
231 * @tc.name: DeviceIdentifier005
232 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY and origDevice to be false. check if returns OK.
233 * @tc.type: FUNC
234 * @tc.require:
235 * @tc.author: maokeheng
236 */
237 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier005, TestSize.Level1)
238 {
239 /**
240 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
241 * @tc.expected: step1. Expect return true.
242 */
243 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
244 /**
245 * @tc.steps:step2. Set PragmaCmd = GET_DEVICE_IDENTIFIER_OF_ENTRY, Key= Key_1, origDevice = false.
246 * @tc.expected: step2. Expect return deviceIdentifier is the same as deviceIdentifier of DEVICE_B.
247 */
248 PragmaEntryDeviceIdentifier param;
249 param.key = KEY_1;
250 param.origDevice = false;
251 PragmaData input = static_cast<void *>(¶m);
252 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), OK);
253 }
254
255 /**
256 * @tc.name: DeviceIdentifier006
257 * @tc.desc: Set pragma to be GET_DEVICE_IDENTIFIER_OF_ENTRY and origDevice to be true. check if returns OK.
258 * @tc.type: FUNC
259 * @tc.require:
260 * @tc.author: maokeheng
261 */
262 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier006, TestSize.Level1)
263 {
264 /**
265 * @tc.steps:step1. Sync 1K data from DEVICE_B into database, with Key= KEY_1, and Value = VALUE_1.
266 * @tc.expected: step1. Expect return true.
267 */
268 g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
269 /**
270 * @tc.steps:step2. Set PragmaCmd = GET_DEVICE_IDENTIFIER_OF_ENTRY, Key= Key_1, origDevice = false.
271 * @tc.expected: step2. Expect return deviceIdentifier is the same as deviceIdentifier of DEVICE_B.
272 */
273 PragmaEntryDeviceIdentifier param;
274 param.key = KEY_1;
275 param.origDevice = true;
276 PragmaData input = static_cast<void *>(¶m);
277 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_DEVICE_IDENTIFIER_OF_ENTRY, input), OK);
278 }
279
280 /**
281 * @tc.name: DeviceIdentifier007
282 * @tc.desc: Set pragma to be GET_IDENTIFIER_OF_DEVICE. check if empty deviceID returns INVALID_ARGS.
283 * @tc.type: FUNC
284 * @tc.require:
285 * @tc.author: maokeheng
286 */
287 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier007, TestSize.Level1)
288 {
289 /**
290 * @tc.steps:step1. Set PragmaCmd = GET_IDENTIFIER_OF_DEVICE, deviceID= NULL.
291 * @tc.expected: step1. Expect return INVALID_ARGS.
292 */
293 PragmaDeviceIdentifier param;
294 param.deviceID = "";
295 PragmaData input = static_cast<void *>(¶m);
296 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_IDENTIFIER_OF_DEVICE, input), INVALID_ARGS);
297 }
298
299 /**
300 * @tc.name: DeviceIdentifier008
301 * @tc.desc: Set pragma to be GET_IDENTIFIER_OF_DEVICE. check if deviceIdentifier matches deviceID.
302 * @tc.type: FUNC
303 * @tc.require:
304 * @tc.author: maokeheng
305 */
306 HWTEST_F(DistributedDBDeviceIdentifierTest, DeviceIdentifier008, TestSize.Level1)
307 {
308 /**
309 * @tc.steps:step1. Set PragmaCmd = GET_IDENTIFIER_OF_DEVICE, deviceID = DEVICE_ID_1
310 * @tc.expected: step1. Expect return deviceIdentifier is the same as deviceIdentifier of DEVICE_ID_1.
311 */
312 PragmaDeviceIdentifier param;
313 param.deviceID = DEVICE_ID_1;
314 PragmaData input = static_cast<void *>(¶m);
315 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(GET_IDENTIFIER_OF_DEVICE, input), OK);
316 EXPECT_EQ(param.deviceIdentifier, DBCommon::TransferHashString(DEVICE_ID_1));
317 }
318
319 /**
320 * @tc.name: ErrDbTest001
321 * @tc.desc: Initialize check when the database is not opened
322 * @tc.type: FUNC
323 * @tc.require:
324 * @tc.author: bty
325 */
326 HWTEST_F(DistributedDBDeviceIdentifierTest, ErrDbTest001, TestSize.Level1)
327 {
328 /**
329 * @tc.steps: step1. Initialize an empty db and register nullptr callback
330 * @tc.expected: step1. Expect return not nullptr
331 */
332 SQLiteSingleVerNaturalStore *errStore = new (std::nothrow) SQLiteSingleVerNaturalStore;
333 ASSERT_NE(errStore, nullptr);
334
335 /**
336 * @tc.steps: step2. Get db handle
337 * @tc.expected: step2. Expect return nullptr
338 */
339 int errCode;
340 EXPECT_EQ(errStore->GetHandle(false, errCode), nullptr);
341
342 /**
343 * @tc.steps: step3. Check db integrity
344 * @tc.expected: step3. Expect return -E_INVALID_DB
345 */
346 EXPECT_EQ(errStore->CheckIntegrity(), -E_INVALID_DB);
347
348 /**
349 * @tc.steps: step4. Check cache db mode
350 * @tc.expected: step4. Expect return false
351 */
352 EXPECT_FALSE(errStore->IsCacheDBMode());
353 EXPECT_FALSE(errStore->IsExtendedCacheDBMode());
354
355 errStore->KillAndDecObjRef(errStore);
356 }
357
358 /**
359 * @tc.name: ErrDbTest002
360 * @tc.desc: Register check when the database is not opened
361 * @tc.type: FUNC
362 * @tc.require:
363 * @tc.author: bty
364 */
365 HWTEST_F(DistributedDBDeviceIdentifierTest, ErrDbTest002, TestSize.Level1)
366 {
367 /**
368 * @tc.steps: step1. Initialize an empty db
369 * @tc.expected: step1. Expect return not nullptr
370 */
371 std::unique_ptr<SQLiteSingleVerNaturalStore> errStore = std::make_unique<SQLiteSingleVerNaturalStore>();
372 ASSERT_NE(errStore, nullptr);
373
374 /**
375 * @tc.steps: step2. Check register nullptr callback
376 * @tc.expected: step2. Expect return E_OK
377 */
378 EXPECT_EQ(errStore->RegisterLifeCycleCallback(nullptr), E_OK);
379
380 /**
381 * @tc.steps: step3. Check register Conflict type
382 * @tc.expected: step3. Expect return -E_NOT_SUPPORT
383 */
384 RegisterFuncType funcType = RegisterFuncType::OBSERVER_SINGLE_VERSION_NS_PUT_EVENT;
385 EXPECT_EQ(errStore->TransConflictTypeToRegisterFunctionType(0, funcType), -E_NOT_SUPPORT);
386
387 /**
388 * @tc.steps: step4. Check register Observer type
389 * @tc.expected: step4. Expect return -E_NOT_SUPPORT
390 */
391 EXPECT_EQ(errStore->TransObserverTypeToRegisterFunctionType(0, funcType), -E_NOT_SUPPORT);
392 }
393
394 /**
395 * @tc.name: ErrDbTest003
396 * @tc.desc: Export and Import check when the database is not opened
397 * @tc.type: FUNC
398 * @tc.require:
399 * @tc.author: bty
400 */
401 HWTEST_F(DistributedDBDeviceIdentifierTest, ErrDbTest003, TestSize.Level1)
402 {
403 /**
404 * @tc.steps: step1. Initialize an empty db
405 * @tc.expected: step1. Expect return not nullptr
406 */
407 std::unique_ptr<SQLiteSingleVerNaturalStore> errStore = std::make_unique<SQLiteSingleVerNaturalStore>();
408 ASSERT_NE(errStore, nullptr);
409
410 /**
411 * @tc.steps: step2. Export
412 * @tc.expected: step2. Expect return -E_INVALID_DB
413 */
414 CipherPassword passwd;
415 EXPECT_EQ(errStore->Export(g_testDir, passwd), -E_INVALID_DB);
416
417 /**
418 * @tc.steps: step3. Import
419 * @tc.expected: step3. Expect return -E_INVALID_DB
420 */
421 EXPECT_EQ(errStore->Import(g_testDir, passwd), -E_INVALID_DB);
422
423 /**
424 * @tc.steps: step4. Reset key
425 * @tc.expected: step4. Expect return -E_INVALID_DB
426 */
427 EXPECT_EQ(errStore->Rekey(passwd), -E_INVALID_DB);
428 }
429
430 /**
431 * @tc.name: ErrDbTest004
432 * @tc.desc: Check the interface of operation data when the database is not opened
433 * @tc.type: FUNC
434 * @tc.require:
435 * @tc.author: bty
436 */
437 HWTEST_F(DistributedDBDeviceIdentifierTest, ErrDbTest004, TestSize.Level1)
438 {
439 /**
440 * @tc.steps: step1. Initialize an empty db
441 * @tc.expected: step1. Expect return not nullptr
442 */
443 std::unique_ptr<SQLiteSingleVerNaturalStore> errStore = std::make_unique<SQLiteSingleVerNaturalStore>();
444 ASSERT_NE(errStore, nullptr);
445
446 /**
447 * @tc.steps: step2. Get all meta keys
448 * @tc.expected: step2. Expect return -E_INVALID_DB
449 */
450 std::vector<Key> keys;
451 EXPECT_EQ(errStore->GetAllMetaKeys(keys), -E_INVALID_DB);
452
453 /**
454 * @tc.steps: step3. Delete meta data if the Key is empty
455 * @tc.expected: step3. Expect return -E_INVALID_ARGS
456 */
457 Key key;
458 keys.push_back(key);
459 EXPECT_EQ(errStore->DeleteMetaData(keys), -E_INVALID_ARGS);
460
461 /**
462 * @tc.steps: step4. Delete meta data if the Key is not empty
463 * @tc.expected: step4. Expect return -E_INVALID_DB
464 */
465 keys.front().push_back('A');
466 EXPECT_EQ(errStore->DeleteMetaData(keys), -E_INVALID_DB);
467
468 /**
469 * @tc.steps: step5. put meta data
470 * @tc.expected: step5. Expect return -E_INVALID_DB
471 */
472 Value values;
473 EXPECT_EQ(errStore->PutMetaData(keys.front(), values, false), -E_INVALID_DB);
474
475 /**
476 * @tc.steps: step6. Test remove device data
477 * @tc.expected: step6. Expect return -E_INVALID_ARGS
478 */
479 std::string deviceName;
480 EXPECT_EQ(errStore->RemoveDeviceData(deviceName, false), -E_INVALID_ARGS);
481 }
482
483 /**
484 * @tc.name: ErrDbTest005
485 * @tc.desc: Test sync data when the database is not opened
486 * @tc.type: FUNC
487 * @tc.require:
488 * @tc.author: bty
489 */
490 HWTEST_F(DistributedDBDeviceIdentifierTest, ErrDbTest005, TestSize.Level1)
491 {
492 std::unique_ptr<SQLiteSingleVerNaturalStore> errStore = std::make_unique<SQLiteSingleVerNaturalStore>();
493 ASSERT_NE(errStore, nullptr);
494 ContinueToken token = nullptr;
495 std::vector<DataItem> dataItems;
496 DataSizeSpecInfo info = {DBConstant::MAX_SYNC_BLOCK_SIZE + 1, 0};
497 EXPECT_EQ(errStore->GetSyncDataNext(dataItems, token, info), -E_INVALID_ARGS);
498 info.blockSize = 0;
499 EXPECT_EQ(errStore->GetSyncDataNext(dataItems, token, info), -E_INVALID_ARGS);
500 errStore->ReleaseContinueToken(token);
501 }
502
503 /**
504 * @tc.name: StorageEngineTest001
505 * @tc.desc: Test cache db remove data
506 * @tc.type: FUNC
507 * @tc.require:
508 * @tc.author: bty
509 */
510 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest001, TestSize.Level1)
511 {
512 int errCode = E_OK;
513 SQLiteSingleVerStorageEngine *storageEngine =
514 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
515 ASSERT_EQ(errCode, E_OK);
516 ASSERT_NE(storageEngine, nullptr);
517 storageEngine->SetEngineState(EngineState::CACHEDB);
518 EXPECT_NE(g_store->RemoveDeviceData("device1", false), E_OK);
519 storageEngine->Release();
520 }
521
522 namespace {
StorageEngineTest002()523 void StorageEngineTest002()
524 {
525 std::string exportFileName = g_testDir + "/" + STORE_ID + ".dump";
526 int fd = open(exportFileName.c_str(), (O_WRONLY | O_CREAT), (S_IRUSR | S_IWUSR | S_IRGRP));
527 ASSERT_TRUE(fd >= 0);
528 g_store->Dump(fd);
529 close(fd);
530 OS::RemoveDBDirectory(exportFileName);
531 }
532 }
533
534 /**
535 * @tc.name: StorageEngineTest002
536 * @tc.desc: Test the interface of Dump
537 * @tc.type: FUNC
538 * @tc.require:
539 * @tc.author: bty
540 */
541 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest002, TestSize.Level1)
542 {
543 ASSERT_NO_FATAL_FAILURE(StorageEngineTest002());
544 }
545
546 /**
547 * @tc.name: StorageEngineTest003
548 * @tc.desc: Test the accuracy of CacheRecordVersion
549 * @tc.type: FUNC
550 * @tc.require:
551 * @tc.author: bty
552 */
553 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest003, TestSize.Level1)
554 {
555 uint64_t curVersion = g_store->GetCacheRecordVersion();
556 g_store->IncreaseCacheRecordVersion();
557 EXPECT_EQ(g_store->GetCacheRecordVersion(), curVersion + 1);
558 EXPECT_EQ(g_store->GetAndIncreaseCacheRecordVersion(), curVersion + 1);
559 EXPECT_EQ(g_store->GetCacheRecordVersion(), curVersion + 2);
560
561 curVersion = 0;
562 std::unique_ptr<SQLiteSingleVerNaturalStore> store2 = std::make_unique<SQLiteSingleVerNaturalStore>();
563 ASSERT_NE(store2, nullptr);
564 EXPECT_EQ(store2->GetCacheRecordVersion(), curVersion);
565 store2->IncreaseCacheRecordVersion();
566 EXPECT_EQ(store2->GetCacheRecordVersion(), curVersion);
567 }
568
569 /**
570 * @tc.name: StorageEngineTest004
571 * @tc.desc: Modify parameter initialization StorageEngine
572 * @tc.type: FUNC
573 * @tc.require:
574 * @tc.author: bty
575 */
576 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest004, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. Get storageEngine
580 * @tc.expected: step1. Expect return E_OK
581 */
582 int errCode = E_OK;
583 SQLiteSingleVerStorageEngine *storageEngine =
584 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
585 ASSERT_EQ(errCode, E_OK);
586 ASSERT_NE(storageEngine, nullptr);
587
588 /**
589 * @tc.steps: step2. Set the wrong min write num
590 * @tc.expected: step2. Expect -E_INVALID_ARGS
591 */
592 StorageEngineAttr poolSize = {17, 1, 1, 1}; // 17 means the maximum value is exceeded, 1 is the normal value
593 OpenDbProperties option;
594 EXPECT_EQ(storageEngine->InitSQLiteStorageEngine(poolSize, option), -E_INVALID_ARGS);
595
596 /**
597 * @tc.steps: step3. Set the correct min write num
598 * @tc.expected: step3. Expect E_OK
599 */
600 poolSize.minWriteNum = 1;
601 EXPECT_EQ(storageEngine->InitSQLiteStorageEngine(poolSize, option), E_OK);
602
603 /**
604 * @tc.steps: step4. Change the Engine State
605 * @tc.expected: step4. Expect E_OK
606 */
607 EngineState engineState = {EngineState::CACHEDB};
608 storageEngine->SetEngineState(engineState);
609 EXPECT_EQ(storageEngine->InitSQLiteStorageEngine(poolSize, option), E_OK);
610
611 storageEngine->Release();
612 }
613
614 /**
615 * @tc.name: StorageEngineTest005
616 * @tc.desc: Set adapter to check engine
617 * @tc.type: FUNC
618 * @tc.require:
619 * @tc.author: bty
620 */
621 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest005, TestSize.Level1)
622 {
623 std::shared_ptr<ProcessSystemApiAdapterImpl> adapter = std::make_shared<ProcessSystemApiAdapterImpl>();
624 EXPECT_TRUE(adapter != nullptr);
625 RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(adapter);
626 int errCode = E_OK;
627 SQLiteSingleVerStorageEngine *storageEngine =
628 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
629 ASSERT_NE(storageEngine, nullptr);
630 EXPECT_EQ(storageEngine->CheckEngineOption(g_property), E_OK);
631 RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(nullptr);
632 /**
633 * @tc.steps: step1. set max value size
634 * @tc.expected: step1. Expect return OK
635 */
636 uint32_t valSize = 64 * 1024 * 1024;
637 PragmaData input = static_cast<PragmaData>(&valSize);
638 EXPECT_TRUE(g_kvNbDelegatePtr->Pragma(SET_MAX_VALUE_SIZE, input) == OK);
639 /**
640 * @tc.steps: step2. set max value size again
641 * @tc.expected: step2. Expect return OK
642 */
643 EXPECT_EQ(g_kvNbDelegatePtr->Pragma(SET_MAX_VALUE_SIZE, input), OK);
644 }
645
646 /**
647 * @tc.name: StorageEngineTest006
648 * @tc.desc: Check the engine Option after setting the schema
649 * @tc.type: FUNC
650 * @tc.require:
651 * @tc.author: bty
652 */
653 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest006, TestSize.Level1)
654 {
655 /**
656 * @tc.steps: step1. First parse the schema, then set the KvDBProperties
657 * @tc.expected: step1. Expect return -E_SCHEMA_MISMATCH
658 */
659 int errCode = E_OK;
660 SQLiteSingleVerStorageEngine *storageEngine =
661 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
662 ASSERT_NE(storageEngine, nullptr);
663 KvDBProperties prop;
664 prop.SetStringProp(KvDBProperties::DATA_DIR, g_property.GetStringProp(KvDBProperties::DATA_DIR, ""));
665 prop.SetStringProp(KvDBProperties::STORE_ID, g_property.GetStringProp(KvDBProperties::STORE_ID, ""));
666 prop.SetIntProp(KvDBProperties::DATABASE_TYPE, g_property.GetIntProp(KvDBProperties::DATABASE_TYPE, 0));
667 string schemaString =
668 "{\"SCHEMA_VERSION\":\"1.0\","
669 "\"SCHEMA_MODE\":\"STRICT\","
670 "\"SCHEMA_DEFINE\":{"
671 "\"field_name1\":\"BOOL\"},"
672 "\"SCHEMA_INDEXES\":[\"$.field_name1\"]}";
673 SchemaObject schema;
674 schema.ParseFromSchemaString(schemaString);
675 prop.SetSchema(schema);
676 EXPECT_EQ(storageEngine->CheckEngineOption(prop), -E_SCHEMA_MISMATCH);
677
678 /**
679 * @tc.steps: step2. Set the error Schema for the option
680 * @tc.expected: step2. Expect return -E_SCHEMA_MISMATCH
681 */
682 OpenDbProperties option;
683 option.schema = "errorSchema";
684 StorageEngineAttr poolSize = {1, 1, 1, 1}; // 1 is the valid size
685 EXPECT_EQ(storageEngine->InitSQLiteStorageEngine(poolSize, option), E_OK);
686 EXPECT_EQ(storageEngine->CheckEngineOption(prop), -E_SCHEMA_MISMATCH);
687
688 /**
689 * @tc.steps: step3. Set the correct Schema for the option
690 * @tc.expected: step3. Expect return E_OK
691 */
692 option.schema = schemaString;
693 EXPECT_EQ(storageEngine->InitSQLiteStorageEngine(poolSize, option), E_OK);
694 EXPECT_EQ(storageEngine->CheckEngineOption(prop), E_OK);
695
696 storageEngine->Release();
697 }
698
699 /**
700 * @tc.name: StorageEngineTest007
701 * @tc.desc: Export and import after changing engine state
702 * @tc.type: FUNC
703 * @tc.require:
704 * @tc.author: bty
705 */
706 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest007, TestSize.Level1)
707 {
708 /**
709 * @tc.steps: step1. Get storage engine
710 * @tc.expected: step1. Expect E_OK
711 */
712 int errCode = E_OK;
713 SQLiteSingleVerStorageEngine *storageEngine =
714 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
715 ASSERT_EQ(errCode, E_OK);
716 ASSERT_NE(storageEngine, nullptr);
717
718 /**
719 * @tc.steps: step2. Change engine state to cache db
720 * @tc.expected: step2. Expect -E_NOT_SUPPORT
721 */
722 storageEngine->SetEngineState(EngineState::CACHEDB);
723 CipherPassword passwd;
724 string filePath = g_testDir + "/store_export.db";
725 EXPECT_EQ(g_store->Export(filePath, passwd), -E_NOT_SUPPORT);
726 EXPECT_EQ(g_store->Import(filePath, passwd), -E_NOT_SUPPORT);
727 EXPECT_EQ(g_store->Rekey(passwd), -E_NOT_SUPPORT);
728
729 /**
730 * @tc.steps: step3. Change engine state to INVALID
731 * @tc.expected: step3. Expect -E_BUSY
732 */
733 storageEngine->SetEngineState(EngineState::INVALID);
734 EXPECT_EQ(g_store->Export(filePath, passwd), -E_BUSY);
735 EXPECT_EQ(g_store->Import(filePath, passwd), -E_BUSY);
736 EXPECT_EQ(g_store->Rekey(passwd), -E_BUSY);
737 storageEngine->Release();
738 }
739
740 /**
741 * @tc.name: StorageEngineTest008
742 * @tc.desc: add and remove sub after changing engine state
743 * @tc.type: FUNC
744 * @tc.require:
745 * @tc.author: bty
746 */
747 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest008, TestSize.Level1)
748 {
749 /**
750 * @tc.steps: step1. Get storage engine
751 * @tc.expected: step1. Expect E_OK
752 */
753 int errCode = E_OK;
754 SQLiteSingleVerStorageEngine *storageEngine =
755 static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
756 ASSERT_EQ(errCode, E_OK);
757 ASSERT_NE(storageEngine, nullptr);
758
759 /**
760 * @tc.steps: step2. Change engine state to cache db
761 * @tc.expected: step2. Expect E_OK
762 */
763 storageEngine->SetEngineState(EngineState::CACHEDB);
764 Query query = Query::Select();
765 QueryObject queryObj(query);
766 std::string sub = "123";
767 EXPECT_EQ(g_store->AddSubscribe(sub, queryObj, true), E_OK);
768
769 /**
770 * @tc.steps: step3. Remove subscribe from cache db
771 * @tc.expected: step3. Expect -1
772 */
773 std::vector<std::string> subs;
774 subs.push_back(sub);
775 EXPECT_EQ(g_store->RemoveSubscribe(subs), -1);
776 storageEngine->Release();
777 }
778
779 /**
780 * @tc.name: StorageEngineTest009
781 * @tc.desc: Test pragma
782 * @tc.type: FUNC
783 * @tc.require:
784 * @tc.author: zqq
785 */
786 HWTEST_F(DistributedDBDeviceIdentifierTest, StorageEngineTest009, TestSize.Level0)
787 {
788 /**
789 * @tc.steps: step1. Remove device data with null db
790 * @tc.expected: step1. Return -E_INVALID_DB
791 */
792 PragmaData input = nullptr;
793 auto con = std::make_shared<SQLiteSingleVerNaturalStoreConnection>(nullptr);
794 EXPECT_EQ(con->Pragma(RM_DEVICE_DATA, input), -E_INVALID_DB);
795 /**
796 * @tc.steps: step2. Remove device data with null
797 * @tc.expected: step2. Return DB_ERROR
798 */
799 auto store = new(std::nothrow) SQLiteSingleVerNaturalStore();
800 con->SetSafeDeleted();
801 con = std::make_shared<SQLiteSingleVerNaturalStoreConnection>(store);
802 EXPECT_EQ(con->Pragma(RM_DEVICE_DATA, input), -E_INVALID_DB);
803 /**
804 * @tc.steps: step3. Remove device data with dev
805 * @tc.expected: step3. Return -E_NOT_INIT
806 */
807 std::string dev = "dev";
808 input = static_cast<PragmaData>(&dev);
809 EXPECT_EQ(con->Pragma(RM_DEVICE_DATA, input), -E_NOT_INIT);
810 con = nullptr;
811 RefObject::KillAndDecObjRef(store);
812 }