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