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