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
18 #include <string>
19
20 #include "common.h"
21 #include "logger.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28
29 class RdbUpgradeTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 void InsertValues(std::shared_ptr<RdbStore> &store);
36
37 static const std::string DATABASE_NAME;
38 static std::shared_ptr<RdbStore> store;
39 };
40
41 const std::string RdbUpgradeTest::DATABASE_NAME = RDB_TEST_PATH + "upgrade_test.db";
42 std::shared_ptr<RdbStore> RdbUpgradeTest::store = nullptr;
43
44 class UpgradeTestOpenCallback : public RdbOpenCallback {
45 public:
46 int OnCreate(RdbStore &rdbStore) override;
47 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
48 static const std::string CREATE_TABLE_TEST;
49 };
50
51 std::string const UpgradeTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
52 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
53 "name TEXT NOT NULL, age INTEGER, salary "
54 "REAL, blobType BLOB)");
55
OnCreate(RdbStore & store)56 int UpgradeTestOpenCallback::OnCreate(RdbStore &store)
57 {
58 return store.ExecuteSql(CREATE_TABLE_TEST);
59 }
60
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)61 int UpgradeTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
62 {
63 return E_OK;
64 }
65
66 class UpgradeOpenCallback : public RdbOpenCallback {
67 public:
68 int OnCreate(RdbStore &rdbStore) override;
69 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
70 static const std::string UPGRADE_TABLE_TEST;
71 };
72
73 std::string const UpgradeOpenCallback::UPGRADE_TABLE_TEST = std::string("ALTER TABLE test ADD COLUMN address TEXT;");
74
OnCreate(RdbStore & store)75 int UpgradeOpenCallback::OnCreate(RdbStore &store)
76 {
77 return E_OK;
78 }
79
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)80 int UpgradeOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
81 {
82 return store.ExecuteSql(UPGRADE_TABLE_TEST);
83 }
84
SetUpTestCase(void)85 void RdbUpgradeTest::SetUpTestCase(void)
86 {
87 int errCode = E_OK;
88 RdbStoreConfig config(RdbUpgradeTest::DATABASE_NAME);
89 UpgradeTestOpenCallback helper;
90 RdbUpgradeTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
91 EXPECT_NE(RdbUpgradeTest::store, nullptr);
92 }
93
TearDownTestCase(void)94 void RdbUpgradeTest::TearDownTestCase(void)
95 {
96 RdbHelper::DeleteRdbStore(RdbUpgradeTest::DATABASE_NAME);
97 }
98
SetUp(void)99 void RdbUpgradeTest::SetUp(void)
100 {
101 store->ExecuteSql("DELETE FROM test");
102 }
103
TearDown(void)104 void RdbUpgradeTest::TearDown(void)
105 {
106 }
107
108 /**
109 * @tc.name: RdbStore_Upgrade_001
110 * @tc.desc: test RdbStore upgrade
111 * @tc.type: FUNC
112 * @tc.require: AR000CU2BO
113 * @tc.author: liumengyue
114 */
115 HWTEST_F(RdbUpgradeTest, RdbStore_Upgrade_001, TestSize.Level1)
116 {
117 std::shared_ptr<RdbStore> &store = RdbUpgradeTest::store;
118
119 RdbUpgradeTest::InsertValues(store);
120
121 std::unique_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
122 EXPECT_NE(resultSet, nullptr);
123 int ret = resultSet->GoToNextRow();
124 EXPECT_EQ(ret, E_OK);
125 ret = resultSet->GoToNextRow();
126 EXPECT_EQ(ret, E_OK);
127 ret = resultSet->GoToNextRow();
128 EXPECT_EQ(ret, E_OK);
129 ret = resultSet->GoToNextRow();
130 EXPECT_EQ(ret, E_ERROR);
131 ret = resultSet->Close();
132 EXPECT_EQ(ret, E_OK);
133 RdbHelper::ClearCache();
134
135 int errCode = E_OK;
136 RdbStoreConfig config(RdbUpgradeTest::DATABASE_NAME);
137 UpgradeOpenCallback callBack;
138 std::shared_ptr<RdbStore> upgradeStore = RdbHelper::GetRdbStore(config, 2, callBack, errCode);
139 EXPECT_NE(upgradeStore, nullptr);
140 std::unique_ptr<ResultSet> upgradeResultSet = upgradeStore->QuerySql("SELECT * FROM test");
141 EXPECT_NE(upgradeResultSet, nullptr);
142 int columnCount;
143 ret = upgradeResultSet->GetColumnCount(columnCount);
144 EXPECT_EQ(ret, E_OK);
145 EXPECT_EQ(columnCount, 6);
146 ret = upgradeResultSet->GoToNextRow();
147 int columnIndex;
148 ret = upgradeResultSet->GetColumnIndex("id", columnIndex);
149 EXPECT_EQ(ret, E_OK);
150 ret = upgradeResultSet->GetColumnIndex("name", columnIndex);
151 EXPECT_EQ(ret, E_OK);
152 ret = upgradeResultSet->GetColumnIndex("age", columnIndex);
153 EXPECT_EQ(ret, E_OK);
154 ret = upgradeResultSet->GetColumnIndex("salary", columnIndex);
155 EXPECT_EQ(ret, E_OK);
156 ret = upgradeResultSet->GetColumnIndex("blobType", columnIndex);
157 EXPECT_EQ(ret, E_OK);
158 ret = upgradeResultSet->GetColumnIndex("address", columnIndex);
159 EXPECT_EQ(ret, E_OK);
160 EXPECT_EQ(columnIndex, 5);
161 ret = upgradeResultSet->GoToNextRow();
162 EXPECT_EQ(ret, E_OK);
163 ret = upgradeResultSet->GoToNextRow();
164 EXPECT_EQ(ret, E_OK);
165 ret = upgradeResultSet->GoToNextRow();
166 EXPECT_EQ(ret, E_ERROR);
167 ret = upgradeResultSet->Close();
168 EXPECT_EQ(ret, E_OK);
169 }
170
InsertValues(std::shared_ptr<RdbStore> & store)171 void RdbUpgradeTest::InsertValues(std::shared_ptr<RdbStore> &store)
172 {
173 int64_t id;
174 ValuesBucket values;
175
176 values.PutInt("id", 1);
177 values.PutString("name", std::string("zhangsan"));
178 values.PutInt("age", 18);
179 values.PutDouble("salary", 100.5);
180 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
181 int ret = store->Insert(id, "test", values);
182 EXPECT_EQ(ret, E_OK);
183 EXPECT_EQ(1, id);
184
185 values.Clear();
186 values.PutInt("id", 2);
187 values.PutString("name", std::string("lisi"));
188 values.PutInt("age", 19);
189 values.PutDouble("salary", 200.5);
190 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
191 ret = store->Insert(id, "test", values);
192 EXPECT_EQ(ret, E_OK);
193 EXPECT_EQ(2, id);
194
195 values.Clear();
196 values.PutInt("id", 3);
197 values.PutString("name", std::string("wangyjing"));
198 values.PutInt("age", 20);
199 values.PutDouble("salary", 300.5);
200 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
201 ret = store->Insert(id, "test", values);
202 EXPECT_EQ(ret, E_OK);
203 EXPECT_EQ(3, id);
204 }
205