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/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;
__anon99d000880102(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;
__anon99d000880202(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: UpdateStore002
216 * @tc.desc: UpdateStore test the return result of input with different values.
217 * @tc.type: FUNC
218 * @tc.author: yl
219 */
220 HWTEST_F(UpgradeTest, UpdateStore002, TestSize.Level0)
221 {
222 DistributedKv::Upgrade upgrade;
223 StoreMetaData oldMeta = metaData_;
224 oldMeta.isNeedUpdateDeviceId = true;
225 std::vector<uint8_t> password;
226 auto dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
227 EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
228
229 oldMeta.isEncrypt = true;
230 dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
231 EXPECT_EQ(dbStatus, DBStatus::OK);
232 }
233
234 /**
235 * @tc.name: ExportStore
236 * @tc.desc: ExportStore test the return result of input with different values.
237 * @tc.type: FUNC
238 * @tc.author: SQL
239 */
240 HWTEST_F(UpgradeTest, ExportStore, TestSize.Level0)
241 {
242 DistributedKv::Upgrade upgrade;
243 StoreMetaData oldMeta = metaData_;
244 auto dbStatus = upgrade.ExportStore(oldMeta, metaData_);
245 EXPECT_EQ(dbStatus, DBStatus::OK);
246
247 oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
248 dbStatus = upgrade.ExportStore(oldMeta, metaData_);
249 EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
250
__anon99d000880302(const StoreMetaData &, DBPassword &) 251 DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
252 return "testexporter";
253 };
254 EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
255 dbStatus = upgrade.ExportStore(oldMeta, metaData_);
256 EXPECT_EQ(dbStatus, DBStatus::OK);
257
__anon99d000880402(const StoreMetaData &, DBPassword &) 258 DistributedKv::Upgrade::Exporter test = [](const StoreMetaData &, DBPassword &) {
259 return "";
260 };
261 EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, test));
262 dbStatus = upgrade.ExportStore(oldMeta, metaData_);
263 EXPECT_EQ(dbStatus, DBStatus::NOT_FOUND);
264 }
265
266 /**
267 * @tc.name: GetEncryptedUuidByMeta
268 * @tc.desc: GetEncryptedUuidByMeta test the return result of input with different values.
269 * @tc.type: FUNC
270 * @tc.author: SQL
271 */
272 HWTEST_F(UpgradeTest, GetEncryptedUuidByMeta, TestSize.Level0)
273 {
274 DistributedKv::Upgrade upgrade;
275 auto dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
276 EXPECT_EQ(dbStatus, metaData_.deviceId);
277 metaData_.appId = "";
278 dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
279 EXPECT_EQ(dbStatus, metaData_.appId);
280 }
281
282 /**
283 * @tc.name: AddSyncOperation
284 * @tc.desc: AddSyncOperation test the return result of input with different values.
285 * @tc.type: FUNC
286 * @tc.author: SQL
287 */
288 HWTEST_F(KvStoreSyncManagerTest, AddSyncOperation, TestSize.Level0)
289 {
290 DistributedKv::KvStoreSyncManager syncManager;
291 uintptr_t syncId = 0;
292 DistributedKv::KvStoreSyncManager::SyncFunc syncFunc = nullptr;
293 DistributedKv::KvStoreSyncManager::SyncEnd syncEnd = nullptr;
294 auto kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
295 EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
296 syncId = 1;
297 kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
298 EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
__anon99d000880502(const DistributedKv::KvStoreSyncManager::SyncEnd &callback) 299 syncFunc = [](const DistributedKv::KvStoreSyncManager::SyncEnd &callback) -> Status {
300 std::map<std::string, DBStatus> status_map =
301 {{"key1", DBStatus::OK}, {"key2", DBStatus::DB_ERROR}};
302 callback(status_map);
303 return Status::SUCCESS;
304 };
305 kvStatus = syncManager.AddSyncOperation(0, 0, syncFunc, syncEnd);
306 EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
307 }
308
309 /**
310 * @tc.name: RemoveSyncOperation
311 * @tc.desc: RemoveSyncOperation test the return result of input with different values.
312 * @tc.type: FUNC
313 * @tc.author: SQL
314 */
315 HWTEST_F(KvStoreSyncManagerTest, RemoveSyncOperation, TestSize.Level0)
316 {
317 DistributedKv::KvStoreSyncManager syncManager;
318 uintptr_t syncId = 0;
319 auto kvStatus = syncManager.RemoveSyncOperation(syncId);
320 EXPECT_EQ(kvStatus, Status::ERROR);
321 }
322
323 /**
324 * @tc.name: DoRemoveSyncingOp
325 * @tc.desc: DoRemoveSyncingOp test the return result of input with different values.
326 * @tc.type: FUNC
327 * @tc.author: SQL
328 */
329 HWTEST_F(KvStoreSyncManagerTest, GetTimeoutSyncOps, TestSize.Level0)
330 {
331 DistributedKv::KvStoreSyncManager syncManager;
332 DistributedKv::KvStoreSyncManager::TimePoint currentTime = std::chrono::steady_clock::now();
333 DistributedKv::KvStoreSyncManager::KvSyncOperation syncOp;
334 syncOp.syncId = 1;
335 syncOp.beginTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(1);
336 std::list<DistributedKv::KvStoreSyncManager::KvSyncOperation> syncOps;
337
338 EXPECT_TRUE(syncManager.realtimeSyncingOps_.empty());
339 EXPECT_TRUE(syncManager.scheduleSyncOps_.empty());
340 auto kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
341 EXPECT_EQ(kvStatus, false);
342 syncManager.realtimeSyncingOps_.emplace_back(syncOp);
343 kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
344 EXPECT_EQ(kvStatus, false);
345 syncManager.realtimeSyncingOps_ = syncOps;
346 syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
347 kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
348 EXPECT_EQ(kvStatus, false);
349
350 syncManager.realtimeSyncingOps_.emplace_back(syncOp);
351 syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
352 EXPECT_TRUE(!syncManager.realtimeSyncingOps_.empty());
353 EXPECT_TRUE(!syncManager.scheduleSyncOps_.empty());
354 kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
355 EXPECT_EQ(kvStatus, true);
356 }
357
358 /**
359 * @tc.name: KVDBWatcher
360 * @tc.desc: KVDBWatcher test the return result of input with different values.
361 * @tc.type: FUNC
362 * @tc.author: SQL
363 */
364 HWTEST_F(KVDBWatcherTest, KVDBWatcher, TestSize.Level0)
365 {
366 GeneralWatcher::Origin origin;
367 GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
368 GeneralWatcher::ChangeInfo values;
369 std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
370 sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
371 watcher->SetObserver(observer);
372 EXPECT_EQ(watcher->observer_, nullptr);
373 auto result = watcher->OnChange(origin, primaryFields, std::move(values));
374 EXPECT_EQ(result, GeneralError::E_OK);
375 GeneralWatcher::Fields fields;
376 GeneralWatcher::ChangeData data;
377 result = watcher->OnChange(origin, fields, std::move(data));
378 EXPECT_EQ(result, GeneralError::E_OK);
379 }
380
381 /**
382 * @tc.name: OnChange001
383 * @tc.desc: OnChange test function.
384 * @tc.type: FUNC
385 * @tc.require:
386 * @tc.author: suoqilong
387 */
388 HWTEST_F(KVDBWatcherTest, OnChange001, TestSize.Level0)
389 {
390 GeneralWatcher::Origin origin;
391 origin.store = "store";
392 GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
393 GeneralWatcher::ChangeInfo values;
394 values["store"][OP_INSERT].emplace_back(std::string("values1"));
395 values["store"][OP_INSERT].emplace_back(11LL);
396 values["store"][OP_INSERT].emplace_back(1.11);
397 values["store"][OP_UPDATE].emplace_back(std::string("values2"));
398 values["store"][OP_UPDATE].emplace_back(22LL);
399 values["store"][OP_UPDATE].emplace_back(2.22);
400 values["store"][OP_DELETE].emplace_back(std::string("values3"));
401 values["store"][OP_DELETE].emplace_back(33LL);
402 values["store"][OP_DELETE].emplace_back(3.33);
403 std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
404 sptr<OHOS::DistributedKv::IKvStoreObserver> observer = nullptr;
405 watcher->SetObserver(observer);
406 EXPECT_EQ(watcher->observer_, nullptr);
407 auto result = watcher->OnChange(origin, primaryFields, std::move(values));
408 EXPECT_EQ(result, GeneralError::E_NOT_INIT);
409 }
410
411 /**
412 * @tc.name: OnChange002
413 * @tc.desc: OnChange test function.
414 * @tc.type: FUNC
415 * @tc.require:
416 * @tc.author: suoqilong
417 */
418 HWTEST_F(KVDBWatcherTest, OnChange002, TestSize.Level0)
419 {
420 GeneralWatcher::Origin origin;
421 origin.store = "store";
422 GeneralWatcher::Fields fields;
423 GeneralWatcher::ChangeData datas;
424 datas["store"][OP_INSERT].push_back({11LL});
425 datas["store"][OP_INSERT].push_back({1.11});
426 datas["store"][OP_INSERT].push_back({std::string("datas1")});
427 datas["store"][OP_INSERT].push_back({Bytes({1, 2, 3})});
428 datas["store"][OP_UPDATE].push_back({22LL});
429 datas["store"][OP_UPDATE].push_back({2.22});
430 datas["store"][OP_UPDATE].push_back({std::string("datas2")});
431 datas["store"][OP_UPDATE].push_back({Bytes({4, 5, 6})});
432 datas["store"][OP_DELETE].push_back({33LL});
433 datas["store"][OP_DELETE].push_back({3.33});
434 datas["store"][OP_DELETE].push_back({std::string("datas3")});
435 datas["store"][OP_DELETE].push_back({Bytes({7, 8, 9})});
436 std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
437 sptr<OHOS::DistributedKv::IKvStoreObserver> observer = nullptr;
438 watcher->SetObserver(observer);
439 EXPECT_EQ(watcher->observer_, nullptr);
440 auto result = watcher->OnChange(origin, fields, std::move(datas));
441 EXPECT_EQ(result, GeneralError::E_NOT_INIT);
442 }
443
444 /**
445 * @tc.name: ConvertToEntries
446 * @tc.desc: ConvertToEntries test the return result of input with different values.
447 * @tc.type: FUNC
448 * @tc.author: SQL
449 */
450 HWTEST_F(KVDBWatcherTest, ConvertToEntries, TestSize.Level0)
451 {
452 std::vector<Values> values;
453 Values info1;
454 info1.emplace_back(Bytes({1, 2, 3}));
455 info1.emplace_back(Bytes({4, 5, 6}));
456 values.emplace_back(info1);
457 Values info2;
458 info2.emplace_back(Bytes({7, 8, 9}));
459 info2.emplace_back(Bytes({10, 11, 12}));
460 values.emplace_back(info2);
461 Values info3;
462 info3.emplace_back(Bytes({16, 17, 18}));
463 info3.emplace_back(int64_t(1));
464 values.emplace_back(info3);
465 Values info4;
466 info4.emplace_back(int64_t(1));
467 info4.emplace_back(Bytes({19, 20, 21}));
468 values.emplace_back(info4);
469 Values info5;
470 info5.emplace_back(int64_t(1));
471 info5.emplace_back(int64_t(1));
472 values.emplace_back(info5);
473 std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
474 auto result = watcher->ConvertToEntries(values);
475 EXPECT_EQ(result.size(), 2);
476 EXPECT_EQ(result[0].key, Bytes({1, 2, 3}));
477 EXPECT_EQ(result[0].value, Bytes({4, 5, 6}));
478 EXPECT_EQ(result[1].key, Bytes({7, 8, 9}));
479 EXPECT_EQ(result[1].value, Bytes({10, 11, 12}));
480 }
481
482 /**
483 * @tc.name: ConvertToKeys
484 * @tc.desc: ConvertToKeys test the return result of input with different values.
485 * @tc.type: FUNC
486 * @tc.author: SQL
487 */
488 HWTEST_F(KVDBWatcherTest, ConvertToKeys, TestSize.Level0)
489 {
490 std::vector<GeneralWatcher::PRIValue> values = { "key1", 123, "key3", 456, "key5" };
491 std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
492 auto result = watcher->ConvertToKeys(values);
493 EXPECT_EQ(result.size(), 3);
494 EXPECT_EQ(result[0], "key1");
495 EXPECT_EQ(result[1], "key3");
496 EXPECT_EQ(result[2], "key5");
497 }
498
499 /**
500 * @tc.name: UserDelegate
501 * @tc.desc: UserDelegate test the return result of input with different values.
502 * @tc.type: FUNC
503 * @tc.author: SQL
504 */
505 HWTEST_F(UserDelegateTest, UserDelegate, TestSize.Level0)
506 {
507 std::shared_ptr<UserDelegate> userDelegate = std::make_shared<UserDelegate>();
508 auto result = userDelegate->GetLocalUserStatus();
509 EXPECT_EQ(result.size(), 0);
510 std::string deviceId = "";
511 result = userDelegate->GetRemoteUserStatus(deviceId);
512 EXPECT_TRUE(deviceId.empty());
513 EXPECT_TRUE(result.empty());
514 deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
515 result = userDelegate->GetRemoteUserStatus(deviceId);
516 EXPECT_EQ(result.size(), 0);
517 }
518
519 /**
520 * @tc.name: StringToDbQuery
521 * @tc.desc: StringToDbQuery test the return result of input with different values.
522 * @tc.type: FUNC
523 * @tc.author: SQL
524 */
525 HWTEST_F(QueryHelperTest, StringToDbQuery, TestSize.Level0)
526 {
527 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
528 bool isSuccess = false;
529 std::string query = "";
530 auto result = queryHelper->StringToDbQuery(query, isSuccess);
531 EXPECT_TRUE(isSuccess);
532 std::string querys(5 * 1024, 'a');
533 query = "querys" + querys;
534 result = queryHelper->StringToDbQuery(query, isSuccess);
535 EXPECT_FALSE(isSuccess);
536 query = "query";
537 result = queryHelper->StringToDbQuery(query, isSuccess);
538 EXPECT_FALSE(isSuccess);
539 }
540
541 /**
542 * @tc.name: Handle001
543 * @tc.desc: Handle test the return result of input with different values.
544 * @tc.type: FUNC
545 * @tc.author: SQL
546 */
547 HWTEST_F(QueryHelperTest, Handle001, TestSize.Level0)
548 {
549 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
550 std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
551 int pointer = 0;
552 int end = 1;
553 int ends = 4;
554 DistributedDB::Query dbQuery;
555 EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
556 EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
557 EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
558 EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
559 EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
560 EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
561 EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
562 EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
563 EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
564 EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
565 EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
566 EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
567 EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
568
569 pointer = 0;
570 words = {"INTEGER", "LONG", "DOUBLE", "STRING"};
571 EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
572 EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
573 EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
574 EXPECT_TRUE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
575 EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
576 pointer = 0;
577 EXPECT_TRUE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
578 EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
579 pointer = 0;
580 EXPECT_TRUE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
581 EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
582 pointer = 0;
583 EXPECT_TRUE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
584 EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
585 pointer = 0;
586 EXPECT_TRUE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
587 EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
588 }
589
590 /**
591 * @tc.name: Handle002
592 * @tc.desc: Handle test the return result of input with different values.
593 * @tc.type: FUNC
594 * @tc.author: SQL
595 */
596 HWTEST_F(QueryHelperTest, Handle002, TestSize.Level0)
597 {
598 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
599 std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
600 int pointer = 1;
601 int end = 1;
602 int ends = 4;
603 DistributedDB::Query dbQuery;
604 EXPECT_TRUE(queryHelper->HandleIsNull(words, pointer, ends, dbQuery));
605 EXPECT_FALSE(queryHelper->HandleIsNull(words, pointer, end, dbQuery));
606 pointer = 0;
607 EXPECT_TRUE(queryHelper->HandleIsNotNull(words, pointer, ends, dbQuery));
608 EXPECT_FALSE(queryHelper->HandleIsNotNull(words, pointer, end, dbQuery));
609 pointer = 0;
610 EXPECT_TRUE(queryHelper->HandleLike(words, pointer, ends, dbQuery));
611 EXPECT_FALSE(queryHelper->HandleLike(words, pointer, end, dbQuery));
612 pointer = 0;
613 EXPECT_TRUE(queryHelper->HandleNotLike(words, pointer, ends, dbQuery));
614 EXPECT_FALSE(queryHelper->HandleNotLike(words, pointer, end, dbQuery));
615 pointer = 0;
616 EXPECT_TRUE(queryHelper->HandleOrderByAsc(words, pointer, ends, dbQuery));
617 EXPECT_FALSE(queryHelper->HandleOrderByAsc(words, pointer, end, dbQuery));
618 pointer = 0;
619 EXPECT_TRUE(queryHelper->HandleOrderByDesc(words, pointer, ends, dbQuery));
620 EXPECT_FALSE(queryHelper->HandleOrderByDesc(words, pointer, end, dbQuery));
621 pointer = 0;
622 EXPECT_TRUE(queryHelper->HandleOrderByWriteTime(words, pointer, ends, dbQuery));
623 EXPECT_FALSE(queryHelper->HandleOrderByWriteTime(words, pointer, end, dbQuery));
624 pointer = 0;
625 EXPECT_TRUE(queryHelper->HandleLimit(words, pointer, ends, dbQuery));
626 EXPECT_FALSE(queryHelper->HandleLimit(words, pointer, end, dbQuery));
627 pointer = 0;
628 EXPECT_TRUE(queryHelper->HandleKeyPrefix(words, pointer, ends, dbQuery));
629 EXPECT_FALSE(queryHelper->HandleKeyPrefix(words, pointer, end, dbQuery));
630 }
631
632 /**
633 * @tc.name: Handle003
634 * @tc.desc: Handle test the return result of input with different values.
635 * @tc.type: FUNC
636 * @tc.author: SQL
637 */
638 HWTEST_F(QueryHelperTest, Handle003, TestSize.Level0)
639 {
640 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
641 std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
642 std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
643 int pointer = 0;
644 int end = 1;
645 int ends = 5;
646 DistributedDB::Query dbQuery;
647 EXPECT_FALSE(queryHelper->HandleIn(words, pointer, ends, dbQuery));
648 EXPECT_FALSE(queryHelper->HandleIn(words, pointer, end, dbQuery));
649 EXPECT_FALSE(queryHelper->HandleIn(wordss, pointer, end, dbQuery));
650 EXPECT_TRUE(queryHelper->HandleIn(wordss, pointer, ends, dbQuery));
651 pointer = 0;
652 EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, ends, dbQuery));
653 EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, end, dbQuery));
654 EXPECT_FALSE(queryHelper->HandleNotIn(wordss, pointer, end, dbQuery));
655 EXPECT_TRUE(queryHelper->HandleNotIn(wordss, pointer, ends, dbQuery));
656 }
657
658 /**
659 * @tc.name: Handle004
660 * @tc.desc: Handle test the return result of input with different values.
661 * @tc.type: FUNC
662 * @tc.author: SQL
663 */
664 HWTEST_F(QueryHelperTest, Handle004, TestSize.Level0)
665 {
666 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
667 std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
668 std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
669 int pointer = 2;
670 int end = 3;
671 int ends = 5;
672 DistributedDB::Query dbQuery;
673 EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, ends, dbQuery));
674 EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, end, dbQuery));
675 EXPECT_FALSE(queryHelper->HandleInKeys(wordss, pointer, end, dbQuery));
676 EXPECT_TRUE(queryHelper->HandleInKeys(wordss, pointer, ends, dbQuery));
677 pointer = 3;
678 EXPECT_FALSE(queryHelper->HandleSetSuggestIndex(wordss, pointer, end, dbQuery));
679 EXPECT_TRUE(queryHelper->HandleSetSuggestIndex(wordss, pointer, ends, dbQuery));
680 pointer = 3;
681 EXPECT_FALSE(queryHelper->HandleDeviceId(wordss, pointer, end, dbQuery));
682 EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
683 queryHelper->hasPrefixKey_ = true;
684 pointer = 3;
685 EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
686 }
687
688 /**
689 * @tc.name: StringTo
690 * @tc.desc: StringTo test the return result of input with different values.
691 * @tc.type: FUNC
692 * @tc.author: SQL
693 */
694 HWTEST_F(QueryHelperTest, StringTo, TestSize.Level0)
695 {
696 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
697 std::string word = "true";
698 EXPECT_TRUE(queryHelper->StringToBoolean(word));
699 word = "false";
700 EXPECT_FALSE(queryHelper->StringToBoolean(word));
701 word = "BOOL";
702 EXPECT_FALSE(queryHelper->StringToBoolean(word));
703
704 word = "^EMPTY_STRING";
705 auto result = queryHelper->StringToString(word);
706 EXPECT_EQ(result, "");
707 word = "START";
708 result = queryHelper->StringToString(word);
709 EXPECT_EQ(result, "START");
710 word = "START^^START";
711 result = queryHelper->StringToString(word);
712 EXPECT_EQ(result, "START START");
713 word = "START(^)START";
714 result = queryHelper->StringToString(word);
715 EXPECT_EQ(result, "START^START");
716 }
717
718 /**
719 * @tc.name: Get
720 * @tc.desc: Get test the return result of input with different values.
721 * @tc.type: FUNC
722 * @tc.author: SQL
723 */
724 HWTEST_F(QueryHelperTest, Get, TestSize.Level0)
725 {
726 std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
727 std::vector<std::string> words = {"1", "2", "3", "4", "5", "^END"};
728 int elementPointer = 0;
729 int end = 5;
730 std::vector<int> ret = {1, 2, 3, 4, 5};
731 auto result = queryHelper->GetIntegerList(words, elementPointer, end);
732 EXPECT_EQ(result, ret);
733 elementPointer = 6;
734 ret = {};
735 result = queryHelper->GetIntegerList(words, elementPointer, end);
736 EXPECT_EQ(result, ret);
737
738 elementPointer = 0;
739 std::vector<int64_t> ret1 = {1, 2, 3, 4, 5};
740 auto result1 = queryHelper->GetLongList(words, elementPointer, end);
741 EXPECT_EQ(result1, ret1);
742 elementPointer = 6;
743 ret1 = {};
744 result1 = queryHelper->GetLongList(words, elementPointer, end);
745 EXPECT_EQ(result1, ret1);
746
747 elementPointer = 0;
748 std::vector<double> ret2 = {1, 2, 3, 4, 5};
749 auto result2 = queryHelper->GetDoubleList(words, elementPointer, end);
750 EXPECT_EQ(result2, ret2);
751 elementPointer = 6;
752 ret2 = {};
753 result2 = queryHelper->GetDoubleList(words, elementPointer, end);
754 EXPECT_EQ(result2, ret2);
755
756 std::vector<std::string> words1 = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
757 elementPointer = 0;
758 std::vector<std::string> ret3 = { "^NOT_IN", "INTEGER", "LONG", "^START", "STRING" };
759 auto result3 = queryHelper->GetStringList(words1, elementPointer, end);
760 EXPECT_EQ(result3, ret3);
761 elementPointer = 6;
762 ret3 = {};
763 result3 = queryHelper->GetStringList(words1, elementPointer, end);
764 EXPECT_EQ(result3, ret3);
765 }
766
767 /**
768 * @tc.name: AuthHandler
769 * @tc.desc: AuthHandler test the return result of input with different values.
770 * @tc.type: FUNC
771 * @tc.author: SQL
772 */
773 HWTEST_F(AuthHandlerTest, AuthHandler, TestSize.Level0)
774 {
775 int localUserId = 0;
776 int peerUserId = 0;
777 std::string peerDeviceId = "";
778 AclParams aclParams;
779 aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
780 auto result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
781 EXPECT_TRUE(result.first);
782
783 aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
784 result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
785 EXPECT_TRUE(result.first);
786
787 aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
788 peerDeviceId = "peerDeviceId";
789 result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
790 EXPECT_TRUE(result.first);
791
792 aclParams.authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
793 result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
794 EXPECT_TRUE(result.first);
795
796 localUserId = 1;
797 result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
798 EXPECT_FALSE(result.first);
799
800 peerUserId = 1;
801 result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, aclParams);
802 EXPECT_FALSE(result.first);
803 }
804 } // namespace DistributedDataTest
805 } // namespace OHOS::Test