1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
16
17 #include <fstream>
18 #include <map>
19 #include <string>
20
21 #include "common.h"
22 #include "file_ex.h"
23 #include "rdb_errno.h"
24 #include "rdb_helper.h"
25 #include "rdb_open_callback.h"
26 #include "rdb_store_impl.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::NativeRdb;
30
31 class RdbStoreBackupRestoreTest : public testing::Test {
32 public:
SetUpTestCase()33 static void SetUpTestCase()
34 {
35 }
TearDownTestCase()36 static void TearDownTestCase()
37 {
38 }
39 void SetUp();
40 void TearDown();
41 void CorruptDoubleWriteStore();
42 void CheckResultSet(std::shared_ptr<RdbStore> &store);
43 void CheckAge(std::shared_ptr<ResultSet> &resultSet);
44 void CheckSalary(std::shared_ptr<ResultSet> &resultSet);
45 void CheckBlob(std::shared_ptr<ResultSet> &resultSet);
46
47 static constexpr char DATABASE_NAME[] = "/data/test/backup_restore_test.db";
48 static constexpr char slaveDataBaseName[] = "/data/test/backup_restore_test_slave.db";
49 static constexpr char BACKUP_DATABASE_NAME[] = "/data/test/backup_restore_test_backup.db";
50 };
51
52 class RdbStoreBackupRestoreTestOpenCallback : public RdbOpenCallback {
53 public:
54 int OnCreate(RdbStore &store) override;
55 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
56 static const std::string CREATE_TABLE_TEST;
57 };
58
59 const std::string RdbStoreBackupRestoreTestOpenCallback::CREATE_TABLE_TEST =
60 std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
61 "name TEXT NOT NULL, age INTEGER, salary "
62 "REAL, blobType BLOB)");
63
OnCreate(RdbStore & store)64 int RdbStoreBackupRestoreTestOpenCallback::OnCreate(RdbStore &store)
65 {
66 return store.ExecuteSql(CREATE_TABLE_TEST);
67 }
68
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)69 int RdbStoreBackupRestoreTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
70 {
71 return E_OK;
72 }
SetUp(void)73 void RdbStoreBackupRestoreTest::SetUp(void)
74 {
75 RdbHelper::ClearCache();
76 int errocode = RdbHelper::DeleteRdbStore(DATABASE_NAME);
77 EXPECT_EQ(E_OK, errocode);
78 errocode = RdbHelper::DeleteRdbStore(BACKUP_DATABASE_NAME);
79 EXPECT_EQ(E_OK, errocode);
80 }
TearDown(void)81 void RdbStoreBackupRestoreTest::TearDown(void)
82 {
83 RdbHelper::ClearCache();
84 int errocode = RdbHelper::DeleteRdbStore(DATABASE_NAME);
85 EXPECT_EQ(E_OK, errocode);
86 errocode = RdbHelper::DeleteRdbStore(BACKUP_DATABASE_NAME);
87 EXPECT_EQ(E_OK, errocode);
88 }
CorruptDoubleWriteStore(void)89 void RdbStoreBackupRestoreTest::CorruptDoubleWriteStore(void)
90 {
91 std::fstream file(DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
92 ASSERT_TRUE(file.is_open() == true);
93 const int seekPosition = 30;
94 file.seekp(seekPosition, std::ios::beg);
95 ASSERT_TRUE(file.good() == true);
96 const int bytesToWrite = 2;
97 char bytes[bytesToWrite] = { 0x6, 0x6 };
98 file.write(bytes, bytesToWrite);
99 ASSERT_TRUE(file.good() == true);
100 file.close();
101 }
102
103 /* *
104 * @tc.name: Rdb_BackupRestoreTest_001
105 * @tc.desc: backup and restore
106 * @tc.type: FUNC
107 */
108 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_001, TestSize.Level2)
109 {
110 int errCode = E_OK;
111 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
112 config.SetEncryptStatus(true);
113 RdbStoreBackupRestoreTestOpenCallback helper;
114 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
115 EXPECT_EQ(errCode, E_OK);
116 EXPECT_NE(store, nullptr);
117
118 int64_t id;
119 ValuesBucket values;
120
121 values.PutInt("id", 1);
122 values.PutString("name", std::string("zhangsan"));
123 values.PutInt("age", 18);
124 values.PutDouble("salary", 100.5);
125 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
126 int ret = store->Insert(id, "test", values);
127 EXPECT_EQ(ret, E_OK);
128 EXPECT_EQ(1, id);
129
130 ret = store->Backup(BACKUP_DATABASE_NAME);
131 EXPECT_EQ(ret, E_OK);
132
133 int deletedRows = 0;
134 ret = store->Delete(deletedRows, "test", "id = 1");
135 EXPECT_EQ(ret, E_OK);
136 EXPECT_EQ(1, deletedRows);
137
138 ret = store->Restore(BACKUP_DATABASE_NAME);
139 EXPECT_EQ(ret, E_OK);
140
141 std::shared_ptr<ResultSet> resultSet =
142 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
143 ret = resultSet->GoToFirstRow();
144 EXPECT_EQ(ret, E_OK);
145 ret = resultSet->Close();
146 EXPECT_EQ(ret, E_OK);
147 }
148
149 /* *
150 * @tc.name: Rdb_BackupRestoreTest_002
151 * @tc.desc: backup and restore for broken original and broken backup db
152 * @tc.type: FUNC
153 */
154 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_002, TestSize.Level2)
155 {
156 int errCode = E_OK;
157 RdbStoreConfig config(DATABASE_NAME);
158 config.SetEncryptStatus(true);
159 RdbStoreBackupRestoreTestOpenCallback helper;
160 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
161 EXPECT_EQ(errCode, E_OK);
162 EXPECT_NE(store, nullptr);
163
164 int64_t id;
165 ValuesBucket values;
166
167 values.PutInt("id", 1);
168 values.PutString("name", std::string("zhangsan"));
169 values.PutInt("age", 18);
170 values.PutDouble("salary", 100.5);
171 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
172 int ret = store->Insert(id, "test", values);
173 EXPECT_EQ(ret, E_OK);
174 EXPECT_EQ(1, id);
175
176 ret = store->Backup(BACKUP_DATABASE_NAME);
177 EXPECT_EQ(ret, E_OK);
178 store = nullptr;
179
180 std::ofstream fsDb(DATABASE_NAME, std::ios_base::binary | std::ios_base::out);
181 fsDb.seekp(64);
182 fsDb.write("hello", 5);
183 fsDb.close();
184 std::ofstream fsBackupDb(BACKUP_DATABASE_NAME, std::ios_base::binary | std::ios_base::out);
185 fsBackupDb.seekp(64);
186 fsBackupDb.write("hello", 5);
187 fsBackupDb.close();
188
189 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
190 EXPECT_EQ(errCode, E_SQLITE_CORRUPT);
191 RdbHelper::DeleteRdbStore(DATABASE_NAME);
192
193 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
194 EXPECT_EQ(errCode, E_OK);
195
196 ret = store->Restore(BACKUP_DATABASE_NAME);
197 EXPECT_EQ(ret, E_SQLITE_CORRUPT);
198
199 ret = store->ExecuteSql(RdbStoreBackupRestoreTestOpenCallback::CREATE_TABLE_TEST);
200 EXPECT_EQ(ret, E_OK);
201 }
202
203 /* *
204 * @tc.name: Rdb_BackupRestoreTest_003
205 * @tc.desc: backup and restore
206 * @tc.type: FUNC
207 */
208 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_003, TestSize.Level2)
209 {
210 int errCode = E_OK;
211 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
212 config.SetEncryptStatus(true);
213 config.SetAllowRebuild(true);
214 config.SetHaMode(HAMode::MAIN_REPLICA);
215 RdbStoreBackupRestoreTestOpenCallback helper;
216 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
217 EXPECT_EQ(errCode, E_OK);
218 EXPECT_NE(store, nullptr);
219
220 int64_t id;
221 ValuesBucket values;
222
223 values.PutInt("id", 1);
224 values.PutString("name", std::string("zhangsan"));
225 values.PutInt("age", 18);
226 values.PutDouble("salary", 100.5);
227 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
228 int ret = store->Insert(id, "test", values);
229 EXPECT_EQ(ret, E_OK);
230 EXPECT_EQ(1, id);
231
232 ret = store->Backup(BACKUP_DATABASE_NAME);
233 EXPECT_EQ(ret, E_OK);
234
235 int deletedRows = 0;
236 ret = store->Delete(deletedRows, "test", "id = 1");
237 EXPECT_EQ(ret, E_OK);
238 EXPECT_EQ(1, deletedRows);
239
240 ret = store->Restore(BACKUP_DATABASE_NAME);
241 EXPECT_EQ(ret, E_OK);
242
243 std::shared_ptr<ResultSet> resultSet =
244 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
245 ret = resultSet->GoToFirstRow();
246 EXPECT_EQ(ret, E_OK);
247 ret = resultSet->Close();
248 EXPECT_EQ(ret, E_OK);
249 }
250
251 /* *
252 * @tc.name: Rdb_BackupRestoreTest_004
253 * @tc.desc: hamode is replica, backup and deletestore and restore, after restore can insert
254 * @tc.type: FUNC
255 */
256 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_004, TestSize.Level2)
257 {
258 int errCode = E_OK;
259 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
260 config.SetEncryptStatus(true);
261 config.SetHaMode(HAMode::MAIN_REPLICA);
262 RdbStoreBackupRestoreTestOpenCallback helper;
263 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
264 EXPECT_EQ(errCode, E_OK);
265 EXPECT_NE(store, nullptr);
266
267 int64_t id;
268 ValuesBucket values;
269
270 values.Put("id", 1);
271 values.Put("name", std::string("zhangsan"));
272 values.Put("age", 18);
273 values.Put("salary", 100.5);
274 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
275 int ret = store->Insert(id, "test", values);
276 EXPECT_EQ(ret, E_OK);
277 EXPECT_EQ(1, id);
278
279 ret = store->Backup(BACKUP_DATABASE_NAME);
280 EXPECT_EQ(ret, E_OK);
281
282 ret = RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
283 EXPECT_EQ(ret, E_OK);
284
285 ret = store->Restore(BACKUP_DATABASE_NAME);
286 EXPECT_EQ(ret, E_ALREADY_CLOSED);
287 }
288
289 /* *
290 * @tc.name: Rdb_BackupRestoreTest_005
291 * @tc.desc: hamode is replica , backup and restore for broken original db, and after restore can insert
292 * @tc.type: FUNC
293 */
294 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_005, TestSize.Level2)
295 {
296 int errCode = E_OK;
297 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
298 config.SetEncryptStatus(true);
299 config.SetHaMode(HAMode::MAIN_REPLICA);
300 RdbStoreBackupRestoreTestOpenCallback helper;
301 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
302 EXPECT_EQ(errCode, E_OK);
303 EXPECT_NE(store, nullptr);
304
305 int64_t id;
306 ValuesBucket values;
307
308 values.Put("id", 1);
309 values.Put("name", std::string("zhangsan"));
310 values.Put("age", 18);
311 values.Put("salary", 100.5);
312 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
313 int ret = store->Insert(id, "test", values);
314 EXPECT_EQ(ret, E_OK);
315 EXPECT_EQ(1, id);
316
317 ret = store->Backup(BACKUP_DATABASE_NAME);
318 EXPECT_EQ(ret, E_OK);
319
320 store = nullptr;
321 CorruptDoubleWriteStore();
322 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
323 EXPECT_EQ(errCode, E_OK);
324
325 int deletedRows = 0;
326 ret = store->Delete(deletedRows, "test", "id = 1");
327 EXPECT_EQ(ret, E_OK);
328 EXPECT_EQ(1, deletedRows);
329
330 ret = store->Restore(BACKUP_DATABASE_NAME);
331 EXPECT_EQ(ret, E_OK);
332
333 std::shared_ptr<ResultSet> resultSet =
334 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
335 ret = resultSet->GoToFirstRow();
336 EXPECT_EQ(ret, E_OK);
337 ret = resultSet->GoToNextRow();
338 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
339 ret = resultSet->Close();
340 EXPECT_EQ(ret, E_OK);
341 }
342
343 /* *
344 * @tc.name: Rdb_BackupRestoreTest_006
345 * @tc.desc: hamode is replica , backup and restore, aftre restore ,store can insert data and delete data and query
346 * @tc.type: FUNC
347 */
348 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_006, TestSize.Level2)
349 {
350 int errCode = E_OK;
351 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
352 config.SetEncryptStatus(true);
353 config.SetHaMode(HAMode::MAIN_REPLICA);
354 RdbStoreBackupRestoreTestOpenCallback helper;
355 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
356 EXPECT_EQ(errCode, E_OK);
357 EXPECT_NE(store, nullptr);
358
359 int64_t id;
360 ValuesBucket values;
361
362 values.Put("id", 1);
363 values.Put("name", std::string("zhangsan"));
364 values.Put("age", 18);
365 values.Put("salary", 100.5);
366 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
367 int ret = store->Insert(id, "test", values);
368 EXPECT_EQ(ret, E_OK);
369 EXPECT_EQ(1, id);
370
371 ret = store->Backup(BACKUP_DATABASE_NAME);
372 EXPECT_EQ(ret, E_OK);
373
374 int deletedRows = 0;
375 ret = store->Delete(deletedRows, "test", "id = 1");
376 EXPECT_EQ(ret, E_OK);
377 EXPECT_EQ(1, deletedRows);
378
379 ret = store->Restore(BACKUP_DATABASE_NAME);
380 EXPECT_EQ(ret, E_OK);
381 std::shared_ptr<ResultSet> resultSet =
382 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
383 ret = resultSet->GoToFirstRow();
384 EXPECT_EQ(ret, E_OK);
385 ret = resultSet->Close();
386 EXPECT_EQ(ret, E_OK);
387
388 deletedRows = 0;
389 ret = store->Delete(deletedRows, "test", "id = 1");
390 EXPECT_EQ(ret, E_OK);
391 EXPECT_EQ(1, deletedRows);
392 resultSet = store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
393 ret = resultSet->GoToFirstRow();
394 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
395 ret = resultSet->Close();
396 EXPECT_EQ(ret, E_OK);
397 }
398
399 /* *
400 * @tc.name: Rdb_BackupRestoreTest_007
401 * @tc.desc: hamode is replica , deletestore , cannot backup and restore
402 * @tc.type: FUNC
403 */
404 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_007, TestSize.Level2)
405 {
406 int errCode = E_OK;
407 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
408 config.SetEncryptStatus(true);
409 config.SetHaMode(HAMode::MAIN_REPLICA);
410 RdbStoreBackupRestoreTestOpenCallback helper;
411 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
412 EXPECT_EQ(errCode, E_OK);
413 EXPECT_NE(store, nullptr);
414
415 int64_t id;
416 ValuesBucket values;
417
418 values.Put("id", 1);
419 values.Put("name", std::string("zhangsan"));
420 values.Put("age", 18);
421 values.Put("salary", 100.5);
422 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
423 int ret = store->Insert(id, "test", values);
424 EXPECT_EQ(ret, E_OK);
425 EXPECT_EQ(1, id);
426
427 ret = RdbHelper::DeleteRdbStore(DATABASE_NAME);
428 EXPECT_EQ(ret, E_OK);
429
430 ret = store->Backup(BACKUP_DATABASE_NAME);
431 EXPECT_EQ(ret, E_DB_NOT_EXIST);
432 }
433
434 /* *
435 * @tc.name: Rdb_BackupRestoreTest_008
436 * @tc.desc: hamode is replica , backup and restore, check slavestore and backupstore
437 * @tc.type: FUNC
438 */
439 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_008, TestSize.Level2)
440 {
441 int errCode = E_OK;
442 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
443 config.SetEncryptStatus(true);
444 config.SetHaMode(HAMode::MAIN_REPLICA);
445 RdbStoreBackupRestoreTestOpenCallback helper;
446 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
447 EXPECT_EQ(errCode, E_OK);
448 EXPECT_NE(store, nullptr);
449
450 int64_t id;
451 ValuesBucket values;
452
453 values.Put("id", 1);
454 values.Put("name", std::string("zhangsan"));
455 values.Put("age", 18);
456 values.Put("salary", 100.5);
457 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
458 int ret = store->Insert(id, "test", values);
459 EXPECT_EQ(ret, E_OK);
460 EXPECT_EQ(1, id);
461
462 ret = store->Backup(BACKUP_DATABASE_NAME);
463 EXPECT_EQ(ret, E_OK);
464
465 int deletedRows = 0;
466 ret = store->Delete(deletedRows, "test", "id = 1");
467 EXPECT_EQ(ret, E_OK);
468 EXPECT_EQ(1, deletedRows);
469
470 ret = store->Restore(BACKUP_DATABASE_NAME);
471 EXPECT_EQ(ret, E_OK);
472
473 std::shared_ptr<ResultSet> resultSet =
474 store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
475 ret = resultSet->GoToFirstRow();
476 EXPECT_EQ(ret, E_OK);
477 ret = resultSet->GoToNextRow();
478 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
479 ret = resultSet->Close();
480 EXPECT_EQ(ret, E_OK);
481
482 EXPECT_EQ(0, access(BACKUP_DATABASE_NAME, F_OK));
483 EXPECT_EQ(0, access(slaveDataBaseName, F_OK));
484 }
485
486 /* *
487 * @tc.name: Rdb_BackupRestoreTest_009
488 * @tc.desc: sql func empty param test
489 * @tc.type: FUNC
490 */
491 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_009, TestSize.Level2)
492 {
493 int errCode = E_OK;
494 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
495 config.SetEncryptStatus(false);
496 RdbStoreBackupRestoreTestOpenCallback helper;
497 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
498 EXPECT_EQ(errCode, E_OK);
499 EXPECT_NE(store, nullptr);
500
501 auto res = store->ExecuteSql("SELECT import_db_from_path()");
502
503 EXPECT_EQ(res, E_SQLITE_ERROR);
504
505 auto [code, result] = store->Execute("pragma integrity_check");
506 std::string val;
507 result.GetString(val);
508 EXPECT_EQ(E_OK, code);
509 EXPECT_EQ("ok", val);
510
511 store = nullptr;
512 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
513 }
514
515 /* *
516 * @tc.name: Rdb_BackupRestoreTest_010
517 * @tc.desc: source db empty path test
518 * @tc.type: FUNC
519 */
520 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_010, TestSize.Level2)
521 {
522 int errCode = E_OK;
523 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
524 config.SetEncryptStatus(false);
525 RdbStoreBackupRestoreTestOpenCallback helper;
526 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
527 EXPECT_EQ(errCode, E_OK);
528 EXPECT_NE(store, nullptr);
529
530 auto res = store->ExecuteSql("SELECT import_db_from_path('')");
531
532 EXPECT_EQ(res, E_SQLITE_CANTOPEN);
533
534 auto [code, result] = store->Execute("pragma integrity_check");
535 std::string val;
536 result.GetString(val);
537 EXPECT_EQ(E_OK, code);
538 EXPECT_EQ("ok", val);
539
540 store = nullptr;
541 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
542 }
543
544 /* *
545 * @tc.name: Rdb_BackupRestoreTest_011
546 * @tc.desc: souce db not exist test
547 * @tc.type: FUNC
548 */
549 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_011, TestSize.Level2)
550 {
551 int errCode = E_OK;
552 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
553 config.SetEncryptStatus(false);
554 RdbStoreBackupRestoreTestOpenCallback helper;
555 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
556 EXPECT_EQ(errCode, E_OK);
557 EXPECT_NE(store, nullptr);
558
559 auto res = store->ExecuteSql("SELECT import_db_from_path('/path/not_exist.db')");
560
561 EXPECT_EQ(res, E_SQLITE_CANTOPEN);
562
563 auto [code, result] = store->Execute("pragma integrity_check");
564 std::string val;
565 result.GetString(val);
566 EXPECT_EQ(E_OK, code);
567 EXPECT_EQ("ok", val);
568
569 store = nullptr;
570 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
571 }
572
573 /* *
574 * @tc.name: Rdb_BackupRestoreTest_012
575 * @tc.desc: source db corrupt test
576 * @tc.type: FUNC
577 */
578 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_012, TestSize.Level2)
579 {
580 int errCode = E_OK;
581 std::string destDbPath = "/data/test/dest.db";
582 std::string sourceDbPath = "/data/test/source.db";
583
584 RdbStoreConfig config(destDbPath);
585 config.SetEncryptStatus(false);
586 RdbStoreBackupRestoreTestOpenCallback helper;
587 auto dest = RdbHelper::GetRdbStore(config, 1, helper, errCode);
588 EXPECT_EQ(errCode, E_OK);
589 EXPECT_NE(dest, nullptr);
590
591 RdbStoreConfig sourceConfig(sourceDbPath);
592 sourceConfig.SetEncryptStatus(false);
593 RdbStoreBackupRestoreTestOpenCallback helper1;
594 auto source = RdbHelper::GetRdbStore(sourceConfig, 1, helper1, errCode);
595 source = nullptr;
596
597 std::fstream sourceFile(sourceDbPath, std::ios::in | std::ios::out | std::ios::binary);
598 ASSERT_TRUE(sourceFile.is_open());
599 sourceFile.seekp(0x0f40, std::ios::beg);
600 std::vector<char> buffer(32, 0xFF);
601 sourceFile.write(buffer.data(), buffer.size());
602 sourceFile.close();
603
604 auto res = dest->ExecuteSql("SELECT import_db_from_path('" + sourceDbPath + "')");
605
606 EXPECT_EQ(res, E_SQLITE_CORRUPT);
607
608 auto [code, result] = dest->Execute("pragma integrity_check");
609 std::string val;
610 result.GetString(val);
611 EXPECT_EQ(E_OK, code);
612 EXPECT_EQ("ok", val);
613
614 dest = nullptr;
615 RdbHelper::DeleteRdbStore(destDbPath);
616 RdbHelper::DeleteRdbStore(sourceDbPath);
617 }
618
619 /* *
620 * @tc.name: Rdb_BackupRestoreTest_013
621 * @tc.desc: import from source db test
622 * @tc.type: FUNC
623 */
624 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_013, TestSize.Level2)
625 {
626 int errCode = E_OK;
627 std::string destDbPath = "/data/test/dest.db";
628 std::string sourceDbPath = "/data/test/source.db";
629
630 RdbStoreConfig config(destDbPath);
631 config.SetEncryptStatus(false);
632 RdbStoreBackupRestoreTestOpenCallback helper;
633 auto dest = RdbHelper::GetRdbStore(config, 1, helper, errCode);
634 EXPECT_EQ(errCode, E_OK);
635 EXPECT_NE(dest, nullptr);
636
637 RdbStoreConfig sourceConfig(sourceDbPath);
638 sourceConfig.SetEncryptStatus(false);
639 RdbStoreBackupRestoreTestOpenCallback helper1;
640 auto source = RdbHelper::GetRdbStore(sourceConfig, 1, helper1, errCode);
641
642 for (uint i = 0; i < 100; i++) {
643 std::vector<ValuesBucket> valuesBuckets;
644
645 for (uint j = 0; j < 100; j++) {
646 ValuesBucket value;
647
648 value.Put("name", "zhangsan");
649 value.PutString("name", "zhangSan");
650 valuesBuckets.push_back(std::move(value));
651 }
652
653 int64_t insertRowCount;
654 int error = source->BatchInsert(insertRowCount, "test", valuesBuckets);
655 EXPECT_EQ(error, E_OK);
656 }
657 source = nullptr;
658 EXPECT_EQ(E_OK, dest->ExecuteSql("SELECT import_db_from_path('" + sourceDbPath + "')"));
659
660 auto resultSet = dest->QuerySql("SELECT * FROM test");
661 int rowCount;
662 EXPECT_EQ(E_OK, resultSet->GetRowCount(rowCount));
663
664 EXPECT_EQ(rowCount, 10000);
665
666 auto [code, result] = dest->Execute("pragma integrity_check");
667 std::string val;
668 result.GetString(val);
669 EXPECT_EQ(E_OK, code);
670 EXPECT_EQ("ok", val);
671
672 dest = nullptr;
673 RdbHelper::DeleteRdbStore(destDbPath);
674 RdbHelper::DeleteRdbStore(sourceDbPath);
675 }
676
677 /* *
678 * @tc.name: Rdb_BackupRestoreTest_014
679 * @tc.desc: sql func empty param test
680 * @tc.type: FUNC
681 */
682 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_014, TestSize.Level2)
683 {
684 int errCode = E_OK;
685 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
686 config.SetEncryptStatus(false);
687 RdbStoreBackupRestoreTestOpenCallback helper;
688 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
689 EXPECT_EQ(errCode, E_OK);
690 EXPECT_NE(store, nullptr);
691
692 auto res = store->ExecuteSql("SELECT import_db_from_path");
693
694 EXPECT_EQ(res, E_SQLITE_SCHEMA);
695
696 auto [code, result] = store->Execute("pragma integrity_check");
697 std::string val;
698 result.GetString(val);
699 EXPECT_EQ(E_OK, code);
700 EXPECT_EQ("ok", val);
701
702 store = nullptr;
703 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
704 }
705
706 /* *
707 * @tc.name: Rdb_BackupRestoreTest_015
708 * @tc.desc: restore wal file exist test
709 * @tc.type: FUNC
710 */
711 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_015, TestSize.Level2)
712 {
713 int errCode = E_OK;
714 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
715 config.SetEncryptStatus(false);
716 RdbStoreBackupRestoreTestOpenCallback helper;
717 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
718 EXPECT_EQ(errCode, E_OK);
719 EXPECT_NE(store, nullptr);
720
721 int ret = store->Backup(BACKUP_DATABASE_NAME);
722 EXPECT_EQ(ret, E_OK);
723
724 RdbStoreConfig backupConfig(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
725 backupConfig.SetEncryptStatus(false);
726 RdbStoreBackupRestoreTestOpenCallback backupHelper;
727 auto backupStore = RdbHelper::GetRdbStore(backupConfig, 1, backupHelper, errCode);
728 EXPECT_EQ(errCode, E_OK);
729 EXPECT_NE(backupStore, nullptr);
730 backupStore = nullptr;
731
732 struct stat fileStat;
733 std::string walFilePath = std::string(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME) + "-wal";
734 EXPECT_EQ(stat(walFilePath.c_str(), &fileStat), 0);
735
736 ret = store->Restore(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
737 EXPECT_EQ(ret, E_OK);
738 ret = stat(walFilePath.c_str(), &fileStat);
739 EXPECT_EQ(ret, -1);
740 EXPECT_EQ(errno, 2);
741
742 store = nullptr;
743 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
744 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
745 }
746
747 /* *
748 * @tc.name: Rdb_BackupRestoreTest_016
749 * @tc.desc: restore wal file not empty
750 * @tc.type: FUNC
751 */
752 HWTEST_F(RdbStoreBackupRestoreTest, Rdb_BackupRestoreTest_016, TestSize.Level2)
753 {
754 int errCode = E_OK;
755 RdbStoreConfig config(RdbStoreBackupRestoreTest::DATABASE_NAME);
756 config.SetEncryptStatus(false);
757 RdbStoreBackupRestoreTestOpenCallback helper;
758 auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
759 EXPECT_EQ(errCode, E_OK);
760 EXPECT_NE(store, nullptr);
761
762 int ret = store->Backup(BACKUP_DATABASE_NAME);
763 EXPECT_EQ(ret, E_OK);
764
765 RdbStoreConfig backupConfig(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
766 backupConfig.SetEncryptStatus(false);
767 RdbStoreBackupRestoreTestOpenCallback backupHelper;
768 auto backupStore = RdbHelper::GetRdbStore(backupConfig, 1, backupHelper, errCode);
769 EXPECT_EQ(errCode, E_OK);
770 EXPECT_NE(backupStore, nullptr);
771
772 int64_t id;
773 ValuesBucket values;
774
775 values.PutInt("id", 1);
776 values.PutString("name", std::string("zhangsan"));
777 values.PutInt("age", 18);
778 values.PutDouble("salary", 100.5);
779 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
780 ret = backupStore->Insert(id, "test", values);
781 EXPECT_EQ(ret, E_OK);
782 EXPECT_EQ(1, id);
783
784 struct stat fileStat;
785 std::string walFilePath = std::string(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME) + "-wal";
786 EXPECT_EQ(stat(walFilePath.c_str(), &fileStat), 0);
787 EXPECT_NE(fileStat.st_size, 0);
788
789 ret = store->Restore(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
790 EXPECT_EQ(ret, E_SQLITE_CORRUPT);
791
792 backupStore = nullptr;
793 store = nullptr;
794 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::DATABASE_NAME);
795 RdbHelper::DeleteRdbStore(RdbStoreBackupRestoreTest::BACKUP_DATABASE_NAME);
796 }
797