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_002
199  * @tc.desc: createRDB
200  * @tc.type: FUNC
201  * @tc.require: issue
202  * @tc.author: lcl
203  */
204 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_002, 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_003
220  * @tc.desc: createRDB
221  * @tc.type: FUNC
222  * @tc.require: issue
223  * @tc.author: lcl
224  */
225 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_003, 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_004
251  * @tc.desc: createRDB
252  * @tc.type: FUNC
253  * @tc.require: issue
254  * @tc.author: lcl
255  */
256 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_004, 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  * @tc.name: RdbStore_GetStore_005
321  * @tc.desc: createRDB
322  * @tc.type: FUNC
323  * @tc.require: issue
324  * @tc.author: lcl
325  */
326 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_005, TestSize.Level1)
327 {
328     sleep(1);
329     CreateRDB(2);
330 }
331 
332 /**
333  * @tc.name: RdbStore_GetStore_006
334  * @tc.desc: createRDB
335  * @tc.type: FUNC
336  * @tc.require: issue
337  * @tc.author: lcl
338  */
339 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_006, TestSize.Level1)
340 {
341     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS);
342     GetOpenCallback helper;
343     int errCode = E_OK;
344     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 2, helper, errCode);
345     EXPECT_NE(store, nullptr);
346     int currentVersion;
347     int ret = store->GetVersion(currentVersion);
348     EXPECT_EQ(ret, E_OK);
349     EXPECT_EQ(currentVersion, 2);
350     sleep(1);
351 }
352 
353 /**
354  * @tc.name: RdbStore_GetStore_007
355  * @tc.desc: createRDB
356  * @tc.type: FUNC
357  * @tc.require: issue
358  * @tc.author: lcl
359  */
360 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_007, TestSize.Level1)
361 {
362     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
363     GetOpenCallback helper;
364     int errCode = E_OK;
365     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, -1, helper, errCode);
366     EXPECT_NE(store, nullptr);
367     int currentVersion;
368     int ret = store->GetVersion(currentVersion);
369     EXPECT_EQ(ret, E_OK);
370     EXPECT_EQ(currentVersion, 0);
371     sleep(1);
372 }
373 
374 /**
375  * @tc.name: RdbStore_GetStore_008
376  * @tc.desc: createRDB
377  * @tc.type: FUNC
378  * @tc.require: issue
379  * @tc.author: lcl
380  */
381 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_008, TestSize.Level1)
382 {
383     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
384     config.SetCustomDir("SetCustomDirTest/");
385     GetOpenCallback helper;
386     int errCode = E_OK;
387     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
388     EXPECT_NE(store, nullptr);
389 }
390 
391 /**
392  * @tc.name: RdbStore_GetStore_009
393  * @tc.desc: get database with quick_check
394  * @tc.type: FUNC
395  */
396 HWTEST_F(RdbGetStoreTest, GetDatabase_009, TestSize.Level0)
397 {
398     int errCode = E_OK;
399     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
400     config.SetIntegrityCheck(IntegrityCheck::QUICK);
401     GetOpenCallback helper;
402     auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
403     EXPECT_NE(store, nullptr);
404 }
405 
406 /**
407  * @tc.name: RdbStore_GetStore_010
408  * @tc.desc: get database with quick_check
409  * @tc.type: FUNC
410  */
411 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_010, TestSize.Level0)
412 {
413     int errCode = E_OK;
414     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
415     config.SetIntegrityCheck(IntegrityCheck::FULL);
416     GetOpenCallback helper;
417     auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
418     EXPECT_NE(store, nullptr);
419 }
420 
421 /**
422  * @tc.name: RdbStore_GetStore_011
423  * @tc.desc: use libs as relative path to get rdbStore
424  * @tc.type: FUNC
425  */
426 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_011, TestSize.Level0)
427 {
428     int errCode = E_OK;
429     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
430     std::vector<std::string> paths = { "./" };
431     config.SetPluginLibs(paths);
432     GetOpenCallback helper;
433     auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
434     EXPECT_EQ(errCode, E_SQLITE_ERROR);
435     EXPECT_EQ(store, nullptr);
436 }
437 
438 /**
439  * @tc.name: RdbStore_GetStore_012
440  * @tc.desc: use libs as empty path to get rdbStore
441  * @tc.type: FUNC
442  */
443 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_012, TestSize.Level0)
444 {
445     int errCode = E_OK;
446     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
447     std::vector<std::string> paths = { "", "" };
448     config.SetPluginLibs(paths);
449     GetOpenCallback helper;
450     auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
451     EXPECT_EQ(errCode, E_OK);
452     EXPECT_NE(store, nullptr);
453 }
454 
455 /**
456  * @tc.name: RdbStore_GetStore_013
457  * @tc.desc: use libs as invalid path to get rdbStore
458  * @tc.type: FUNC
459  */
460 HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_013, TestSize.Level0)
461 {
462     int errCode = E_OK;
463     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
464     std::vector<std::string> paths = { "", "/data/errPath/libErr.so" };
465     config.SetPluginLibs(paths);
466     GetOpenCallback helper;
467     auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
468     EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
469     EXPECT_EQ(store, nullptr);
470 }