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 "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27
28 class RdbExecuteTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34
35 static const std::string DATABASE_NAME;
36 static std::shared_ptr<RdbStore> store;
37 };
38
39 const std::string RdbExecuteTest::DATABASE_NAME = RDB_TEST_PATH + "execute_test.db";
40 std::shared_ptr<RdbStore> RdbExecuteTest::store = nullptr;
41
42 class ExecuteTestOpenCallback : public RdbOpenCallback {
43 public:
44 int OnCreate(RdbStore &store) override;
45 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
46 static const std::string CREATE_TABLE_TEST;
47 };
48
49 const std::string ExecuteTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
50 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
51 "name TEXT NOT NULL, age INTEGER, salary "
52 "REAL, blobType BLOB)");
53
OnCreate(RdbStore & store)54 int ExecuteTestOpenCallback::OnCreate(RdbStore &store)
55 {
56 return store.ExecuteSql(CREATE_TABLE_TEST);
57 }
58
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)59 int ExecuteTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
60 {
61 return E_OK;
62 }
63
SetUpTestCase(void)64 void RdbExecuteTest::SetUpTestCase(void)
65 {
66 int errCode = E_OK;
67 RdbHelper::DeleteRdbStore(RdbExecuteTest::DATABASE_NAME);
68 RdbStoreConfig config(RdbExecuteTest::DATABASE_NAME);
69 ExecuteTestOpenCallback helper;
70 RdbExecuteTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
71 EXPECT_NE(RdbExecuteTest::store, nullptr);
72 EXPECT_EQ(errCode, E_OK);
73 }
74
TearDownTestCase(void)75 void RdbExecuteTest::TearDownTestCase(void)
76 {
77 store = nullptr;
78 RdbHelper::DeleteRdbStore(RdbExecuteTest::DATABASE_NAME);
79 }
80
SetUp(void)81 void RdbExecuteTest::SetUp(void)
82 {
83 store->ExecuteSql("DELETE FROM test");
84 }
85
TearDown(void)86 void RdbExecuteTest::TearDown(void)
87 {
88 }
89
90 /**
91 * @tc.name: RdbStore_Execute_001
92 * @tc.desc: test RdbStore Execute
93 * @tc.type: FUNC
94 */
95 HWTEST_F(RdbExecuteTest, RdbStore_Execute_001, TestSize.Level1)
96 {
97 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
98
99 int64_t id;
100 ValuesBucket values;
101
102 values.PutInt("id", 1);
103 values.PutString("name", std::string("zhangsan"));
104 values.PutInt("age", 18);
105 values.PutDouble("salary", 100.5);
106 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
107 int ret = store->Insert(id, "test", values);
108 EXPECT_EQ(ret, E_OK);
109 EXPECT_EQ(1, id);
110
111 values.Clear();
112 values.PutInt("id", 2);
113 values.PutString("name", std::string("lisi"));
114 values.PutInt("age", 19);
115 values.PutDouble("salary", 200.5);
116 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
117 ret = store->Insert(id, "test", values);
118 EXPECT_EQ(ret, E_OK);
119 EXPECT_EQ(2, id);
120
121 values.Clear();
122 values.PutInt("id", 3);
123 values.PutString("name", std::string("wangyjing"));
124 values.PutInt("age", 20);
125 values.PutDouble("salary", 300.5);
126 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
127 ret = store->Insert(id, "test", values);
128 EXPECT_EQ(ret, E_OK);
129 EXPECT_EQ(3, id);
130
131 int64_t count;
132 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(count, 3);
135
136 ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?",
137 std::vector<ValueObject>{ ValueObject(std::string("18")), ValueObject(std ::string("20")) });
138 EXPECT_EQ(ret, E_OK);
139
140 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test where age = 19");
141 EXPECT_EQ(ret, E_OK);
142 EXPECT_EQ(count, 1);
143
144 ret = store->ExecuteSql("DELETE FROM test WHERE age = 19");
145 EXPECT_EQ(ret, E_OK);
146
147 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
148 EXPECT_EQ(ret, E_OK);
149 EXPECT_EQ(count, 0);
150 }
151
152 /**
153 * @tc.name: RdbStore_Execute_002
154 * @tc.desc: test RdbStore Execute
155 * @tc.type: FUNC
156 */
157 HWTEST_F(RdbExecuteTest, RdbStore_Execute_002, TestSize.Level1)
158 {
159 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
160
161 int64_t id;
162 ValuesBucket values;
163
164 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
165 EXPECT_EQ(ret, E_OK);
166 EXPECT_EQ(1, id);
167
168 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
169 EXPECT_EQ(ret, E_OK);
170 EXPECT_EQ(2, id);
171
172 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[2]));
173 EXPECT_EQ(ret, E_OK);
174 EXPECT_EQ(3, id);
175
176 int64_t count;
177 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector<ValueObject>());
178 EXPECT_EQ(ret, E_OK);
179 EXPECT_EQ(count, 3);
180
181 ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?",
182 std::vector<ValueObject>{ ValueObject(std::string("18")), ValueObject(std ::string("20")) });
183 EXPECT_EQ(ret, E_OK);
184
185 ret = store->ExecuteAndGetLong(
186 count, "SELECT COUNT(*) FROM test where age = ?", std::vector<ValueObject>{ ValueObject(std::string("19")) });
187 EXPECT_EQ(ret, E_OK);
188 EXPECT_EQ(count, 1);
189
190 ret = store->ExecuteSql("DELETE FROM test WHERE age = 19");
191 EXPECT_EQ(ret, E_OK);
192
193 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector<ValueObject>());
194 EXPECT_EQ(ret, E_OK);
195 EXPECT_EQ(count, 0);
196
197 ret = store->ExecuteSql("DROP TABLE IF EXISTS test");
198 EXPECT_EQ(ret, E_OK);
199
200 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
201 EXPECT_EQ(ret, -1);
202 }
203
204 /**
205 * @tc.name: RdbStore_Execute_003
206 * @tc.desc: test RdbStore Execute
207 * @tc.type: FUNC
208 */
209 HWTEST_F(RdbExecuteTest, RdbStore_Execute_003, TestSize.Level1)
210 {
211 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
212
213 int64_t pageSize;
214 int ret = store->ExecuteAndGetLong(pageSize, "PRAGMA page_size");
215 EXPECT_EQ(ret, E_OK);
216 EXPECT_EQ(pageSize, 4096);
217
218 int64_t journalSize;
219 ret = store->ExecuteAndGetLong(journalSize, "PRAGMA journal_size_limit");
220 EXPECT_EQ(ret, E_OK);
221 EXPECT_EQ(journalSize, 1048576);
222
223 std::string journalMode;
224 ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode");
225 EXPECT_EQ(ret, E_OK);
226 EXPECT_EQ(journalMode, "wal");
227 }
228
229 /**
230 * @tc.name: RdbStore_Execute_004
231 * @tc.desc: Abnormal testCase for ExecuteAndGetString, if sqlstatementtype is special
232 * @tc.type: FUNC
233 */
234 HWTEST_F(RdbExecuteTest, RdbStore_Execute_004, TestSize.Level4)
235 {
236 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
237
238 std::string outValue;
239 int ret = store->ExecuteAndGetString(outValue, "BEGIN;");
240 EXPECT_NE(E_OK, ret);
241 }
242
243 /**
244 * @tc.name: RdbStore_Execute_005
245 * @tc.desc: Abnormal testCase for ExecuteForLastInsertedRowId, if sql is invalid
246 * @tc.type: FUNC
247 * @tc.type: FUNC
248 */
249 HWTEST_F(RdbExecuteTest, RdbStore_Execute_005, TestSize.Level4)
250 {
251 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
252 int64_t outValue;
253 int ret = store->ExecuteForLastInsertedRowId(outValue, "", {});
254 EXPECT_NE(E_OK, ret);
255 }
256
257 /**
258 * @tc.name: RdbStore_Execute_006
259 * @tc.desc: Abnormal testCase for ExecuteForChangedRowCount, if sql is invalid
260 * @tc.type: FUNC
261 */
262 HWTEST_F(RdbExecuteTest, RdbStore_Execute_006, TestSize.Level4)
263 {
264 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
265 int64_t outValue;
266 int ret = store->ExecuteForChangedRowCount(outValue, "", {});
267 EXPECT_NE(E_OK, ret);
268 }