1 /*
2  * Copyright (c) 2023 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 
18 #include "db_common.h"
19 #include "distributeddb_storage_single_ver_natural_store_testcase.h"
20 #include "storage_engine_manager.h"
21 
22 using namespace testing::ext;
23 using namespace DistributedDB;
24 using namespace DistributedDBUnitTest;
25 using namespace std;
26 
27 namespace {
28     string g_testDir;
29     string g_databaseName;
30     string g_identifier;
31     string g_cacheDir;
32     KvDBProperties g_property;
33 
34     SQLiteSingleVerNaturalStore *g_store = nullptr;
35     SQLiteSingleVerNaturalStoreConnection *g_connection = nullptr;
36 
37     const char * const ADD_SYNC = "ALTER TABLE sync_data ADD column version INT";
38     const char * const INSERT_SQL = "INSERT INTO sync_data VALUES('a', 'b', 1, 2, '', '', 'efdef', 100 , 1, 0, 0);";
39     const int SQL_STATE_ERR = -1;
40 
CopyCacheDb()41     void CopyCacheDb()
42     {
43         EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName, g_cacheDir), E_OK);
44         EXPECT_EQ(DBCommon::CopyFile(g_testDir + g_databaseName + "-wal", g_cacheDir + "-wal"), E_OK);
45     }
46 
GetStorageEngine(SQLiteSingleVerStorageEngine * & storageEngine)47     void GetStorageEngine(SQLiteSingleVerStorageEngine *&storageEngine)
48     {
49         int errCode;
50         storageEngine =
51             static_cast<SQLiteSingleVerStorageEngine *>(StorageEngineManager::GetStorageEngine(g_property, errCode));
52         EXPECT_EQ(errCode, E_OK);
53     }
54 }
55 
56 class DistributedDBStorageSQLiteSingleVerStorageEngineTest : public testing::Test {
57 public:
58     static void SetUpTestCase(void);
59     static void TearDownTestCase(void);
60     void SetUp();
61     void TearDown();
62 };
63 
SetUpTestCase(void)64 void DistributedDBStorageSQLiteSingleVerStorageEngineTest::SetUpTestCase(void)
65 {
66     DistributedDBToolsUnitTest::TestDirInit(g_testDir);
67     LOGI("DistributedDBStorageSQLiteSingleVerStorageEngineTest dir is %s", g_testDir.c_str());
68     std::string oriIdentifier = APP_ID + "-" + USER_ID + "-" + "TestGeneralNBStorageEngine";
69     std::string identifier = DBCommon::TransferHashString(oriIdentifier);
70     g_identifier = DBCommon::TransferStringToHex(identifier);
71 
72     g_databaseName = "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR + "/" + DBConstant::MAINDB_DIR + "/" +
73         DBConstant::SINGLE_VER_DATA_STORE + DBConstant::DB_EXTENSION;
74     g_property.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
75     g_property.SetStringProp(KvDBProperties::STORE_ID, "TestGeneralNBStorageEngine");
76     g_property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, g_identifier);
77     g_property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
78     g_cacheDir = g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR +
79         "/" + DBConstant::CACHEDB_DIR + "/" + DBConstant::SINGLE_VER_CACHE_STORE + DBConstant::DB_EXTENSION;
80 }
81 
TearDownTestCase(void)82 void DistributedDBStorageSQLiteSingleVerStorageEngineTest::TearDownTestCase(void)
83 {
84     DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR);
85 }
86 
SetUp(void)87 void DistributedDBStorageSQLiteSingleVerStorageEngineTest::SetUp(void)
88 {
89     DistributedDBToolsUnitTest::PrintTestCaseInfo();
90     DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/" + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR);
91     g_store = new (std::nothrow) SQLiteSingleVerNaturalStore;
92     ASSERT_NE(g_store, nullptr);
93     ASSERT_EQ(g_store->Open(g_property), E_OK);
94 
95     int erroCode = E_OK;
96     g_connection = static_cast<SQLiteSingleVerNaturalStoreConnection *>(g_store->GetDBConnection(erroCode));
97     ASSERT_NE(g_connection, nullptr);
98     g_store->DecObjRef(g_store);
99     EXPECT_EQ(erroCode, E_OK);
100 }
101 
TearDown(void)102 void DistributedDBStorageSQLiteSingleVerStorageEngineTest::TearDown(void)
103 {
104     if (g_connection != nullptr) {
105         g_connection->Close();
106         g_connection = nullptr;
107     }
108     g_store = nullptr;
109 }
110 
111 /**
112   * @tc.name: DataTest001
113   * @tc.desc: Change engine state, execute migrate
114   * @tc.type: FUNC
115   * @tc.require:
116   * @tc.author: bty
117   */
118 HWTEST_F(DistributedDBStorageSQLiteSingleVerStorageEngineTest, DataTest001, TestSize.Level1)
119 {
120     SQLiteSingleVerStorageEngine *storageEngine = nullptr;
121     GetStorageEngine(storageEngine);
122     ASSERT_NE(storageEngine, nullptr);
123     CopyCacheDb();
124 
125     storageEngine->SetEngineState(EngineState::ENGINE_BUSY);
126     EXPECT_EQ(storageEngine->ExecuteMigrate(), -E_BUSY);
127     storageEngine->SetEngineState(EngineState::ATTACHING);
128     EXPECT_EQ(storageEngine->ExecuteMigrate(), -E_NOT_SUPPORT);
129     storageEngine->SetEngineState(EngineState::MAINDB);
130     EXPECT_EQ(storageEngine->ExecuteMigrate(), SQL_STATE_ERR);
131     storageEngine->SetEngineState(EngineState::CACHEDB);
132     EXPECT_EQ(storageEngine->ExecuteMigrate(), SQL_STATE_ERR);
133     storageEngine->Release();
134     storageEngine = nullptr;
135 }
136 
137 /**
138   * @tc.name: DataTest002
139   * @tc.desc: Alter table, Change engine state, execute migrate
140   * @tc.type: FUNC
141   * @tc.require:
142   * @tc.author: bty
143   */
144 HWTEST_F(DistributedDBStorageSQLiteSingleVerStorageEngineTest, DataTest002, TestSize.Level1)
145 {
146     sqlite3 *db;
147     ASSERT_TRUE(sqlite3_open_v2((g_testDir + g_databaseName).c_str(),
148         &db, SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) == SQLITE_OK);
149     ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, ADD_SYNC) == E_OK);
150     ASSERT_TRUE(SQLiteUtils::ExecuteRawSQL(db, INSERT_SQL) == E_OK);
151     sqlite3_close_v2(db);
152     CopyCacheDb();
153     SQLiteSingleVerStorageEngine *storageEngine = nullptr;
154     GetStorageEngine(storageEngine);
155     ASSERT_NE(storageEngine, nullptr);
156     storageEngine->SetEngineState(EngineState::CACHEDB);
157     EXPECT_EQ(storageEngine->ExecuteMigrate(), -E_BUSY);
158     storageEngine->Release();
159     storageEngine = nullptr;
160 }