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 namespace OHOS::RdbDeleteTest {
28 struct RdbTestParam {
29 std::shared_ptr<RdbStore> store;
operator std::shared_ptr<RdbStore>OHOS::RdbDeleteTest::RdbTestParam30 operator std::shared_ptr<RdbStore>()
31 {
32 return store;
33 }
34 };
35 static RdbTestParam g_store;
36 static RdbTestParam g_memDb;
37
38 class RdbDeleteTest : public testing::TestWithParam<RdbTestParam *> {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44
45 std::shared_ptr<RdbStore> store_;
46 static const std::string DATABASE_NAME;
47 };
48
49 const std::string RdbDeleteTest::DATABASE_NAME = RDB_TEST_PATH + "delete_test.db";
50
51 class DeleteTestOpenCallback : public RdbOpenCallback {
52 public:
53 int OnCreate(RdbStore &store) override;
54 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
55 };
56 constexpr const char *CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test"
57 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
58 "name TEXT NOT NULL, age INTEGER, salary "
59 "REAL, blobType BLOB)";
OnCreate(RdbStore & store)60 int DeleteTestOpenCallback::OnCreate(RdbStore &store)
61 {
62 return store.ExecuteSql(CREATE_TABLE_TEST);
63 }
64
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)65 int DeleteTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
66 {
67 return E_OK;
68 }
69
SetUpTestCase(void)70 void RdbDeleteTest::SetUpTestCase(void)
71 {
72 int errCode = E_OK;
73 RdbHelper::DeleteRdbStore(DATABASE_NAME);
74 RdbStoreConfig config(RdbDeleteTest::DATABASE_NAME);
75 DeleteTestOpenCallback helper;
76 g_store.store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
77 ASSERT_NE(g_store.store, nullptr);
78
79 config.SetStorageMode(StorageMode::MODE_MEMORY);
80 g_memDb.store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
81 ASSERT_NE(g_memDb.store, nullptr);
82 }
83
TearDownTestCase(void)84 void RdbDeleteTest::TearDownTestCase(void)
85 {
86 RdbStoreConfig config(RdbDeleteTest::DATABASE_NAME);
87 RdbHelper::DeleteRdbStore(config);
88 config.SetStorageMode(StorageMode::MODE_MEMORY);
89 RdbHelper::DeleteRdbStore(config);
90 }
91
SetUp(void)92 void RdbDeleteTest::SetUp(void)
93 {
94 store_ = *GetParam();
95 store_->ExecuteSql("DELETE FROM test");
96 }
97
TearDown(void)98 void RdbDeleteTest::TearDown(void)
99 {
100 }
101
102 /**
103 * @tc.name: RdbStore_Delete_001
104 * @tc.desc: test RdbStore update, select id and update one row
105 * @tc.type: FUNC
106 */
107 HWTEST_P(RdbDeleteTest, RdbStore_Delete_001, TestSize.Level1)
108 {
109 std::shared_ptr<RdbStore> store = *GetParam();
110
111 int64_t id;
112 int deletedRows;
113
114 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
115 EXPECT_EQ(ret, E_OK);
116 EXPECT_EQ(1, id);
117
118 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
119 EXPECT_EQ(ret, E_OK);
120 EXPECT_EQ(2, id);
121
122 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[2]));
123 EXPECT_EQ(ret, E_OK);
124 EXPECT_EQ(3, id);
125
126 ret = store->Delete(deletedRows, "test", "id = 1");
127 EXPECT_EQ(ret, E_OK);
128 EXPECT_EQ(1, deletedRows);
129
130 std::shared_ptr<ResultSet> resultSet =
131 store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "1" });
132 EXPECT_NE(resultSet, nullptr);
133 ret = resultSet->GoToNextRow();
134 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
135 ret = resultSet->Close();
136 EXPECT_EQ(ret, E_OK);
137
138 resultSet = store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "2" });
139 EXPECT_NE(resultSet, nullptr);
140 ret = resultSet->GoToFirstRow();
141 EXPECT_EQ(ret, E_OK);
142 ret = resultSet->GoToNextRow();
143 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
144 ret = resultSet->Close();
145 EXPECT_EQ(ret, E_OK);
146
147 resultSet = store->QuerySql("SELECT * FROM test WHERE id = 3", std::vector<std::string>());
148 EXPECT_NE(resultSet, nullptr);
149 ret = resultSet->GoToFirstRow();
150 EXPECT_EQ(ret, E_OK);
151 ret = resultSet->GoToNextRow();
152 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
153 ret = resultSet->Close();
154 EXPECT_EQ(ret, E_OK);
155 }
156
157 /**
158 * @tc.name: RdbStore_Delete_002
159 * @tc.desc: test RdbStore update, select id and update one row
160 * @tc.type: FUNC
161 */
162 HWTEST_P(RdbDeleteTest, RdbStore_Delete_002, TestSize.Level1)
163 {
164 std::shared_ptr<RdbStore> store = *GetParam();
165
166 int64_t id;
167 ValuesBucket values;
168 int deletedRows;
169
170 values.PutInt("id", 1);
171 values.PutString("name", std::string("zhangsan"));
172 values.PutInt("age", 18);
173 values.PutDouble("salary", 100.5);
174 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
175 int ret = store->Insert(id, "test", values);
176 EXPECT_EQ(ret, E_OK);
177 EXPECT_EQ(1, id);
178
179 values.Clear();
180 values.PutInt("id", 2);
181 values.PutString("name", std::string("lisi"));
182 values.PutInt("age", 19);
183 values.PutDouble("salary", 200.5);
184 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
185 ret = store->Insert(id, "test", values);
186 EXPECT_EQ(ret, E_OK);
187 EXPECT_EQ(2, id);
188
189 values.Clear();
190 values.PutInt("id", 3);
191 values.PutString("name", std::string("wangyjing"));
192 values.PutInt("age", 20);
193 values.PutDouble("salary", 300.5);
194 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
195 ret = store->Insert(id, "test", values);
196 EXPECT_EQ(ret, E_OK);
197 EXPECT_EQ(3, id);
198
199 ret = store->Delete(deletedRows, "test");
200 EXPECT_EQ(ret, E_OK);
201 EXPECT_EQ(3, deletedRows);
202
203 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
204 EXPECT_NE(resultSet, nullptr);
205 ret = resultSet->GoToNextRow();
206 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
207 ret = resultSet->Close();
208 EXPECT_EQ(ret, E_OK);
209 }
210
211 /**
212 * @tc.name: RdbStore_Delete_003
213 * @tc.desc: test RdbStore update, select id and update one row
214 * @tc.type: FUNC
215 */
216 HWTEST_P(RdbDeleteTest, RdbStore_Delete_003, TestSize.Level1)
217 {
218 std::shared_ptr<RdbStore> store = *GetParam();
219
220 int64_t id;
221 ValuesBucket values;
222 int deletedRows;
223
224 values.PutInt("id", 1);
225 values.PutString("name", std::string("zhangsan"));
226 values.PutInt("age", 18);
227 values.PutDouble("salary", 100.5);
228 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
229 int ret = store->Insert(id, "test", values);
230 EXPECT_EQ(ret, E_OK);
231 EXPECT_EQ(1, id);
232
233 ret = store->Delete(deletedRows, "", "id = ?", std::vector<std::string>{ "1" });
234 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
235
236 ret = store->Delete(deletedRows, "wrongTable", "id = ?", std::vector<std::string>{ "1" });
237 EXPECT_EQ(ret, E_SQLITE_ERROR);
238
239 ret = store->Delete(deletedRows, "test", "wrong sql id = ?", std::vector<std::string>{ "1" });
240 EXPECT_EQ(ret, E_SQLITE_ERROR);
241
242 ret = store->Delete(deletedRows, "test", "id = 1", std::vector<std::string>());
243 EXPECT_EQ(ret, E_OK);
244 EXPECT_EQ(deletedRows, 1);
245 }
246
247 INSTANTIATE_TEST_SUITE_P(DeleteTest, RdbDeleteTest, testing::Values(&g_store, &g_memDb));
248 } // namespace OHOS::RdbDeleteTest
249