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 "rdb_helper.h"
17
18 #include <gtest/gtest.h>
19
20 #include <string>
21
22 #include "common.h"
23 #include "rdb_errno.h"
24 #include "rdb_open_callback.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28
29 class OpenCallback : public RdbOpenCallback {
30 public:
OnCreate(RdbStore & store)31 int OnCreate(RdbStore &store) override
32 {
33 return E_OK;
34 }
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)35 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override
36 {
37 return E_OK;
38 }
39 };
40
41 class RdbHelperTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 void InitDb();
48
49 static const std::string rdbStorePath;
50 static std::shared_ptr<RdbStore> store;
51 };
52 const std::string RdbHelperTest::rdbStorePath = RDB_TEST_PATH + std::string("rdbhelper.db");
53 std::shared_ptr<RdbStore> RdbHelperTest::store = nullptr;
54
SetUpTestCase(void)55 void RdbHelperTest::SetUpTestCase(void)
56 {
57 }
58
TearDownTestCase(void)59 void RdbHelperTest::TearDownTestCase(void)
60 {
61 RdbHelper::DeleteRdbStore(rdbStorePath);
62 }
63
SetUp(void)64 void RdbHelperTest::SetUp(void)
65 {
66 }
67
TearDown(void)68 void RdbHelperTest::TearDown(void)
69 {
70 }
71
72 class RdbHelperTestWrongSqlOpenCallback : public RdbOpenCallback {
73 public:
74 int OnCreate(RdbStore &store) override;
75 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
76 static const std::string WRONG_SQL_TEST;
77 };
78
79 class RdbHelperTestOpenCallback : public RdbOpenCallback {
80 public:
81 int OnCreate(RdbStore &store) override;
82 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
83 static const std::string CREATE_TABLE_TEST;
84 };
85
InitDb()86 void RdbHelperTest::InitDb()
87 {
88 int errCode = E_OK;
89 RdbStoreConfig config(RdbHelperTest::rdbStorePath);
90 RdbHelperTestOpenCallback helper;
91 RdbHelperTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
92 EXPECT_NE(store, nullptr);
93 }
94
95 const std::string RdbHelperTestWrongSqlOpenCallback::WRONG_SQL_TEST = "CREATE TABL IF NOT EXISTS test "
96 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
97 "name TEXT NOT NULL, age INTEGER, salary REAL, "
98 "blobType BLOB)";
99 const std::string RdbHelperTestOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test "
100 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
101 "name TEXT NOT NULL, age INTEGER, salary REAL, "
102 "blobType BLOB)";
103
OnCreate(RdbStore & store)104 int RdbHelperTestWrongSqlOpenCallback::OnCreate(RdbStore &store)
105 {
106 return store.ExecuteSql(WRONG_SQL_TEST);
107 }
108
OnCreate(RdbStore & store)109 int RdbHelperTestOpenCallback::OnCreate(RdbStore &store)
110 {
111 return store.ExecuteSql(CREATE_TABLE_TEST);
112 }
113
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)114 int RdbHelperTestWrongSqlOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
115 {
116 return E_OK;
117 }
118
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)119 int RdbHelperTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
120 {
121 return E_OK;
122 }
123
124 /**
125 * @tc.name: DeleteDatabaseCache_001
126 * @tc.desc: delete db cache
127 * @tc.type: FUNC
128 * @tc.require:
129 * @tc.author:
130 */
131 HWTEST_F(RdbHelperTest, DeleteDatabaseCache_001, TestSize.Level1)
132 {
133 int errCode = E_OK;
134 RdbStoreConfig config(RdbHelperTest::rdbStorePath);
135 RdbHelperTestWrongSqlOpenCallback helper;
136 std::shared_ptr<RdbStore> rdbStore = RdbHelper::GetRdbStore(config, 1, helper, errCode);
137 EXPECT_EQ(rdbStore, nullptr);
138 }
139
140 /**
141 * @tc.name: DeleteDatabase_001
142 * @tc.desc: delete db file
143 * @tc.type: FUNC
144 */
145 HWTEST_F(RdbHelperTest, DeleteDatabase_001, TestSize.Level1)
146 {
147 int errCode = E_OK;
148 RdbStoreConfig config1(RdbHelperTest::rdbStorePath);
149 RdbStoreConfig config2("test");
150 RdbStoreConfig config3("");
151 RdbHelperTestOpenCallback helper;
152 std::shared_ptr<RdbStore> rdbStore = RdbHelper::GetRdbStore(config1, 1, helper, errCode);
153 EXPECT_NE(rdbStore, nullptr);
154 int ret1 = RdbHelper::DeleteRdbStore(config1);
155 EXPECT_EQ(ret1, E_OK);
156 int ret2 = RdbHelper::DeleteRdbStore(config2);
157 EXPECT_EQ(ret2, E_INVALID_FILE_PATH);
158 int ret3 = RdbHelper::DeleteRdbStore(config3);
159 EXPECT_EQ(ret3, E_INVALID_FILE_PATH);
160 }
161
162 /**
163 * @tc.name: DeleteDatabase_002
164 * @tc.desc: DeleteRdbStore if the dbFile is not exists
165 * @tc.type: FUNC
166 */
167 HWTEST_F(RdbHelperTest, DeleteDatabase_002, TestSize.Level1)
168 {
169 int errCode = E_OK;
170 RdbStoreConfig config(RdbHelperTest::rdbStorePath);
171 RdbHelperTestOpenCallback helper;
172 std::shared_ptr<RdbStore> rdbStore = RdbHelper::GetRdbStore(config, 1, helper, errCode);
173 EXPECT_NE(rdbStore, nullptr);
174
175 remove(rdbStorePath.c_str());
176
177 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
178 EXPECT_EQ(ret, E_OK);
179 std::string shmFileName = rdbStorePath + "-shm";
180 std::string walFileName = rdbStorePath + "-wal";
181 EXPECT_NE(access(shmFileName.c_str(), F_OK), 0);
182 EXPECT_NE(access(walFileName.c_str(), F_OK), 0);
183 }
184
185 /**
186 * @tc.name: DeleteDatabase_003
187 * @tc.desc: DeleteRdbStore if the dbFile is not exists
188 * @tc.type: FUNC
189 */
190 HWTEST_F(RdbHelperTest, DeleteDatabase_003, TestSize.Level1)
191 {
192 int errCode = E_OK;
193 RdbStoreConfig config(RdbHelperTest::rdbStorePath);
194 RdbHelperTestOpenCallback helper;
195 std::shared_ptr<RdbStore> rdbStore = RdbHelper::GetRdbStore(config, 1, helper, errCode);
196 EXPECT_NE(rdbStore, nullptr);
197
198 remove(rdbStorePath.c_str());
199
200 int ret = RdbHelper::DeleteRdbStore(config);
201 EXPECT_EQ(ret, E_OK);
202 std::string shmFileName = rdbStorePath + "-shm";
203 std::string walFileName = rdbStorePath + "-wal";
204 EXPECT_NE(access(shmFileName.c_str(), F_OK), 0);
205 EXPECT_NE(access(walFileName.c_str(), F_OK), 0);
206 }
207
208 /**
209 * @tc.name: DeleteDatabase_004
210 * @tc.desc: Update after deleteRdbStore
211 * @tc.type: FUNC
212 */
213 HWTEST_F(RdbHelperTest, DeleteDatabase_004, TestSize.Level0)
214 {
215 InitDb();
216 int64_t id;
217 int changedRows;
218 ValuesBucket values;
219
220 values.PutInt("id", 1);
221 values.PutString("name", std::string("zhangsan"));
222 values.PutInt("age", 18);
223 values.PutDouble("salary", 100.5);
224 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
225 int ret = store->Insert(id, "test", values);
226 EXPECT_EQ(ret, E_OK);
227 EXPECT_EQ(1, id);
228
229 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
230 EXPECT_EQ(ret, E_OK);
231
232 values.Clear();
233 values.PutInt("id", 2);
234 values.PutString("name", std::string("lisi"));
235 values.PutInt("age", 19);
236 values.PutDouble("salary", 200.5);
237 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
238 ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
239 EXPECT_EQ(ret, E_ALREADY_CLOSED);
240 }
241
242 /**
243 * @tc.name: DeleteDatabase_005
244 * @tc.desc: Insert after deleteRdbStore
245 * @tc.type: FUNC
246 */
247 HWTEST_F(RdbHelperTest, DeleteDatabase_005, TestSize.Level0)
248 {
249 InitDb();
250 int64_t id;
251 ValuesBucket values;
252
253 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
254 EXPECT_EQ(ret, E_OK);
255
256 values.PutInt("id", 1);
257 values.PutString("name", std::string("zhangsan"));
258 values.PutInt("age", 18);
259 values.PutDouble("salary", 100.5);
260 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
261 ret = store->Insert(id, "test", values);
262 EXPECT_EQ(ret, E_ALREADY_CLOSED);
263 }
264
265 /**
266 * @tc.name: DeleteDatabase_006
267 * @tc.desc: BatchInsert after deleteRdbStore
268 * @tc.type: FUNC
269 */
270 HWTEST_F(RdbHelperTest, DeleteDatabase_006, TestSize.Level0)
271 {
272 InitDb();
273 int64_t id;
274 ValuesBucket values;
275
276 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
277 EXPECT_EQ(ret, E_OK);
278
279 values.PutInt("id", 1);
280 values.PutString("name", std::string("zhangsan"));
281 values.PutInt("age", 18);
282 values.PutDouble("salary", 100.5);
283 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
284
285 std::vector<ValuesBucket> valuesBuckets;
286 for (int i = 0; i < 10; i++) {
287 valuesBuckets.push_back(values);
288 }
289 ret = store->BatchInsert(id, "test", valuesBuckets);
290 EXPECT_EQ(ret, E_ALREADY_CLOSED);
291 }
292
293 /**
294 * @tc.name: DeleteDatabase_007
295 * @tc.desc: Delete after deleteRdbStore
296 * @tc.type: FUNC
297 */
298 HWTEST_F(RdbHelperTest, DeleteDatabase_007, TestSize.Level0)
299 {
300 InitDb();
301 int64_t id;
302 int deletedRows;
303 ValuesBucket values;
304
305 values.PutInt("id", 1);
306 values.PutString("name", std::string("zhangsan"));
307 values.PutInt("age", 18);
308 values.PutDouble("salary", 100.5);
309 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
310 int ret = store->Insert(id, "test", values);
311 EXPECT_EQ(ret, E_OK);
312
313 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
314 EXPECT_EQ(ret, E_OK);
315
316 ret = store->Delete(deletedRows, "test", "id = 1");
317 EXPECT_EQ(ret, E_ALREADY_CLOSED);
318 }
319
320 /**
321 * @tc.name: DeleteDatabase_008
322 * @tc.desc: QuerySql after deleteRdbStore
323 * @tc.type: FUNC
324 */
325 HWTEST_F(RdbHelperTest, DeleteDatabase_008, TestSize.Level0)
326 {
327 InitDb();
328 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
329 EXPECT_EQ(ret, E_OK);
330
331 std::shared_ptr<ResultSet> resultSet =
332 store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "1" });
333 EXPECT_EQ(resultSet, nullptr);
334 }
335
336 /**
337 * @tc.name: DeleteDatabase_009
338 * @tc.desc: QueryByStep after deleteRdbStore
339 * @tc.type: FUNC
340 */
341 HWTEST_F(RdbHelperTest, DeleteDatabase_009, TestSize.Level0)
342 {
343 InitDb();
344 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
345 EXPECT_EQ(ret, E_OK);
346
347 std::shared_ptr<ResultSet> resultSet =
348 store->QueryByStep("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "1" });
349 EXPECT_EQ(resultSet, nullptr);
350 }
351
352 /**
353 * @tc.name: DeleteDatabase_010
354 * @tc.desc: Restore after deleteRdbStore
355 * @tc.type: FUNC
356 */
357 HWTEST_F(RdbHelperTest, DeleteDatabase_010, TestSize.Level0)
358 {
359 InitDb();
360 int ret = store->Backup("backup.db");
361 EXPECT_EQ(ret, E_OK);
362
363 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
364 EXPECT_EQ(ret, E_OK);
365
366 ret = store->Restore("backup.db");
367 EXPECT_EQ(ret, E_ALREADY_CLOSED);
368
369 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + std::string("backup.db"));
370 }
371
372 /**
373 * @tc.name: DeleteDatabase_011
374 * @tc.desc: Backup after deleteRdbStore
375 * @tc.type: FUNC
376 */
377 HWTEST_F(RdbHelperTest, DeleteDatabase_011, TestSize.Level0)
378 {
379 InitDb();
380 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
381 EXPECT_EQ(ret, E_OK);
382
383 ret = store->Backup("backup.db");
384 EXPECT_EQ(ret, E_DB_NOT_EXIST);
385 }
386
387 /**
388 * @tc.name: DeleteDatabase_012
389 * @tc.desc: CleanDirtyData after deleteRdbStore
390 * @tc.type: FUNC
391 */
392 HWTEST_F(RdbHelperTest, DeleteDatabase_012, TestSize.Level0)
393 {
394 InitDb();
395 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
396 EXPECT_EQ(ret, E_OK);
397
398 uint64_t cursor = UINT64_MAX;
399 ret = store->CleanDirtyData("test", cursor);
400 EXPECT_EQ(ret, E_ALREADY_CLOSED);
401 }
402
403 /**
404 * @tc.name: DeleteDatabase_013
405 * @tc.desc: ExecuteSql after deleteRdbStore
406 * @tc.type: FUNC
407 */
408 HWTEST_F(RdbHelperTest, DeleteDatabase_013, TestSize.Level0)
409 {
410 InitDb();
411 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
412 EXPECT_EQ(ret, E_OK);
413
414 ret = store->ExecuteSql(RdbHelperTestOpenCallback::CREATE_TABLE_TEST);
415 EXPECT_EQ(ret, E_ALREADY_CLOSED);
416 }
417
418 /**
419 * @tc.name: DeleteDatabase_014
420 * @tc.desc: Execute after deleteRdbStore
421 * @tc.type: FUNC
422 */
423 HWTEST_F(RdbHelperTest, DeleteDatabase_014, TestSize.Level0)
424 {
425 InitDb();
426 int ret1 = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
427 EXPECT_EQ(ret1, E_OK);
428
429 auto [ret2, outValue] = store->Execute(RdbHelperTestOpenCallback::CREATE_TABLE_TEST);
430 EXPECT_EQ(ret2, E_ALREADY_CLOSED);
431 }
432
433 /**
434 * @tc.name: DeleteDatabase_015
435 * @tc.desc: BeginTransaction after deleteRdbStore
436 * @tc.type: FUNC
437 */
438 HWTEST_F(RdbHelperTest, DeleteDatabase_015, TestSize.Level0)
439 {
440 InitDb();
441 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
442 EXPECT_EQ(ret, E_OK);
443
444 ret = store->BeginTransaction();
445 EXPECT_EQ(ret, E_ALREADY_CLOSED);
446 }
447
448 /**
449 * @tc.name: DeleteDatabase_016
450 * @tc.desc: Attach after deleteRdbStore
451 * @tc.type: FUNC
452 */
453 HWTEST_F(RdbHelperTest, DeleteDatabase_016, TestSize.Level0)
454 {
455 InitDb();
456 int ret = 0;
457 std::string attachPath = RDB_TEST_PATH + std::string("attached.db");
458 RdbStoreConfig attachedConfig(attachPath);
459 RdbHelperTestOpenCallback attachedHelper;
460 std::shared_ptr<RdbStore> attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, ret);
461 EXPECT_NE(attachedStore, nullptr);
462
463 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
464 EXPECT_EQ(ret, E_OK);
465
466 int busyTimeout = 2;
467 std::string attachedName = "attached";
468 auto err = store->Attach(attachedConfig, attachedName, busyTimeout);
469 EXPECT_EQ(err.first, E_ALREADY_CLOSED);
470
471 RdbHelper::DeleteRdbStore(attachPath);
472 }
473
474 /**
475 * @tc.name: DeleteDatabase_017
476 * @tc.desc: Detach after deleteRdbStore
477 * @tc.type: FUNC
478 */
479 HWTEST_F(RdbHelperTest, DeleteDatabase_017, TestSize.Level0)
480 {
481 InitDb();
482 int ret = 0;
483 std::string attachPath = RDB_TEST_PATH + std::string("attached.db");
484 RdbStoreConfig attachedConfig(attachPath);
485 RdbHelperTestOpenCallback attachedHelper;
486 std::shared_ptr<RdbStore> attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, ret);
487 EXPECT_NE(attachedStore, nullptr);
488
489 int busyTimeout = 2;
490 std::string attachedName = "attached";
491 auto err = store->Attach(attachedConfig, attachedName, busyTimeout);
492 EXPECT_EQ(err.first, E_OK);
493
494 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
495 EXPECT_EQ(ret, E_OK);
496
497 err = store->Detach(attachedName);
498 EXPECT_EQ(err.first, E_ALREADY_CLOSED);
499
500 RdbHelper::DeleteRdbStore(attachPath);
501 }
502
503 /**
504 * @tc.name: DeleteDatabase_018
505 * @tc.desc: CreateTransaction after deleteRdbStore
506 * @tc.type: FUNC
507 */
508 HWTEST_F(RdbHelperTest, DeleteDatabase_018, TestSize.Level0)
509 {
510 InitDb();
511 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
512 EXPECT_EQ(err, E_OK);
513
514 auto [ret, transaction] = store->CreateTransaction(Transaction::EXCLUSIVE);
515 ASSERT_EQ(ret, E_ALREADY_CLOSED);
516 ASSERT_EQ(transaction, nullptr);
517 }
518
519 /**
520 * @tc.name: DeleteDatabase_019
521 * @tc.desc: BeginTrans after deleteRdbStore
522 * @tc.type: FUNC
523 */
524 HWTEST_F(RdbHelperTest, DeleteDatabase_019, TestSize.Level0)
525 {
526 InitDb();
527 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
528 EXPECT_EQ(err, E_OK);
529
530 auto ret = store->BeginTrans();
531 ASSERT_EQ(ret.first, E_NOT_SUPPORT);
532 }
533
534 /**
535 * @tc.name: DeleteDatabase_020
536 * @tc.desc: Commit after deleteRdbStore
537 * @tc.type: FUNC
538 */
539 HWTEST_F(RdbHelperTest, DeleteDatabase_020, TestSize.Level0)
540 {
541 InitDb();
542 int ret = store->BeginTransaction();
543 EXPECT_EQ(ret, E_OK);
544
545 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
546 EXPECT_EQ(ret, E_OK);
547
548 ret = store->Commit();
549 ASSERT_EQ(ret, E_ALREADY_CLOSED);
550 }
551
552 /**
553 * @tc.name: DeleteDatabase_021
554 * @tc.desc: GetModifyTime after deleteRdbStore
555 * @tc.type: FUNC
556 */
557 HWTEST_F(RdbHelperTest, DeleteDatabase_021, TestSize.Level0)
558 {
559 InitDb();
560 store->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
561 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
562 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
563 int64_t rowId;
564 ValuesBucket valuesBucket;
565 valuesBucket.PutInt("data_key", ValueObject(2));
566 int errorCode = store->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
567 EXPECT_EQ(E_OK, errorCode);
568 EXPECT_EQ(1, rowId);
569
570 errorCode = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
571 EXPECT_EQ(errorCode, E_OK);
572
573 std::vector<RdbStore::PRIKey> PKey = { 1 };
574 std::map<RdbStore::PRIKey, RdbStore::Date> result =
575 store->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
576 int size = result.size();
577 EXPECT_EQ(0, size);
578 }
579
580 /**
581 * @tc.name: DeleteDatabase_022
582 * @tc.desc: RollBack after deleteRdbStore
583 * @tc.type: FUNC
584 */
585 HWTEST_F(RdbHelperTest, DeleteDatabase_022, TestSize.Level0)
586 {
587 InitDb();
588 int ret = store->BeginTransaction();
589 EXPECT_EQ(ret, E_OK);
590
591 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
592 EXPECT_EQ(ret, E_OK);
593
594 ret = store->RollBack();
595 ASSERT_EQ(ret, E_ALREADY_CLOSED);
596 }
597
598 /**
599 * @tc.name: DeleteDatabase_023
600 * @tc.desc: Transaction insert after deleteRdbStore
601 * @tc.type: FUNC
602 */
603 HWTEST_F(RdbHelperTest, DeleteDatabase_023, TestSize.Level0)
604 {
605 InitDb();
606 auto [ret, transaction] = store->CreateTransaction(Transaction::EXCLUSIVE);
607 ASSERT_EQ(ret, E_OK);
608 ASSERT_NE(transaction, nullptr);
609
610 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
611 EXPECT_EQ(err, E_OK);
612
613 auto result = transaction->Insert("test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
614 ASSERT_EQ(result.first, E_ALREADY_CLOSED);
615 }
616
617 /**
618 * @tc.name: getrdbstore_001
619 * @tc.desc: get db file with a invalid path
620 * @tc.type: FUNC
621 */
622 HWTEST_F(RdbHelperTest, GetDatabase_001, TestSize.Level0)
623 {
624 int errCode = E_OK;
625 RdbStoreConfig config("/invalid/invalid/test.db");
626 OpenCallback helper;
627 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
628 EXPECT_EQ(store, nullptr);
629 EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
630 }
631
632 HWTEST_F(RdbHelperTest, GetDatabase_002, TestSize.Level0)
633 {
634 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
635 RdbStoreConfig config(dbPath);
636 std::string bundleName = "com.ohos.config.GetDatabase";
637 config.SetBundleName(bundleName);
638 config.SetArea(1);
639 config.SetEncryptStatus(true);
640
641 RdbHelper::DeleteRdbStore(config);
642
643 int errCode = E_OK;
644
645 RdbHelperTestOpenCallback helper;
646 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
647 EXPECT_EQ(errCode, E_OK);
648 EXPECT_NE(rdbStore1, nullptr);
649
650 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
651 EXPECT_EQ(errCode, E_OK);
652 EXPECT_NE(rdbStore2, nullptr);
653
654 EXPECT_EQ(rdbStore1, rdbStore2);
655 }
656
657 HWTEST_F(RdbHelperTest, GetDatabase_003, TestSize.Level0)
658 {
659 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
660 RdbStoreConfig config(dbPath);
661 std::string bundleName = "com.ohos.config.GetDatabase";
662 config.SetBundleName(bundleName);
663 config.SetArea(1);
664 config.SetEncryptStatus(true);
665
666 RdbHelper::DeleteRdbStore(config);
667
668 // Ensure that the database returns OK when it is successfully opened
669 int errCode = E_ERROR;
670
671 RdbHelperTestOpenCallback helper;
672 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
673 EXPECT_EQ(errCode, E_OK);
674 ASSERT_NE(rdbStore1, nullptr);
675
676 config.SetEncryptStatus(false);
677 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
678 // Ensure that the database can be opened after the encryption parameters are changed
679 EXPECT_EQ(errCode, E_OK);
680 ASSERT_NE(rdbStore2, nullptr);
681
682 // Ensure that two databases will not be opened after the encrypt parameters are changed
683 EXPECT_EQ(rdbStore1, rdbStore2);
684 }
685
686 HWTEST_F(RdbHelperTest, GetDatabase_004, TestSize.Level0)
687 {
688 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
689 RdbStoreConfig config(dbPath);
690 std::string bundleName = "com.ohos.config.GetDatabase";
691 config.SetBundleName(bundleName);
692 config.SetArea(1);
693 config.SetEncryptStatus(true);
694
695 RdbHelper::DeleteRdbStore(config);
696
697 int errCode = E_OK;
698
699 RdbHelperTestOpenCallback helper;
700 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
701 EXPECT_EQ(errCode, E_OK);
702 EXPECT_NE(rdbStore1, nullptr);
703
704 config.SetVisitorDir(dbPath);
705 config.SetRoleType(RoleType::VISITOR_WRITE);
706 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
707 EXPECT_NE(errCode, E_OK);
708 EXPECT_EQ(rdbStore2, nullptr);
709 }
710
711 HWTEST_F(RdbHelperTest, GetDatabase_005, TestSize.Level0)
712 {
713 const std::string dbPath = RDB_TEST_PATH + "GetSubUserDatabase.db";
714 RdbStoreConfig config(dbPath);
715 config.SetName("RdbStoreConfig_test.db");
716 std::string bundleName = "com.ohos.config.TestSubUser";
717 config.SetBundleName(bundleName);
718 config.SetSubUser(100);
719 auto subUser = config.GetSubUser();
720 EXPECT_EQ(subUser, 100);
721 int errCode = E_OK;
722
723 RdbHelperTestOpenCallback helper;
724 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
725 EXPECT_EQ(errCode, E_OK);
726 ASSERT_NE(rdbStore1, nullptr);
727
728 int ret = RdbHelper::DeleteRdbStore(config);
729 EXPECT_EQ(ret, E_OK);
730 }
731
732 /**
733 * @tc.name: GetDatabase_006
734 * @tc.desc: Insert after GetRdbStore
735 * @tc.type: FUNC
736 */
737 HWTEST_F(RdbHelperTest, GetDatabase_006, TestSize.Level0)
738 {
739 const std::string dbPath = RDB_TEST_PATH + "GetDatabase1.db";
740 RdbStoreConfig config(dbPath);
741 config.SetName("RdbStoreConfig_test.db");
742 std::string bundleName = "com.ohos.config.TestSubUser";
743 config.SetBundleName(bundleName);
744 config.SetSubUser(100);
745 auto subUser = config.GetSubUser();
746 EXPECT_EQ(subUser, 100);
747 int errCode = E_OK;
748
749 RdbHelperTestOpenCallback helper;
750 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
751 EXPECT_EQ(errCode, E_OK);
752 ASSERT_NE(rdbStore1, nullptr);
753 rdbStore1->ExecuteSql("CREATE TABLE IF NOT EXISTS test "
754 "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, age INTEGER, salary "
755 "REAL, blobType BLOB);");
756
757 int64_t id;
758 ValuesBucket values;
759 int deletedRows;
760
761 values.PutInt("id", 1);
762 values.PutString("name", std::string("zhangsan"));
763 values.PutInt("age", 18);
764 values.PutDouble("salary", 100.5);
765 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
766 int ret = rdbStore1->Insert(id, "test", values);
767 EXPECT_EQ(ret, E_OK);
768 EXPECT_EQ(1, id);
769
770 ret = rdbStore1->Delete(deletedRows, "test", "id = 1", std::vector<std::string>());
771 EXPECT_EQ(ret, E_OK);
772 EXPECT_EQ(deletedRows, 1);
773
774 ret = RdbHelper::DeleteRdbStore(config);
775 EXPECT_EQ(ret, E_OK);
776 }
777
778 /**
779 * @tc.name: GetDatabase_007
780 * @tc.desc: Insert after GetRdbStore
781 * @tc.type: FUNC
782 */
783 HWTEST_F(RdbHelperTest, GetDatabase_007, TestSize.Level0)
784 {
785 const std::string dbPath = RDB_TEST_PATH + "GetDatabase_007.db";
786 RdbStoreConfig config(dbPath);
787 config.SetStorageMode(StorageMode::MODE_MEMORY);
788
789 RdbHelper::DeleteRdbStore(config);
790
791 // Ensure that the database returns OK when it is successfully opened
792 int errCode = E_ERROR;
793
794 RdbHelperTestOpenCallback helper;
795 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
796 EXPECT_EQ(errCode, E_OK);
797 ASSERT_NE(rdbStore1, nullptr);
798
799 RdbHelper::DeleteRdbStore(dbPath);
800 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
801 // Ensure that the database can be opened after the encryption parameters are changed
802 EXPECT_EQ(errCode, E_OK);
803 ASSERT_NE(rdbStore2, nullptr);
804
805 // Ensure that two databases not equal
806 EXPECT_NE(rdbStore1, rdbStore2);
807 }