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 int deletedRows;
100
101 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
102 EXPECT_EQ(ret, E_OK);
103 EXPECT_EQ(1, id);
104
105 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1]));
106 EXPECT_EQ(ret, E_OK);
107 EXPECT_EQ(2, id);
108
109 ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[2]));
110 EXPECT_EQ(ret, E_OK);
111 EXPECT_EQ(3, id);
112
113 ret = store->Delete(deletedRows, "test", "id = 1");
114 EXPECT_EQ(ret, E_OK);
115 EXPECT_EQ(1, deletedRows);
116
117 std::shared_ptr<ResultSet> resultSet =
118 store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "1" });
119 EXPECT_NE(resultSet, nullptr);
120 ret = resultSet->GoToNextRow();
121 EXPECT_EQ(ret, E_ERROR);
122 ret = resultSet->Close();
123 EXPECT_EQ(ret, E_OK);
124
125 resultSet = store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector<std::string>{ "2" });
126 EXPECT_NE(resultSet, nullptr);
127 ret = resultSet->GoToFirstRow();
128 EXPECT_EQ(ret, E_OK);
129 ret = resultSet->GoToNextRow();
130 EXPECT_EQ(ret, E_ERROR);
131 ret = resultSet->Close();
132 EXPECT_EQ(ret, E_OK);
133
134 resultSet = store->QuerySql("SELECT * FROM test WHERE id = 3", std::vector<std::string>());
135 EXPECT_NE(resultSet, nullptr);
136 ret = resultSet->GoToFirstRow();
137 EXPECT_EQ(ret, E_OK);
138 ret = resultSet->GoToNextRow();
139 EXPECT_EQ(ret, E_ERROR);
140 ret = resultSet->Close();
141 EXPECT_EQ(ret, E_OK);
142 }
143
144 /**
145 * @tc.name: RdbStore_Delete_002
146 * @tc.desc: test RdbStore update, select id and update one row
147 * @tc.type: FUNC
148 */
149 HWTEST_F(RdbDeleteTest, RdbStore_Delete_002, TestSize.Level1)
150 {
151 std::shared_ptr<RdbStore> &store = RdbDeleteTest::store;
152
153 int64_t id;
154 ValuesBucket values;
155 int deletedRows;
156
157 values.PutInt("id", 1);
158 values.PutString("name", std::string("zhangsan"));
159 values.PutInt("age", 18);
160 values.PutDouble("salary", 100.5);
161 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
162 int ret = store->Insert(id, "test", values);
163 EXPECT_EQ(ret, E_OK);
164 EXPECT_EQ(1, id);
165
166 values.Clear();
167 values.PutInt("id", 2);
168 values.PutString("name", std::string("lisi"));
169 values.PutInt("age", 19);
170 values.PutDouble("salary", 200.5);
171 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
172 ret = store->Insert(id, "test", values);
173 EXPECT_EQ(ret, E_OK);
174 EXPECT_EQ(2, id);
175
176 values.Clear();
177 values.PutInt("id", 3);
178 values.PutString("name", std::string("wangyjing"));
179 values.PutInt("age", 20);
180 values.PutDouble("salary", 300.5);
181 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
182 ret = store->Insert(id, "test", values);
183 EXPECT_EQ(ret, E_OK);
184 EXPECT_EQ(3, id);
185
186 ret = store->Delete(deletedRows, "test");
187 EXPECT_EQ(ret, E_OK);
188 EXPECT_EQ(3, deletedRows);
189
190 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
191 EXPECT_NE(resultSet, nullptr);
192 ret = resultSet->GoToNextRow();
193 EXPECT_EQ(ret, E_ERROR);
194 ret = resultSet->Close();
195 EXPECT_EQ(ret, E_OK);
196 }
197
198 /**
199 * @tc.name: RdbStore_Delete_003
200 * @tc.desc: test RdbStore update, select id and update one row
201 * @tc.type: FUNC
202 */
203 HWTEST_F(RdbDeleteTest, RdbStore_Delete_003, TestSize.Level1)
204 {
205 std::shared_ptr<RdbStore> &store = RdbDeleteTest::store;
206
207 int64_t id;
208 ValuesBucket values;
209 int deletedRows;
210
211 values.PutInt("id", 1);
212 values.PutString("name", std::string("zhangsan"));
213 values.PutInt("age", 18);
214 values.PutDouble("salary", 100.5);
215 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
216 int ret = store->Insert(id, "test", values);
217 EXPECT_EQ(ret, E_OK);
218 EXPECT_EQ(1, id);
219
220 ret = store->Delete(deletedRows, "", "id = ?", std::vector<std::string>{ "1" });
221 EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
222
223 ret = store->Delete(deletedRows, "wrongTable", "id = ?", std::vector<std::string>{ "1" });
224 EXPECT_EQ(ret, RdbDeleteTest::E_SQLITE_ERROR);
225
226 ret = store->Delete(deletedRows, "test", "wrong sql id = ?", std::vector<std::string>{ "1" });
227 EXPECT_EQ(ret, RdbDeleteTest::E_SQLITE_ERROR);
228
229 ret = store->Delete(deletedRows, "test", "id = 1", std::vector<std::string>());
230 EXPECT_EQ(ret, E_OK);
231 EXPECT_EQ(deletedRows, 1);
232 }
233