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 
16 #include <gtest/gtest.h>
17 
18 #include "accesstoken_kit.h"
19 #include "auth_delegate.h"
20 #include "bootstrap.h"
21 #include "crypto_manager.h"
22 #include "device_manager_adapter.h"
23 #include "directory/directory_manager.h"
24 #include "kvdb_general_store.h"
25 #include "kvdb_notifier_proxy.h"
26 #include "kvdb_watcher.h"
27 #include "kvstore_meta_manager.h"
28 #include "kvstore_sync_manager.h"
29 #include "log_print.h"
30 #include "metadata/meta_data_manager.h"
31 #include "metadata/secret_key_meta_data.h"
32 #include "metadata/store_meta_data.h"
33 #include "metadata/store_meta_data_local.h"
34 #include "query_helper.h"
35 #include "upgrade.h"
36 #include "user_delegate.h"
37 
38 using namespace testing::ext;
39 using namespace DistributedDB;
40 using namespace OHOS::DistributedData;
41 using StoreMetaData = OHOS::DistributedData::StoreMetaData;
42 using DBPassword = DistributedDB::CipherPassword;
43 using DBStatus = DistributedDB::DBStatus;
44 using Status = OHOS::DistributedKv::Status;
45 using KVDBWatcher = OHOS::DistributedKv::KVDBWatcher;
46 using KVDBNotifierProxy = OHOS::DistributedKv::KVDBNotifierProxy;
47 using QueryHelper = OHOS::DistributedKv::QueryHelper;
48 namespace OHOS::Test {
49 namespace DistributedDataTest {
50 class UpgradeTest : public testing::Test {
51 public:
SetUpTestCase(void)52     static void SetUpTestCase(void){};
TearDownTestCase(void)53     static void TearDownTestCase(void){};
54     void SetUp();
TearDown()55     void TearDown(){};
56 protected:
57     static constexpr const char *bundleName = "test_upgrade";
58     static constexpr const char *storeName = "test_upgrade_meta";
59     void InitMetaData();
60     StoreMetaData metaData_;
61 };
62 
InitMetaData()63 void UpgradeTest::InitMetaData()
64 {
65     metaData_.bundleName = bundleName;
66     metaData_.appId = bundleName;
67     metaData_.user = "0";
68     metaData_.area = OHOS::DistributedKv::EL1;
69     metaData_.instanceId = 0;
70     metaData_.isAutoSync = true;
71     metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
72     metaData_.storeId = storeName;
73     metaData_.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade";
74     metaData_.securityLevel = DistributedKv::SecurityLevel::S2;
75 }
76 
SetUp()77 void UpgradeTest::SetUp()
78 {
79     Bootstrap::GetInstance().LoadDirectory();
80     InitMetaData();
81 }
82 
83 class KvStoreSyncManagerTest : public testing::Test {
84 public:
SetUpTestCase(void)85     static void SetUpTestCase(void){};
TearDownTestCase(void)86     static void TearDownTestCase(void){};
SetUp()87     void SetUp(){};
TearDown()88     void TearDown(){};
89 protected:
90 };
91 
92 class KVDBWatcherTest : public testing::Test {
93 public:
SetUpTestCase(void)94     static void SetUpTestCase(void){};
TearDownTestCase(void)95     static void TearDownTestCase(void){};
SetUp()96     void SetUp(){};
TearDown()97     void TearDown(){};
98 protected:
99 };
100 
101 class UserDelegateTest : public testing::Test {
102 public:
SetUpTestCase(void)103     static void SetUpTestCase(void){};
TearDownTestCase(void)104     static void TearDownTestCase(void){};
SetUp()105     void SetUp(){};
TearDown()106     void TearDown(){};
107 protected:
108 };
109 
110 class QueryHelperTest : public testing::Test {
111 public:
SetUpTestCase(void)112     static void SetUpTestCase(void){};
TearDownTestCase(void)113     static void TearDownTestCase(void){};
SetUp()114     void SetUp(){};
TearDown()115     void TearDown(){};
116 protected:
117 };
118 
119 class AuthHandlerTest : public testing::Test {
120 public:
SetUpTestCase(void)121     static void SetUpTestCase(void){};
TearDownTestCase(void)122     static void TearDownTestCase(void){};
SetUp()123     void SetUp(){};
TearDown()124     void TearDown(){};
125 protected:
126 };
127 
128 /**
129 * @tc.name: UpdateStore
130 * @tc.desc: UpdateStore test the return result of input with different values.
131 * @tc.type: FUNC
132 * @tc.author: SQL
133 */
HWTEST_F(UpgradeTest, UpdateStore, TestSize.Level0)134 HWTEST_F(UpgradeTest, UpdateStore, TestSize.Level0)
135 {
136     DistributedKv::Upgrade upgrade;
137     StoreMetaData oldMeta = metaData_;
138     oldMeta.version = 1;
139     oldMeta.storeType = DistributedKv::KvStoreType::DEVICE_COLLABORATION;
140     oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
141     std::vector<uint8_t> password = {0x01, 0x02, 0x03};
142     auto dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
143     EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
144 
145     oldMeta.version = StoreMetaData::CURRENT_VERSION;
146     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
147     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
148 
149     oldMeta.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
150     DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
151         return "testexporter";
152     };
153     upgrade.exporter_ = exporter;
154     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
155     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
156 
157     oldMeta.version = 1;
158     DistributedKv::Upgrade::Cleaner cleaner = [](const StoreMetaData &meta) -> DistributedKv::Status {
159         return DistributedKv::Status::SUCCESS;
160     };
161     upgrade.cleaner_ = cleaner;
162     upgrade.exporter_ = nullptr;
163     upgrade.UpdatePassword(metaData_, password);
164     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
165     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
166 
167     metaData_.isEncrypt = true;
168     upgrade.UpdatePassword(metaData_, password);
169     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
170     EXPECT_TRUE(upgrade.RegisterCleaner(oldMeta.version, cleaner));
171     dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
172     EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
173 
174     StoreMetaData oldMetas = metaData_;
175     dbStatus = upgrade.UpdateStore(oldMetas, metaData_, password);
176     EXPECT_EQ(dbStatus, DBStatus::OK);
177 }
178 
179 /**
180 * @tc.name: ExportStore
181 * @tc.desc: ExportStore test the return result of input with different values.
182 * @tc.type: FUNC
183 * @tc.author: SQL
184 */
HWTEST_F(UpgradeTest, ExportStore, TestSize.Level0)185 HWTEST_F(UpgradeTest, ExportStore, TestSize.Level0)
186 {
187     DistributedKv::Upgrade upgrade;
188     StoreMetaData oldMeta = metaData_;
189     auto dbStatus = upgrade.ExportStore(oldMeta, metaData_);
190     EXPECT_EQ(dbStatus, DBStatus::OK);
191 
192     oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
193     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
194     EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
195 
196     DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
197         return "testexporter";
198     };
199     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
200     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
201     EXPECT_EQ(dbStatus, DBStatus::OK);
202 
203     DistributedKv::Upgrade::Exporter test = [](const StoreMetaData &, DBPassword &) {
204         return "";
205     };
206     EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, test));
207     dbStatus = upgrade.ExportStore(oldMeta, metaData_);
208     EXPECT_EQ(dbStatus, DBStatus::NOT_FOUND);
209 }
210 
211 /**
212 * @tc.name: GetEncryptedUuidByMeta
213 * @tc.desc: GetEncryptedUuidByMeta test the return result of input with different values.
214 * @tc.type: FUNC
215 * @tc.author: SQL
216 */
HWTEST_F(UpgradeTest, GetEncryptedUuidByMeta, TestSize.Level0)217 HWTEST_F(UpgradeTest, GetEncryptedUuidByMeta, TestSize.Level0)
218 {
219     DistributedKv::Upgrade upgrade;
220     auto dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
221     EXPECT_EQ(dbStatus, metaData_.deviceId);
222     metaData_.appId = "";
223     dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
224     EXPECT_EQ(dbStatus, metaData_.appId);
225 }
226 
227 /**
228 * @tc.name: AddSyncOperation
229 * @tc.desc: AddSyncOperation test the return result of input with different values.
230 * @tc.type: FUNC
231 * @tc.author: SQL
232 */
HWTEST_F(KvStoreSyncManagerTest, AddSyncOperation, TestSize.Level0)233 HWTEST_F(KvStoreSyncManagerTest, AddSyncOperation, TestSize.Level0)
234 {
235     DistributedKv::KvStoreSyncManager syncManager;
236     uintptr_t syncId = 0;
237     DistributedKv::KvStoreSyncManager::SyncFunc syncFunc = nullptr;
238     DistributedKv::KvStoreSyncManager::SyncEnd syncEnd = nullptr;
239     auto kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
240     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
241     syncId = 1;
242     kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
243     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
244     syncFunc = [](const DistributedKv::KvStoreSyncManager::SyncEnd &callback) -> Status {
245         std::map<std::string, DBStatus> status_map =
246             {{"key1", DBStatus::OK}, {"key2", DBStatus::DB_ERROR}};
247         callback(status_map);
248         return Status::SUCCESS;
249     };
250     kvStatus = syncManager.AddSyncOperation(0, 0, syncFunc, syncEnd);
251     EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
252 }
253 
254 /**
255 * @tc.name: RemoveSyncOperation
256 * @tc.desc: RemoveSyncOperation test the return result of input with different values.
257 * @tc.type: FUNC
258 * @tc.author: SQL
259 */
HWTEST_F(KvStoreSyncManagerTest, RemoveSyncOperation, TestSize.Level0)260 HWTEST_F(KvStoreSyncManagerTest, RemoveSyncOperation, TestSize.Level0)
261 {
262     DistributedKv::KvStoreSyncManager syncManager;
263     uintptr_t syncId = 0;
264     auto kvStatus = syncManager.RemoveSyncOperation(syncId);
265     EXPECT_EQ(kvStatus, Status::ERROR);
266 }
267 
268 /**
269 * @tc.name: DoRemoveSyncingOp
270 * @tc.desc: DoRemoveSyncingOp test the return result of input with different values.
271 * @tc.type: FUNC
272 * @tc.author: SQL
273 */
HWTEST_F(KvStoreSyncManagerTest, GetTimeoutSyncOps, TestSize.Level0)274 HWTEST_F(KvStoreSyncManagerTest, GetTimeoutSyncOps, TestSize.Level0)
275 {
276     DistributedKv::KvStoreSyncManager syncManager;
277     DistributedKv::KvStoreSyncManager::TimePoint currentTime = std::chrono::steady_clock::now();
278     DistributedKv::KvStoreSyncManager::KvSyncOperation syncOp;
279     syncOp.syncId = 1;
280     syncOp.beginTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(1);
281     std::list<DistributedKv::KvStoreSyncManager::KvSyncOperation> syncOps;
282 
283     EXPECT_TRUE(syncManager.realtimeSyncingOps_.empty());
284     EXPECT_TRUE(syncManager.scheduleSyncOps_.empty());
285     auto kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
286     EXPECT_EQ(kvStatus, false);
287     syncManager.realtimeSyncingOps_.push_back(syncOp);
288     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
289     EXPECT_EQ(kvStatus, false);
290     syncManager.realtimeSyncingOps_ = syncOps;
291     syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
292     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
293     EXPECT_EQ(kvStatus, false);
294 
295     syncManager.realtimeSyncingOps_.push_back(syncOp);
296     syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
297     EXPECT_TRUE(!syncManager.realtimeSyncingOps_.empty());
298     EXPECT_TRUE(!syncManager.scheduleSyncOps_.empty());
299     kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
300     EXPECT_EQ(kvStatus, true);
301 }
302 
303 /**
304 * @tc.name: KVDBWatcher
305 * @tc.desc: KVDBWatcher test the return result of input with different values.
306 * @tc.type: FUNC
307 * @tc.author: SQL
308 */
HWTEST_F(KVDBWatcherTest, KVDBWatcher, TestSize.Level0)309 HWTEST_F(KVDBWatcherTest, KVDBWatcher, TestSize.Level0)
310 {
311     GeneralWatcher::Origin origin;
312     GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
313     GeneralWatcher::ChangeInfo values;
314     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
315     sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
316     watcher->SetObserver(observer);
317     EXPECT_EQ(watcher->observer_, nullptr);
318     auto result = watcher->OnChange(origin, primaryFields, std::move(values));
319     EXPECT_EQ(result, GeneralError::E_OK);
320     GeneralWatcher::Fields fields;
321     GeneralWatcher::ChangeData data;
322     result = watcher->OnChange(origin, fields, std::move(data));
323     EXPECT_EQ(result, GeneralError::E_OK);
324 }
325 
326 /**
327 * @tc.name: ConvertToEntries
328 * @tc.desc: ConvertToEntries test the return result of input with different values.
329 * @tc.type: FUNC
330 * @tc.author: SQL
331 */
HWTEST_F(KVDBWatcherTest, ConvertToEntries, TestSize.Level0)332 HWTEST_F(KVDBWatcherTest, ConvertToEntries, TestSize.Level0)
333 {
334     std::vector<Values> values;
335     Values info1;
336     info1.emplace_back(Bytes({1, 2, 3}));
337     info1.emplace_back(Bytes({4, 5, 6}));
338     values.emplace_back(info1);
339     Values info2;
340     info2.emplace_back(Bytes({7, 8, 9}));
341     info2.emplace_back(Bytes({10, 11, 12}));
342     values.emplace_back(info2);
343     Values info3;
344     info3.emplace_back(Bytes({16, 17, 18}));
345     info3.emplace_back(int64_t(1));
346     values.emplace_back(info3);
347     Values info4;
348     info4.emplace_back(int64_t(1));
349     info4.emplace_back(Bytes({19, 20, 21}));
350     values.emplace_back(info4);
351     Values info5;
352     info5.emplace_back(int64_t(1));
353     info5.emplace_back(int64_t(1));
354     values.emplace_back(info5);
355     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
356     auto result = watcher->ConvertToEntries(values);
357     EXPECT_EQ(result.size(), 2);
358     EXPECT_EQ(result[0].key, Bytes({1, 2, 3}));
359     EXPECT_EQ(result[0].value, Bytes({4, 5, 6}));
360     EXPECT_EQ(result[1].key, Bytes({7, 8, 9}));
361     EXPECT_EQ(result[1].value, Bytes({10, 11, 12}));
362 }
363 
364 /**
365 * @tc.name: ConvertToKeys
366 * @tc.desc: ConvertToKeys test the return result of input with different values.
367 * @tc.type: FUNC
368 * @tc.author: SQL
369 */
HWTEST_F(KVDBWatcherTest, ConvertToKeys, TestSize.Level0)370 HWTEST_F(KVDBWatcherTest, ConvertToKeys, TestSize.Level0)
371 {
372     std::vector<GeneralWatcher::PRIValue> values = { "key1", 123, "key3", 456, "key5" };
373     std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
374     auto result = watcher->ConvertToKeys(values);
375     EXPECT_EQ(result.size(), 3);
376     EXPECT_EQ(result[0], "key1");
377     EXPECT_EQ(result[1], "key3");
378     EXPECT_EQ(result[2], "key5");
379 }
380 
381 /**
382 * @tc.name: UserDelegate
383 * @tc.desc: UserDelegate test the return result of input with different values.
384 * @tc.type: FUNC
385 * @tc.author: SQL
386 */
HWTEST_F(UserDelegateTest, UserDelegate, TestSize.Level0)387 HWTEST_F(UserDelegateTest, UserDelegate, TestSize.Level0)
388 {
389     std::shared_ptr<UserDelegate> userDelegate = std::make_shared<UserDelegate>();
390     auto result = userDelegate->GetLocalUserStatus();
391     EXPECT_EQ(result.size(), 0);
392     std::string deviceId = "";
393     result = userDelegate->GetRemoteUserStatus(deviceId);
394     EXPECT_TRUE(deviceId.empty());
395     EXPECT_TRUE(result.empty());
396     deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
397     result = userDelegate->GetRemoteUserStatus(deviceId);
398     EXPECT_EQ(result.size(), 0);
399 }
400 
401 /**
402 * @tc.name: StringToDbQuery
403 * @tc.desc: StringToDbQuery test the return result of input with different values.
404 * @tc.type: FUNC
405 * @tc.author: SQL
406 */
HWTEST_F(QueryHelperTest, StringToDbQuery, TestSize.Level0)407 HWTEST_F(QueryHelperTest, StringToDbQuery, TestSize.Level0)
408 {
409     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
410     bool isSuccess = false;
411     std::string query = "";
412     auto result = queryHelper->StringToDbQuery(query, isSuccess);
413     EXPECT_TRUE(isSuccess);
414     std::string querys(5 * 1024, 'a');
415     query = "querys" + querys;
416     result = queryHelper->StringToDbQuery(query, isSuccess);
417     EXPECT_FALSE(isSuccess);
418     query = "query";
419     result = queryHelper->StringToDbQuery(query, isSuccess);
420     EXPECT_FALSE(isSuccess);
421 }
422 
423 /**
424 * @tc.name: Handle001
425 * @tc.desc: Handle test the return result of input with different values.
426 * @tc.type: FUNC
427 * @tc.author: SQL
428 */
HWTEST_F(QueryHelperTest, Handle001, TestSize.Level0)429 HWTEST_F(QueryHelperTest, Handle001, TestSize.Level0)
430 {
431     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
432     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
433     int pointer = 0;
434     int end = 1;
435     int ends = 4;
436     DistributedDB::Query dbQuery;
437     EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
438     EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
439     EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
440     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
441     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
442     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
443     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
444     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
445     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
446     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
447     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
448     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
449     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
450 
451     pointer = 0;
452     words = {"INTEGER", "LONG", "DOUBLE", "STRING"};
453     EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
454     EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
455     EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
456     EXPECT_TRUE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
457     EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
458     pointer = 0;
459     EXPECT_TRUE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
460     EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
461     pointer = 0;
462     EXPECT_TRUE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
463     EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
464     pointer = 0;
465     EXPECT_TRUE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
466     EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
467     pointer = 0;
468     EXPECT_TRUE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
469     EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
470 }
471 
472 /**
473 * @tc.name: Handle002
474 * @tc.desc: Handle test the return result of input with different values.
475 * @tc.type: FUNC
476 * @tc.author: SQL
477 */
HWTEST_F(QueryHelperTest, Handle002, TestSize.Level0)478 HWTEST_F(QueryHelperTest, Handle002, TestSize.Level0)
479 {
480     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
481     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
482     int pointer = 1;
483     int end = 1;
484     int ends = 4;
485     DistributedDB::Query dbQuery;
486     EXPECT_TRUE(queryHelper->HandleIsNull(words, pointer, ends, dbQuery));
487     EXPECT_FALSE(queryHelper->HandleIsNull(words, pointer, end, dbQuery));
488     pointer = 0;
489     EXPECT_TRUE(queryHelper->HandleIsNotNull(words, pointer, ends, dbQuery));
490     EXPECT_FALSE(queryHelper->HandleIsNotNull(words, pointer, end, dbQuery));
491     pointer = 0;
492     EXPECT_TRUE(queryHelper->HandleLike(words, pointer, ends, dbQuery));
493     EXPECT_FALSE(queryHelper->HandleLike(words, pointer, end, dbQuery));
494     pointer = 0;
495     EXPECT_TRUE(queryHelper->HandleNotLike(words, pointer, ends, dbQuery));
496     EXPECT_FALSE(queryHelper->HandleNotLike(words, pointer, end, dbQuery));
497     pointer = 0;
498     EXPECT_TRUE(queryHelper->HandleOrderByAsc(words, pointer, ends, dbQuery));
499     EXPECT_FALSE(queryHelper->HandleOrderByAsc(words, pointer, end, dbQuery));
500     pointer = 0;
501     EXPECT_TRUE(queryHelper->HandleOrderByDesc(words, pointer, ends, dbQuery));
502     EXPECT_FALSE(queryHelper->HandleOrderByDesc(words, pointer, end, dbQuery));
503     pointer = 0;
504     EXPECT_TRUE(queryHelper->HandleOrderByWriteTime(words, pointer, ends, dbQuery));
505     EXPECT_FALSE(queryHelper->HandleOrderByWriteTime(words, pointer, end, dbQuery));
506     pointer = 0;
507     EXPECT_TRUE(queryHelper->HandleLimit(words, pointer, ends, dbQuery));
508     EXPECT_FALSE(queryHelper->HandleLimit(words, pointer, end, dbQuery));
509     pointer = 0;
510     EXPECT_TRUE(queryHelper->HandleKeyPrefix(words, pointer, ends, dbQuery));
511     EXPECT_FALSE(queryHelper->HandleKeyPrefix(words, pointer, end, dbQuery));
512 }
513 
514 /**
515 * @tc.name: Handle003
516 * @tc.desc: Handle test the return result of input with different values.
517 * @tc.type: FUNC
518 * @tc.author: SQL
519 */
HWTEST_F(QueryHelperTest, Handle003, TestSize.Level0)520 HWTEST_F(QueryHelperTest, Handle003, TestSize.Level0)
521 {
522     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
523     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
524     std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
525     int pointer = 0;
526     int end = 1;
527     int ends = 5;
528     DistributedDB::Query dbQuery;
529     EXPECT_FALSE(queryHelper->HandleIn(words, pointer, ends, dbQuery));
530     EXPECT_FALSE(queryHelper->HandleIn(words, pointer, end, dbQuery));
531     EXPECT_FALSE(queryHelper->HandleIn(wordss, pointer, end, dbQuery));
532     EXPECT_TRUE(queryHelper->HandleIn(wordss, pointer, ends, dbQuery));
533     pointer = 0;
534     EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, ends, dbQuery));
535     EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, end, dbQuery));
536     EXPECT_FALSE(queryHelper->HandleNotIn(wordss, pointer, end, dbQuery));
537     EXPECT_TRUE(queryHelper->HandleNotIn(wordss, pointer, ends, dbQuery));
538 }
539 
540 /**
541 * @tc.name: Handle004
542 * @tc.desc: Handle test the return result of input with different values.
543 * @tc.type: FUNC
544 * @tc.author: SQL
545 */
HWTEST_F(QueryHelperTest, Handle004, TestSize.Level0)546 HWTEST_F(QueryHelperTest, Handle004, TestSize.Level0)
547 {
548     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
549     std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
550     std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
551     int pointer = 2;
552     int end = 3;
553     int ends = 5;
554     DistributedDB::Query dbQuery;
555     EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, ends, dbQuery));
556     EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, end, dbQuery));
557     EXPECT_FALSE(queryHelper->HandleInKeys(wordss, pointer, end, dbQuery));
558     EXPECT_TRUE(queryHelper->HandleInKeys(wordss, pointer, ends, dbQuery));
559     pointer = 3;
560     EXPECT_FALSE(queryHelper->HandleSetSuggestIndex(wordss, pointer, end, dbQuery));
561     EXPECT_TRUE(queryHelper->HandleSetSuggestIndex(wordss, pointer, ends, dbQuery));
562     pointer = 3;
563     EXPECT_FALSE(queryHelper->HandleDeviceId(wordss, pointer, end, dbQuery));
564     EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
565     queryHelper->hasPrefixKey_ = true;
566     pointer = 3;
567     EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
568 }
569 
570 /**
571 * @tc.name: StringTo
572 * @tc.desc: StringTo test the return result of input with different values.
573 * @tc.type: FUNC
574 * @tc.author: SQL
575 */
HWTEST_F(QueryHelperTest, StringTo, TestSize.Level0)576 HWTEST_F(QueryHelperTest, StringTo, TestSize.Level0)
577 {
578     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
579     std::string word = "true";
580     EXPECT_TRUE(queryHelper->StringToBoolean(word));
581     word = "false";
582     EXPECT_FALSE(queryHelper->StringToBoolean(word));
583     word = "BOOL";
584     EXPECT_FALSE(queryHelper->StringToBoolean(word));
585 
586     word = "^EMPTY_STRING";
587     auto result = queryHelper->StringToString(word);
588     EXPECT_EQ(result, "");
589     word = "START";
590     result = queryHelper->StringToString(word);
591     EXPECT_EQ(result, "START");
592     word = "START^^START";
593     result = queryHelper->StringToString(word);
594     EXPECT_EQ(result, "START START");
595     word = "START(^)START";
596     result = queryHelper->StringToString(word);
597     EXPECT_EQ(result, "START^START");
598 }
599 
600 /**
601 * @tc.name: Get
602 * @tc.desc: Get test the return result of input with different values.
603 * @tc.type: FUNC
604 * @tc.author: SQL
605 */
HWTEST_F(QueryHelperTest, Get, TestSize.Level0)606 HWTEST_F(QueryHelperTest, Get, TestSize.Level0)
607 {
608     std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
609     std::vector<std::string> words = {"1", "2", "3", "4", "5", "^END"};
610     int elementPointer = 0;
611     int end = 5;
612     std::vector<int> ret = {1, 2, 3, 4, 5};
613     auto result = queryHelper->GetIntegerList(words, elementPointer, end);
614     EXPECT_EQ(result, ret);
615     elementPointer = 6;
616     ret = {};
617     result = queryHelper->GetIntegerList(words, elementPointer, end);
618     EXPECT_EQ(result, ret);
619 
620     elementPointer = 0;
621     std::vector<int64_t> ret1 = {1, 2, 3, 4, 5};
622     auto result1 = queryHelper->GetLongList(words, elementPointer, end);
623     EXPECT_EQ(result1, ret1);
624     elementPointer = 6;
625     ret1 = {};
626     result1 = queryHelper->GetLongList(words, elementPointer, end);
627     EXPECT_EQ(result1, ret1);
628 
629     elementPointer = 0;
630     std::vector<double> ret2 = {1, 2, 3, 4, 5};
631     auto result2 = queryHelper->GetDoubleList(words, elementPointer, end);
632     EXPECT_EQ(result2, ret2);
633     elementPointer = 6;
634     ret2 = {};
635     result2 = queryHelper->GetDoubleList(words, elementPointer, end);
636     EXPECT_EQ(result2, ret2);
637 
638     std::vector<std::string> words1 = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
639     elementPointer = 0;
640     std::vector<std::string> ret3 = { "^NOT_IN", "INTEGER", "LONG", "^START", "STRING" };
641     auto result3 = queryHelper->GetStringList(words1, elementPointer, end);
642     EXPECT_EQ(result3, ret3);
643     elementPointer = 6;
644     ret3 = {};
645     result3 = queryHelper->GetStringList(words1, elementPointer, end);
646     EXPECT_EQ(result3, ret3);
647 }
648 
649 /**
650 * @tc.name: AuthHandler
651 * @tc.desc: AuthHandler test the return result of input with different values.
652 * @tc.type: FUNC
653 * @tc.author: SQL
654 */
HWTEST_F(AuthHandlerTest, AuthHandler, TestSize.Level0)655 HWTEST_F(AuthHandlerTest, AuthHandler, TestSize.Level0)
656 {
657     int localUserId = 0;
658     int peerUserId = 0;
659     std::string peerDeviceId = "";
660     int32_t authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
661     bool isSend = false;
662     auto result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
663     EXPECT_FALSE(result);
664     authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
665     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
666     EXPECT_TRUE(result);
667 
668     authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
669     peerDeviceId = "peerDeviceId";
670     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
671     EXPECT_FALSE(result);
672 
673     authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
674     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
675     EXPECT_TRUE(result);
676 
677     localUserId = 1;
678     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
679     EXPECT_FALSE(result);
680 
681     peerUserId = 1;
682     result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
683     EXPECT_FALSE(result);
684 }
685 } // namespace DistributedDataTest
686 } // namespace OHOS::Test