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