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 auto [code, result] = store->ExecuteExt(RdbHelperTestOpenCallback::CREATE_TABLE_TEST);
433 EXPECT_EQ(code, E_ALREADY_CLOSED);
434 }
435
436 /**
437 * @tc.name: DeleteDatabase_015
438 * @tc.desc: BeginTransaction after deleteRdbStore
439 * @tc.type: FUNC
440 */
441 HWTEST_F(RdbHelperTest, DeleteDatabase_015, TestSize.Level0)
442 {
443 InitDb();
444 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
445 EXPECT_EQ(ret, E_OK);
446
447 ret = store->BeginTransaction();
448 EXPECT_EQ(ret, E_ALREADY_CLOSED);
449 }
450
451 /**
452 * @tc.name: DeleteDatabase_016
453 * @tc.desc: Attach after deleteRdbStore
454 * @tc.type: FUNC
455 */
456 HWTEST_F(RdbHelperTest, DeleteDatabase_016, TestSize.Level0)
457 {
458 InitDb();
459 int ret = 0;
460 std::string attachPath = RDB_TEST_PATH + std::string("attached.db");
461 RdbStoreConfig attachedConfig(attachPath);
462 RdbHelperTestOpenCallback attachedHelper;
463 std::shared_ptr<RdbStore> attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, ret);
464 EXPECT_NE(attachedStore, nullptr);
465
466 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
467 EXPECT_EQ(ret, E_OK);
468
469 int busyTimeout = 2;
470 std::string attachedName = "attached";
471 auto err = store->Attach(attachedConfig, attachedName, busyTimeout);
472 EXPECT_EQ(err.first, E_ALREADY_CLOSED);
473
474 RdbHelper::DeleteRdbStore(attachPath);
475 }
476
477 /**
478 * @tc.name: DeleteDatabase_017
479 * @tc.desc: Detach after deleteRdbStore
480 * @tc.type: FUNC
481 */
482 HWTEST_F(RdbHelperTest, DeleteDatabase_017, TestSize.Level0)
483 {
484 InitDb();
485 int ret = 0;
486 std::string attachPath = RDB_TEST_PATH + std::string("attached.db");
487 RdbStoreConfig attachedConfig(attachPath);
488 RdbHelperTestOpenCallback attachedHelper;
489 std::shared_ptr<RdbStore> attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, ret);
490 EXPECT_NE(attachedStore, nullptr);
491
492 int busyTimeout = 2;
493 std::string attachedName = "attached";
494 auto err = store->Attach(attachedConfig, attachedName, busyTimeout);
495 EXPECT_EQ(err.first, E_OK);
496
497 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
498 EXPECT_EQ(ret, E_OK);
499
500 err = store->Detach(attachedName);
501 EXPECT_EQ(err.first, E_ALREADY_CLOSED);
502
503 RdbHelper::DeleteRdbStore(attachPath);
504 }
505
506 /**
507 * @tc.name: DeleteDatabase_018
508 * @tc.desc: CreateTransaction after deleteRdbStore
509 * @tc.type: FUNC
510 */
511 HWTEST_F(RdbHelperTest, DeleteDatabase_018, TestSize.Level0)
512 {
513 InitDb();
514 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
515 EXPECT_EQ(err, E_OK);
516
517 auto [ret, transaction] = store->CreateTransaction(Transaction::EXCLUSIVE);
518 ASSERT_EQ(ret, E_ALREADY_CLOSED);
519 ASSERT_EQ(transaction, nullptr);
520 }
521
522 /**
523 * @tc.name: DeleteDatabase_019
524 * @tc.desc: BeginTrans after deleteRdbStore
525 * @tc.type: FUNC
526 */
527 HWTEST_F(RdbHelperTest, DeleteDatabase_019, TestSize.Level0)
528 {
529 InitDb();
530 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
531 EXPECT_EQ(err, E_OK);
532
533 auto ret = store->BeginTrans();
534 ASSERT_EQ(ret.first, E_NOT_SUPPORT);
535 }
536
537 /**
538 * @tc.name: DeleteDatabase_020
539 * @tc.desc: Commit after deleteRdbStore
540 * @tc.type: FUNC
541 */
542 HWTEST_F(RdbHelperTest, DeleteDatabase_020, TestSize.Level0)
543 {
544 InitDb();
545 int ret = store->BeginTransaction();
546 EXPECT_EQ(ret, E_OK);
547
548 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
549 EXPECT_EQ(ret, E_OK);
550
551 ret = store->Commit();
552 ASSERT_EQ(ret, E_ALREADY_CLOSED);
553 }
554
555 /**
556 * @tc.name: DeleteDatabase_021
557 * @tc.desc: GetModifyTime after deleteRdbStore
558 * @tc.type: FUNC
559 */
560 HWTEST_F(RdbHelperTest, DeleteDatabase_021, TestSize.Level0)
561 {
562 InitDb();
563 store->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
564 "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
565 "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
566 int64_t rowId;
567 ValuesBucket valuesBucket;
568 valuesBucket.PutInt("data_key", ValueObject(2));
569 int errorCode = store->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
570 EXPECT_EQ(E_OK, errorCode);
571 EXPECT_EQ(1, rowId);
572
573 errorCode = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
574 EXPECT_EQ(errorCode, E_OK);
575
576 std::vector<RdbStore::PRIKey> PKey = { 1 };
577 std::map<RdbStore::PRIKey, RdbStore::Date> result =
578 store->GetModifyTime("rdbstoreimpltest_integer", "ROWID", PKey);
579 int size = result.size();
580 EXPECT_EQ(0, size);
581 }
582
583 /**
584 * @tc.name: DeleteDatabase_022
585 * @tc.desc: RollBack after deleteRdbStore
586 * @tc.type: FUNC
587 */
588 HWTEST_F(RdbHelperTest, DeleteDatabase_022, TestSize.Level0)
589 {
590 InitDb();
591 int ret = store->BeginTransaction();
592 EXPECT_EQ(ret, E_OK);
593
594 ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
595 EXPECT_EQ(ret, E_OK);
596
597 ret = store->RollBack();
598 ASSERT_EQ(ret, E_ALREADY_CLOSED);
599 }
600
601 /**
602 * @tc.name: DeleteDatabase_023
603 * @tc.desc: Transaction insert after deleteRdbStore
604 * @tc.type: FUNC
605 */
606 HWTEST_F(RdbHelperTest, DeleteDatabase_023, TestSize.Level0)
607 {
608 InitDb();
609 auto [ret, transaction] = store->CreateTransaction(Transaction::EXCLUSIVE);
610 ASSERT_EQ(ret, E_OK);
611 ASSERT_NE(transaction, nullptr);
612
613 int err = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
614 EXPECT_EQ(err, E_OK);
615
616 auto result = transaction->Insert("test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
617 ASSERT_EQ(result.first, E_ALREADY_CLOSED);
618 }
619
620 /**
621 * @tc.name: DeleteDatabase_024
622 * @tc.desc: BatchInsert after deleteRdbStore
623 * @tc.type: FUNC
624 */
625 HWTEST_F(RdbHelperTest, DeleteDatabase_024, TestSize.Level0)
626 {
627 InitDb();
628 ValuesBuckets rows;
629
630 int ret = RdbHelper::DeleteRdbStore(RdbHelperTest::rdbStorePath);
631 EXPECT_EQ(ret, E_OK);
632
633 for (int32_t i = 0; i < 10; i++) {
634 ValuesBucket row;
635 row.Put("id", i);
636 row.Put("name", "Jim");
637 rows.Put(row);
638 }
639 auto result = store->BatchInsert("test", rows, ConflictResolution::ON_CONFLICT_NONE);
640 EXPECT_EQ(result.first, E_ALREADY_CLOSED);
641 }
642
643 /**
644 * @tc.name: getrdbstore_001
645 * @tc.desc: get db file with a invalid path
646 * @tc.type: FUNC
647 */
648 HWTEST_F(RdbHelperTest, GetDatabase_001, TestSize.Level0)
649 {
650 int errCode = E_OK;
651 RdbStoreConfig config("/invalid/invalid/test.db");
652 OpenCallback helper;
653 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
654 EXPECT_EQ(store, nullptr);
655 EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
656 }
657
658 HWTEST_F(RdbHelperTest, GetDatabase_002, TestSize.Level0)
659 {
660 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
661 RdbStoreConfig config(dbPath);
662 std::string bundleName = "com.ohos.config.GetDatabase";
663 config.SetBundleName(bundleName);
664 config.SetArea(1);
665 config.SetEncryptStatus(true);
666
667 RdbHelper::DeleteRdbStore(config);
668
669 int errCode = E_OK;
670
671 RdbHelperTestOpenCallback helper;
672 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
673 EXPECT_EQ(errCode, E_OK);
674 EXPECT_NE(rdbStore1, nullptr);
675
676 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
677 EXPECT_EQ(errCode, E_OK);
678 EXPECT_NE(rdbStore2, nullptr);
679
680 EXPECT_EQ(rdbStore1, rdbStore2);
681 }
682
683 HWTEST_F(RdbHelperTest, GetDatabase_003, TestSize.Level0)
684 {
685 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
686 RdbStoreConfig config(dbPath);
687 std::string bundleName = "com.ohos.config.GetDatabase";
688 config.SetBundleName(bundleName);
689 config.SetArea(1);
690 config.SetEncryptStatus(true);
691
692 RdbHelper::DeleteRdbStore(config);
693
694 // Ensure that the database returns OK when it is successfully opened
695 int errCode = E_ERROR;
696
697 RdbHelperTestOpenCallback helper;
698 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
699 EXPECT_EQ(errCode, E_OK);
700 ASSERT_NE(rdbStore1, nullptr);
701
702 config.SetEncryptStatus(false);
703 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
704 // Ensure that the database can be opened after the encryption parameters are changed
705 EXPECT_EQ(errCode, E_OK);
706 ASSERT_NE(rdbStore2, nullptr);
707
708 // Ensure that two databases will not be opened after the encrypt parameters are changed
709 EXPECT_EQ(rdbStore1, rdbStore2);
710 }
711
712 HWTEST_F(RdbHelperTest, GetDatabase_004, TestSize.Level0)
713 {
714 const std::string dbPath = RDB_TEST_PATH + "GetDatabase.db";
715 RdbStoreConfig config(dbPath);
716 std::string bundleName = "com.ohos.config.GetDatabase";
717 config.SetBundleName(bundleName);
718 config.SetArea(1);
719 config.SetEncryptStatus(true);
720
721 RdbHelper::DeleteRdbStore(config);
722
723 int errCode = E_OK;
724
725 RdbHelperTestOpenCallback helper;
726 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
727 EXPECT_EQ(errCode, E_OK);
728 EXPECT_NE(rdbStore1, nullptr);
729
730 config.SetVisitorDir(dbPath);
731 config.SetRoleType(RoleType::VISITOR_WRITE);
732 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
733 EXPECT_NE(errCode, E_OK);
734 EXPECT_EQ(rdbStore2, nullptr);
735 }
736
737 HWTEST_F(RdbHelperTest, GetDatabase_005, TestSize.Level0)
738 {
739 const std::string dbPath = RDB_TEST_PATH + "GetSubUserDatabase.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
754 int ret = RdbHelper::DeleteRdbStore(config);
755 EXPECT_EQ(ret, E_OK);
756 }
757
758 /**
759 * @tc.name: GetDatabase_006
760 * @tc.desc: Insert after GetRdbStore
761 * @tc.type: FUNC
762 */
763 HWTEST_F(RdbHelperTest, GetDatabase_006, TestSize.Level0)
764 {
765 const std::string dbPath = RDB_TEST_PATH + "GetDatabase1.db";
766 RdbStoreConfig config(dbPath);
767 config.SetName("RdbStoreConfig_test.db");
768 std::string bundleName = "com.ohos.config.TestSubUser";
769 config.SetBundleName(bundleName);
770 config.SetSubUser(100);
771 auto subUser = config.GetSubUser();
772 EXPECT_EQ(subUser, 100);
773 int errCode = E_OK;
774
775 RdbHelperTestOpenCallback helper;
776 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
777 EXPECT_EQ(errCode, E_OK);
778 ASSERT_NE(rdbStore1, nullptr);
779 rdbStore1->ExecuteSql("CREATE TABLE IF NOT EXISTS test "
780 "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, age INTEGER, salary "
781 "REAL, blobType BLOB);");
782
783 int64_t id;
784 ValuesBucket values;
785 int deletedRows;
786
787 values.PutInt("id", 1);
788 values.PutString("name", std::string("zhangsan"));
789 values.PutInt("age", 18);
790 values.PutDouble("salary", 100.5);
791 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
792 int ret = rdbStore1->Insert(id, "test", values);
793 EXPECT_EQ(ret, E_OK);
794 EXPECT_EQ(1, id);
795
796 ret = rdbStore1->Delete(deletedRows, "test", "id = 1", std::vector<std::string>());
797 EXPECT_EQ(ret, E_OK);
798 EXPECT_EQ(deletedRows, 1);
799
800 ret = RdbHelper::DeleteRdbStore(config);
801 EXPECT_EQ(ret, E_OK);
802 }
803
804 /**
805 * @tc.name: GetDatabase_007
806 * @tc.desc: Insert after GetRdbStore
807 * @tc.type: FUNC
808 */
809 HWTEST_F(RdbHelperTest, GetDatabase_007, TestSize.Level0)
810 {
811 const std::string dbPath = RDB_TEST_PATH + "GetDatabase_007.db";
812 RdbStoreConfig config(dbPath);
813 config.SetStorageMode(StorageMode::MODE_MEMORY);
814
815 RdbHelper::DeleteRdbStore(config);
816
817 // Ensure that the database returns OK when it is successfully opened
818 int errCode = E_ERROR;
819
820 RdbHelperTestOpenCallback helper;
821 std::shared_ptr<RdbStore> rdbStore1 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
822 EXPECT_EQ(errCode, E_OK);
823 ASSERT_NE(rdbStore1, nullptr);
824
825 RdbHelper::DeleteRdbStore(dbPath);
826 std::shared_ptr<RdbStore> rdbStore2 = RdbHelper::GetRdbStore(config, 1, helper, errCode);
827 // Ensure that the database can be opened after the encryption parameters are changed
828 EXPECT_EQ(errCode, E_OK);
829 ASSERT_NE(rdbStore2, nullptr);
830
831 // Ensure that two databases not equal
832 EXPECT_NE(rdbStore1, rdbStore2);
833 }
834