1 /*
2 * Copyright (c) 2022 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 #include "rdb_store_manager.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28
29 class RdbGetStoreTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 void QueryCheck1(std::shared_ptr<RdbStore> &store) const;
36 void QueryCheck2(std::shared_ptr<RdbStore> &store) const;
37
38 static const std::string MAIN_DATABASE_NAME;
39 static const std::string MAIN_DATABASE_NAME_RELEASE;
40 static const std::string MAIN_DATABASE_NAME_STATUS;
41 static const std::string MAIN_DATABASE_NAME_MINUS;
42 std::shared_ptr<RdbStore> CreateGetRDB(int version);
43 void CreateRDB(int version);
44 };
45
46 const std::string RdbGetStoreTest::MAIN_DATABASE_NAME = RDB_TEST_PATH + "getrdb.db";
47 const std::string RdbGetStoreTest::MAIN_DATABASE_NAME_RELEASE = RDB_TEST_PATH + "releaserdb.db";
48 const std::string RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS = RDB_TEST_PATH + "status.db";
49 const std::string RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS = RDB_TEST_PATH + "minus.db";
50
51 class GetOpenCallback : public RdbOpenCallback {
52 public:
53 int OnCreate(RdbStore &store) override;
54 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
55 static const std::string CREATE_TABLE_TEST;
56 };
57
58 std::string const GetOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test1(id INTEGER PRIMARY KEY "
59 "AUTOINCREMENT, name TEXT NOT NULL, age INTEGER)";
60
OnCreate(RdbStore & store)61 int GetOpenCallback::OnCreate(RdbStore &store)
62 {
63 return store.ExecuteSql(CREATE_TABLE_TEST);
64 }
65
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)66 int GetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
67 {
68 return E_OK;
69 }
70
SetUpTestCase(void)71 void RdbGetStoreTest::SetUpTestCase(void)
72 {
73 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
74 }
75
TearDownTestCase(void)76 void RdbGetStoreTest::TearDownTestCase(void)
77 {
78 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
79 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME_RELEASE);
80 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME_STATUS);
81 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME_MINUS);
82 }
83
SetUp(void)84 void RdbGetStoreTest::SetUp(void)
85 {
86 }
87
TearDown(void)88 void RdbGetStoreTest::TearDown(void)
89 {
90 RdbHelper::ClearCache();
91 }
92
CreateRDB(int version)93 void RdbGetStoreTest::CreateRDB(int version)
94 {
95 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_RELEASE);
96 GetOpenCallback helper;
97 int errCode = E_OK;
98 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, version, helper, errCode);
99 EXPECT_NE(store, nullptr);
100 int currentVersion;
101 int ret = store->GetVersion(currentVersion);
102 EXPECT_EQ(ret, E_OK);
103 EXPECT_EQ(currentVersion, version);
104
105 ret = store->ExecuteSql("CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY AUTOINCREMENT, "
106 "name TEXT NOT NULL, age INTEGER)");
107 EXPECT_EQ(ret, E_OK);
108 ret = store->ExecuteSql("delete from test1");
109 EXPECT_EQ(ret, E_OK);
110 ret = store->ExecuteSql("delete from test2");
111 EXPECT_EQ(ret, E_OK);
112 QueryCheck1(store);
113 QueryCheck2(store);
114 }
115
QueryCheck1(std::shared_ptr<RdbStore> & store) const116 void RdbGetStoreTest::QueryCheck1(std::shared_ptr<RdbStore> &store) const
117 {
118 int ret;
119 int64_t id;
120 ValuesBucket values;
121 values.Clear();
122 values.PutInt("id", 3);
123 values.PutString("name", std::string("lisi"));
124 values.PutInt("age", 18);
125 ret = store->Insert(id, "test1", values);
126 EXPECT_EQ(ret, E_OK);
127 EXPECT_EQ(3, id);
128
129 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1");
130 EXPECT_NE(resultSet, nullptr);
131 ret = resultSet->GoToNextRow();
132 EXPECT_EQ(ret, E_OK);
133 int columnIndex;
134 std::string strVal;
135 ret = resultSet->GetColumnIndex("name", columnIndex);
136 EXPECT_EQ(ret, E_OK);
137 ret = resultSet->GetString(columnIndex, strVal);
138 EXPECT_EQ(ret, E_OK);
139 EXPECT_EQ(strVal, "lisi");
140 }
141
QueryCheck2(std::shared_ptr<RdbStore> & store) const142 void RdbGetStoreTest::QueryCheck2(std::shared_ptr<RdbStore> &store) const
143 {
144 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1");
145 EXPECT_NE(resultSet, nullptr);
146 int ret = resultSet->GoToNextRow();
147 EXPECT_EQ(ret, E_OK);
148 int columnIndex;
149 int intVal;
150 int64_t id;
151 std::string strVal;
152
153 ret = resultSet->GetColumnIndex("age", columnIndex);
154 EXPECT_EQ(ret, E_OK);
155 ret = resultSet->GetInt(columnIndex, intVal);
156 EXPECT_EQ(ret, E_OK);
157 EXPECT_EQ(intVal, 18);
158
159 ValuesBucket values;
160 values.Clear();
161 values.PutInt("id", 1);
162 values.PutString("name", std::string("lisi"));
163 values.PutInt("age", 18);
164 ret = store->Insert(id, "test2", values);
165 EXPECT_EQ(ret, E_OK);
166 EXPECT_EQ(1, id);
167
168 resultSet = store->QuerySql("SELECT * FROM test2");
169 EXPECT_NE(resultSet, nullptr);
170 ret = resultSet->GoToNextRow();
171 EXPECT_EQ(ret, E_OK);
172 ret = resultSet->GetColumnIndex("id", columnIndex);
173 EXPECT_EQ(ret, E_OK);
174 ret = resultSet->GetInt(columnIndex, intVal);
175 EXPECT_EQ(ret, E_OK);
176 EXPECT_EQ(intVal, 1);
177 ret = resultSet->GetColumnIndex("name", columnIndex);
178 EXPECT_EQ(ret, E_OK);
179 ret = resultSet->GetString(columnIndex, strVal);
180 EXPECT_EQ(ret, E_OK);
181 EXPECT_EQ(strVal, "lisi");
182 }
183
184 /**
185 * @tc.name: RdbStore_GetStore_001
186 * @tc.desc: createRDB
187 * @tc.type: FUNC
188 * @tc.require: issue
189 * @tc.author: lcl
190 */
191 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_001, TestSize.Level1)
192 {
193 CreateRDB(1);
194 sleep(1);
195 }
196
197 /**
198 * @tc.name: RdbStore_GetStore_001
199 * @tc.desc: createRDB
200 * @tc.type: FUNC
201 * @tc.require: issue
202 * @tc.author: lcl
203 */
204 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00101, TestSize.Level1)
205 {
206 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS);
207 GetOpenCallback helper;
208 int errCode = E_OK;
209 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
210 EXPECT_NE(store, nullptr);
211 int currentVersion;
212 int ret = store->GetVersion(currentVersion);
213 EXPECT_EQ(ret, E_OK);
214 EXPECT_EQ(currentVersion, 1);
215 sleep(1);
216 }
217
218 /**
219 * @tc.name: RdbStore_GetStore_001
220 * @tc.desc: createRDB
221 * @tc.type: FUNC
222 * @tc.require: issue
223 * @tc.author: lcl
224 */
225 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00102, TestSize.Level1)
226 {
227 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
228 GetOpenCallback helper;
229 int errCode = E_OK;
230 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, -1, helper, errCode);
231 EXPECT_NE(store, nullptr);
232 int currentVersion;
233 int ret = store->GetVersion(currentVersion);
234 EXPECT_EQ(ret, E_OK);
235 EXPECT_EQ(currentVersion, 0);
236 sleep(1);
237 }
238
CreateGetRDB(int version)239 std::shared_ptr<RdbStore> RdbGetStoreTest::CreateGetRDB(int version)
240 {
241 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
242 GetOpenCallback helper;
243 int errCode = E_OK;
244 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, version, helper, errCode);
245 EXPECT_NE(store, nullptr);
246 return store;
247 }
248
249 /**
250 * @tc.name: RdbStore_GetStore_002
251 * @tc.desc: createRDB
252 * @tc.type: FUNC
253 * @tc.require: issue
254 * @tc.author: lcl
255 */
256 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_002, TestSize.Level1)
257 {
258 std::shared_ptr<RdbStore> store1 = CreateGetRDB(1);
259
260 std::shared_ptr<RdbStore> store = CreateGetRDB(2);
261
262 int currentVersion;
263 int64_t id;
264 int changedRows;
265 ValuesBucket values;
266 int rowCount;
267
268 int ret = store->GetVersion(currentVersion);
269 EXPECT_EQ(ret, E_OK);
270 EXPECT_EQ(currentVersion, 1);
271
272 ret = store1->GetVersion(currentVersion);
273 EXPECT_EQ(ret, E_OK);
274 EXPECT_EQ(currentVersion, 1);
275
276 ret = store->ExecuteSql("delete from test1");
277 EXPECT_EQ(ret, E_OK);
278
279 values.Clear();
280 values.PutInt("id", 3);
281 values.PutString("name", std::string("lisi"));
282 values.PutInt("age", 18);
283 ret = store->Insert(id, "test1", values);
284 EXPECT_EQ(ret, E_OK);
285 EXPECT_EQ(3, id);
286
287 values.Clear();
288 values.PutInt("id", 4);
289 values.PutString("name", std::string("zhangsan"));
290 values.PutInt("age", 20);
291 ret = store->Insert(id, "test1", values);
292 EXPECT_EQ(ret, E_OK);
293 EXPECT_EQ(4, id);
294
295 values.Clear();
296 values.PutInt("id", 5);
297 values.PutString("name", std::string("zhangsan"));
298 values.PutInt("age", 19);
299 ret = store->Insert(id, "test1", values);
300 EXPECT_EQ(ret, E_OK);
301 EXPECT_EQ(5, id);
302
303 std::shared_ptr<ResultSet> resultSet = store1->QuerySql("select * from test1");
304 ret = resultSet->GetRowCount(rowCount);
305 EXPECT_EQ(ret, E_OK);
306 EXPECT_EQ(3, rowCount);
307
308 values.Clear();
309 values.PutInt("age", 21);
310 ret = store->Update(changedRows, "test1", values, "age = ?", std::vector<std::string>{ "18" });
311 EXPECT_EQ(ret, E_OK);
312 EXPECT_EQ(1, changedRows);
313
314 ret = store1->Delete(changedRows, "test1", "age = ?", std::vector<std::string>{ "21" });
315 EXPECT_EQ(ret, E_OK);
316 EXPECT_EQ(1, changedRows);
317 }
318
319
320 /**
321 * @tc.name: RdbStore_GetStore_003
322 * @tc.desc: createRDB
323 * @tc.type: FUNC
324 * @tc.require: issue
325 * @tc.author: lcl
326 */
327 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_003, TestSize.Level1)
328 {
329 std::shared_ptr<RdbStore> store2 = CreateGetRDB(2);
330 std::shared_ptr<RdbStore> store3 = CreateGetRDB(3);
331
332 int currentVersion;
333 int ret;
334 int64_t id;
335 int changedRows;
336 ValuesBucket values;
337
338 ret = store2->GetVersion(currentVersion);
339 EXPECT_EQ(ret, E_OK);
340 EXPECT_EQ(currentVersion, 2);
341
342 ret = store3->GetVersion(currentVersion);
343 EXPECT_EQ(ret, E_OK);
344 EXPECT_EQ(currentVersion, 2);
345
346 ret = store2->ExecuteSql("delete from test1");
347 EXPECT_EQ(ret, E_OK);
348
349 values.PutInt("id", 3);
350 values.PutString("name", std::string("lisi"));
351 values.PutInt("age", 18);
352 ret = store2->Insert(id, "test1", values);
353 EXPECT_EQ(ret, E_OK);
354 EXPECT_EQ(3, id);
355
356 values.Clear();
357 values.PutInt("age", 20);
358 ret = store2->Update(changedRows, "test1", values, "age = ?", std::vector<std::string>{ "18" });
359 EXPECT_EQ(ret, E_OK);
360 EXPECT_EQ(1, changedRows);
361
362 ret = store3->Delete(changedRows, "test1", "age = ?", std::vector<std::string>{ "20" });
363 EXPECT_EQ(ret, E_OK);
364 EXPECT_EQ(1, changedRows);
365 }
366
367
368 /**
369 * @tc.name: RdbStore_GetStore_004
370 * @tc.desc: createRDB
371 * @tc.type: FUNC
372 * @tc.require: issue
373 * @tc.author: lcl
374 */
375 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_004, TestSize.Level1)
376 {
377 sleep(1);
378 CreateRDB(2);
379 }
380
381 /**
382 * @tc.name: RdbStore_GetStore_001
383 * @tc.desc: createRDB
384 * @tc.type: FUNC
385 * @tc.require: issue
386 * @tc.author: lcl
387 */
388 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00103, TestSize.Level1)
389 {
390 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS);
391 GetOpenCallback helper;
392 int errCode = E_OK;
393 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 2, helper, errCode);
394 EXPECT_NE(store, nullptr);
395 int currentVersion;
396 int ret = store->GetVersion(currentVersion);
397 EXPECT_EQ(ret, E_OK);
398 EXPECT_EQ(currentVersion, 2);
399 sleep(1);
400 }
401
402 /**
403 * @tc.name: RdbStore_GetStore_001
404 * @tc.desc: createRDB
405 * @tc.type: FUNC
406 * @tc.require: issue
407 * @tc.author: lcl
408 */
409 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00104, TestSize.Level1)
410 {
411 RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
412 GetOpenCallback helper;
413 int errCode = E_OK;
414 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, -1, helper, errCode);
415 EXPECT_NE(store, nullptr);
416 int currentVersion;
417 int ret = store->GetVersion(currentVersion);
418 EXPECT_EQ(ret, E_OK);
419 EXPECT_EQ(currentVersion, 0);
420 sleep(1);
421 }
422
423 /**
424 * @tc.name: RdbStore_GetStore_005
425 * @tc.desc: createRDB
426 * @tc.type: FUNC
427 * @tc.require: issue
428 * @tc.author: lcl
429 */
430 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_005, TestSize.Level1)
431 {
432 std::shared_ptr<RdbStore> store2 = CreateGetRDB(2);
433 std::shared_ptr<RdbStore> store3 = CreateGetRDB(3);
434
435 int currentVersion;
436 int ret;
437 int64_t id;
438 int changedRows;
439 ValuesBucket values;
440
441 ret = store2->GetVersion(currentVersion);
442 EXPECT_EQ(ret, E_OK);
443 EXPECT_EQ(currentVersion, 2);
444
445 ret = store3->GetVersion(currentVersion);
446 EXPECT_EQ(ret, E_OK);
447 EXPECT_EQ(currentVersion, 2);
448
449 ret = store2->ExecuteSql("delete from test1");
450 EXPECT_EQ(ret, E_OK);
451
452 values.PutInt("id", 3);
453 values.PutString("name", std::string("lisi"));
454 values.PutInt("age", 18);
455 ret = store2->Insert(id, "test1", values);
456 EXPECT_EQ(ret, E_OK);
457 EXPECT_EQ(3, id);
458
459 values.Clear();
460 values.PutInt("age", 20);
461 ret = store2->Update(changedRows, "test1", values, "age = ?", std::vector<std::string>{ "18" });
462 EXPECT_EQ(ret, E_OK);
463 EXPECT_EQ(1, changedRows);
464
465 ret = store3->Delete(changedRows, "test1", "age = ?", std::vector<std::string>{ "20" });
466 EXPECT_EQ(ret, E_OK);
467 EXPECT_EQ(1, changedRows);
468 }
469
470