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