1 /*
2  * Copyright (c) 2024 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 #define LOG_TAG "RdbCursorTest"
16 
17 #include "gtest/gtest.h"
18 #include "log_print.h"
19 #include "rdb_cursor.h"
20 #include "result_set.h"
21 #include "store/general_value.h"
22 
23 using namespace OHOS;
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS::DistributedRdb;
27 using namespace OHOS::DistributedData;
28 using DBStatus = DistributedDB::DBStatus;
29 namespace OHOS::Test {
30 namespace DistributedRDBTest {
31 static constexpr int MAX_DATA_NUM = 100;
32 class MockResultSet : public DistributedDB::ResultSet {
33 public:
MockResultSet()34     MockResultSet() {}
~MockResultSet()35     virtual ~MockResultSet() {}
36 
Close()37     void Close() override
38     {
39     }
40 
GetCount() const41     int GetCount() const override
42     {
43         return MAX_DATA_NUM;
44     }
45 
MoveToFirst()46     bool MoveToFirst() override
47     {
48         return true;
49     }
50 
MoveToNext()51     bool MoveToNext() override
52     {
53         return true;
54     }
55 
MoveToPrevious()56     bool MoveToPrevious() override
57     {
58         return true;
59     }
60 
IsAfterLast() const61     bool IsAfterLast() const override
62     {
63         return true;
64     }
65 
GetPosition() const66     int GetPosition() const override
67     {
68         return MAX_DATA_NUM;
69     }
70 
MoveToLast()71     bool MoveToLast() override
72     {
73         return true;
74     }
75 
Move(int offset)76     bool Move(int offset) override
77     {
78         return true;
79     }
80 
MoveToPosition(int position)81     bool MoveToPosition(int position) override
82     {
83         return true;
84     }
85 
IsFirst() const86     bool IsFirst() const override
87     {
88         return true;
89     }
90 
IsLast() const91     bool IsLast() const override
92     {
93         return true;
94     }
95 
IsBeforeFirst() const96     bool IsBeforeFirst() const override
97     {
98         return true;
99     }
100 
IsClosed() const101     bool IsClosed() const override
102     {
103         return true;
104     }
105 
GetEntry(DistributedDB::Entry & entry) const106     DBStatus GetEntry(DistributedDB::Entry &entry) const override
107     {
108         return DBStatus::OK;
109     }
110 
GetColumnNames(std::vector<std::string> & columnNames) const111     void GetColumnNames(std::vector<std::string> &columnNames) const override
112     {
113         columnNames = {"age", "identifier", "name", "phoneNumber"};
114     }
115 
GetColumnType(int columnIndex,DistributedDB::ResultSet::ColumnType & columnType) const116     DBStatus GetColumnType(int columnIndex, DistributedDB::ResultSet::ColumnType &columnType) const override
117     {
118         if (columnIndex < 0) {
119             return DBStatus::DB_ERROR;
120         }
121         return DBStatus::OK;
122     }
123 
GetColumnIndex(const std::string & columnName,int & columnIndex) const124     DBStatus GetColumnIndex(const std::string &columnName, int &columnIndex) const override
125     {
126         if (columnName == "ERROR") {
127             return DBStatus::DB_ERROR;
128         }
129         return DBStatus::OK;
130     }
131 
GetColumnName(int columnIndex,std::string & columnName) const132     DBStatus GetColumnName(int columnIndex, std::string &columnName) const override
133     {
134         if (columnIndex < 0) {
135             return DBStatus::DB_ERROR;
136         }
137         return DBStatus::OK;
138     }
139 
Get(int columnIndex,std::vector<uint8_t> & value) const140     DBStatus Get(int columnIndex, std::vector<uint8_t> &value) const override
141     {
142         if (columnIndex < 0) {
143             return DBStatus::DB_ERROR;
144         }
145         return DBStatus::OK;
146     }
147 
Get(int columnIndex,std::string & value) const148     DBStatus Get(int columnIndex, std::string &value) const override
149     {
150         if (columnIndex < 0) {
151             return DBStatus::DB_ERROR;
152         }
153         return DBStatus::OK;
154     }
155 
Get(int columnIndex,int64_t & value) const156     DBStatus Get(int columnIndex, int64_t &value) const override
157     {
158         if (columnIndex < 0) {
159             return DBStatus::DB_ERROR;
160         }
161         return DBStatus::OK;
162     }
163 
Get(int columnIndex,double & value) const164     DBStatus Get(int columnIndex, double &value) const override
165     {
166         if (columnIndex < 0) {
167             return DBStatus::DB_ERROR;
168         }
169         return DBStatus::OK;
170     }
171 
IsColumnNull(int columnIndex,bool & isNull) const172     DBStatus IsColumnNull(int columnIndex, bool &isNull) const override
173     {
174         if (columnIndex < 0) {
175             return DBStatus::DB_ERROR;
176         }
177         return DBStatus::OK;
178     }
179 
GetRow(std::map<std::string,DistributedDB::VariantData> & data) const180     DBStatus GetRow(std::map<std::string, DistributedDB::VariantData> &data) const override
181     {
182         return DBStatus::OK;
183     }
184 };
185 
186 class RdbCursorTest : public testing::Test {
187 public:
SetUpTestCase(void)188     static void SetUpTestCase(void){};
TearDownTestCase(void)189     static void TearDownTestCase(void){};
SetUp()190     void SetUp(){};
TearDown()191     void TearDown(){};
192 protected:
193     static std::shared_ptr<MockResultSet> resultSet;
194     static std::shared_ptr<RdbCursor> rdbCursor;
195 };
196 std::shared_ptr<MockResultSet> RdbCursorTest::resultSet = std::make_shared<MockResultSet>();
197 std::shared_ptr<RdbCursor> RdbCursorTest::rdbCursor = std::make_shared<RdbCursor>(std::move(resultSet));
198 
199 /**
200 * @tc.name: RdbCursorTest001
201 * @tc.desc: RdbCacheCursor function and error test.
202 * @tc.type: FUNC
203 * @tc.require:
204 * @tc.author: SQL
205 */
206 HWTEST_F(RdbCursorTest, RdbCursorTest001, TestSize.Level1)
207 {
208     EXPECT_NE(rdbCursor, nullptr);
209     std::vector<std::string> expectedNames = {"age", "identifier", "name", "phoneNumber"};
210     std::vector<std::string> names;
211     auto result = rdbCursor->GetColumnNames(names);
212     EXPECT_EQ(result, GeneralError::E_OK);
213     EXPECT_EQ(names, expectedNames);
214 
215     std::string colName = "colName";
216     auto err = rdbCursor->GetColumnName(1, colName);
217     EXPECT_EQ(err, GeneralError::E_OK);
218 
219     int32_t type = rdbCursor->GetColumnType(0);
220     EXPECT_EQ(type, TYPE_INDEX<std::monostate>);
221     type = rdbCursor->GetColumnType(-1);
222     EXPECT_EQ(type, TYPE_INDEX<std::monostate>);
223 
224     int32_t count = rdbCursor->GetCount();
225     EXPECT_EQ(count, MAX_DATA_NUM);
226 
227     err = rdbCursor->MoveToFirst();
228     EXPECT_EQ(err, GeneralError::E_OK);
229 
230     err = rdbCursor->MoveToNext();
231     EXPECT_EQ(err, GeneralError::E_OK);
232 
233     err = rdbCursor->MoveToPrev();
234     EXPECT_EQ(err, GeneralError::E_OK);
235 }
236 
237 /**
238 * @tc.name: RdbCursorTest002
239 * @tc.desc: RdbCacheCursor function and error test.
240 * @tc.type: FUNC
241 * @tc.require:
242 * @tc.author: SQL
243 */
244 HWTEST_F(RdbCursorTest, RdbCursorTest002, TestSize.Level1)
245 {
246     EXPECT_NE(rdbCursor, nullptr);
247     DistributedData::VBucket data;
248     auto result = rdbCursor->GetEntry(data);
249     EXPECT_EQ(result, GeneralError::E_OK);
250 
251     result = rdbCursor->GetRow(data);
252     EXPECT_EQ(result, GeneralError::E_OK);
253 
254     DistributedData::Value value;
255     result = rdbCursor->Get(1, value);
256     EXPECT_EQ(result, GeneralError::E_OK);
257     result = rdbCursor->Get(-1, value);
258     EXPECT_EQ(result, GeneralError::E_ERROR);
259 
260     std::string col = "col";
261     result = rdbCursor->Get(col, value);
262     EXPECT_EQ(result, GeneralError::E_ERROR);
263     result = rdbCursor->Get("ERROR", value);
264     EXPECT_EQ(result, GeneralError::E_ERROR);
265     bool ret = rdbCursor->IsEnd();
266     EXPECT_EQ(ret, true);
267 
268     result = rdbCursor->Close();
269     EXPECT_EQ(result, GeneralError::E_OK);
270 }
271 
272 /**
273 * @tc.name: Convert
274 * @tc.desc: Convert function test.
275 * @tc.type: FUNC
276 * @tc.require:
277 * @tc.author: SQL
278 */
279 HWTEST_F(RdbCursorTest, Convert, TestSize.Level1)
280 {
281     EXPECT_NE(rdbCursor, nullptr);
282     DistributedDB::ResultSet::ColumnType dbColumnType = DistributedDB::ResultSet::ColumnType::INT64;
283     int32_t result = rdbCursor->Convert(dbColumnType);
284     EXPECT_EQ(result, TYPE_INDEX<int64_t>);
285 
286     dbColumnType = DistributedDB::ResultSet::ColumnType::STRING;
287     result = rdbCursor->Convert(dbColumnType);
288     EXPECT_EQ(result, TYPE_INDEX<std::string>);
289 
290     dbColumnType = DistributedDB::ResultSet::ColumnType::BLOB;
291     result = rdbCursor->Convert(dbColumnType);
292     EXPECT_EQ(result, TYPE_INDEX<std::vector<uint8_t>>);
293 
294     dbColumnType = DistributedDB::ResultSet::ColumnType::DOUBLE;
295     result = rdbCursor->Convert(dbColumnType);
296     EXPECT_EQ(result, TYPE_INDEX<double>);
297 
298     dbColumnType = DistributedDB::ResultSet::ColumnType::NULL_VALUE;
299     result = rdbCursor->Convert(dbColumnType);
300     EXPECT_EQ(result, TYPE_INDEX<std::monostate>);
301 
302     dbColumnType = DistributedDB::ResultSet::ColumnType::INVALID_TYPE;
303     result = rdbCursor->Convert(dbColumnType);
304     EXPECT_EQ(result, TYPE_INDEX<std::monostate>);
305 
306     dbColumnType = static_cast<DistributedDB::ResultSet::ColumnType>(MAX_DATA_NUM);
307     result = rdbCursor->Convert(dbColumnType);
308     EXPECT_EQ(result, TYPE_INDEX<std::monostate>);
309 }
310 } // namespace DistributedRDBTest
311 } // namespace OHOS::Test