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 #include <memory>
16 #include <sys/types.h>
17 #include <unistd.h>
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include "include/accesstoken_kit_mock.h"
23 #include "include/convertor_mock.h"
24 #include "include/dev_manager_mock.h"
25 #include "include/kvdb_notifier_client_mock.h"
26 #include "include/kvdb_service_client_mock.h"
27 #include "include/observer_bridge_mock.h"
28 #include "include/task_executor_mock.h"
29 #include "kvstore_observer.h"
30 #include "single_store_impl.h"
31 #include "store_factory.h"
32 #include "store_manager.h"
33
34 namespace OHOS::DistributedKv {
35 using namespace std;
36 using namespace testing;
37 using namespace DistributedDB;
38 using namespace Security::AccessToken;
39
40 static StoreId storeId = { "single_test" };
41 static AppId appId = { "rekey" };
42
43 class SingleStoreImplMockTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase();
47 void SetUp() override;
48 void TearDown() override;
49
50 public:
51 using DBStatus = DistributedDB::DBStatus;
52 using DBStore = DistributedDB::KvStoreNbDelegate;
53 using Observer = DistributedKv::KvStoreObserver;
54 static inline shared_ptr<DevManagerMock> devManagerMock = nullptr;
55 static inline shared_ptr<KVDBServiceClientMock> kVDBServiceClientMock = nullptr;
56 static inline shared_ptr<KVDBNotifierClientMock> kVDBNotifierClientMock = nullptr;
57 static inline shared_ptr<ObserverBridgeMock> observerBridgeMock = nullptr;
58 static inline shared_ptr<TaskExecutorMock> taskExecutorMock = nullptr;
59 static inline shared_ptr<AccessTokenKitMock> accessTokenKitMock = nullptr;
60 static inline shared_ptr<ConvertorMock> convertorMock = nullptr;
61 std::shared_ptr<SingleStoreImpl> CreateKVStore(bool autosync = false, bool backup = true);
62 };
63
SetUp()64 void SingleStoreImplMockTest::SetUp() { }
65
TearDown()66 void SingleStoreImplMockTest::TearDown() { }
67
SetUpTestCase()68 void SingleStoreImplMockTest::SetUpTestCase()
69 {
70 GTEST_LOG_(INFO) << "SetUpTestCase enter";
71 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
72 mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
73 devManagerMock = make_shared<DevManagerMock>();
74 BDevManager::devManager = devManagerMock;
75 kVDBServiceClientMock = make_shared<KVDBServiceClientMock>();
76 BKVDBServiceClient::kVDBServiceClient = kVDBServiceClientMock;
77 kVDBNotifierClientMock = make_shared<KVDBNotifierClientMock>();
78 BKVDBNotifierClient::kVDBNotifierClient = kVDBNotifierClientMock;
79 observerBridgeMock = make_shared<ObserverBridgeMock>();
80 BObserverBridge::observerBridge = observerBridgeMock;
81 taskExecutorMock = make_shared<TaskExecutorMock>();
82 BTaskExecutor::taskExecutor = taskExecutorMock;
83 accessTokenKitMock = make_shared<AccessTokenKitMock>();
84 BAccessTokenKit::accessTokenKit = accessTokenKitMock;
85 convertorMock = make_shared<ConvertorMock>();
86 BConvertor::convertor = convertorMock;
87 }
88
TearDownTestCase()89 void SingleStoreImplMockTest::TearDownTestCase()
90 {
91 GTEST_LOG_(INFO) << "TearDownTestCase enter";
92 BDevManager::devManager = nullptr;
93 devManagerMock = nullptr;
94 BKVDBServiceClient::kVDBServiceClient = nullptr;
95 kVDBServiceClientMock = nullptr;
96 BKVDBNotifierClient::kVDBNotifierClient = nullptr;
97 kVDBNotifierClientMock = nullptr;
98 BObserverBridge::observerBridge = nullptr;
99 observerBridgeMock = nullptr;
100 BTaskExecutor::taskExecutor = nullptr;
101 taskExecutorMock = nullptr;
102 BAccessTokenKit::accessTokenKit = nullptr;
103 accessTokenKitMock = nullptr;
104 BConvertor::convertor = nullptr;
105 convertorMock = nullptr;
106 std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
107 (void)remove("/data/service/el1/public/database/SingleStoreImplTest");
108 }
109
CreateKVStore(bool autosync,bool backup)110 std::shared_ptr<SingleStoreImpl> SingleStoreImplMockTest::CreateKVStore(bool autosync, bool backup)
111 {
112 AppId appId = { "SingleStoreImplTest" };
113 StoreId storeId = { "DestructorTest" };
114 std::shared_ptr<SingleStoreImpl> kvStore;
115 Options options;
116 options.kvStoreType = SINGLE_VERSION;
117 options.securityLevel = S2;
118 options.area = EL1;
119 options.autoSync = autosync;
120 options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
121 options.backup = backup;
122 StoreFactory storeFactory;
123 auto dbManager = storeFactory.GetDBManager(options.baseDir, appId);
124 auto dbPassword = SecurityManager::GetInstance().GetDBPassword(storeId.storeId, options.baseDir, options.encrypt);
125 DBStatus dbStatus = DBStatus::DB_ERROR;
126 dbManager->GetKvStore(storeId, storeFactory.GetDBOption(options, dbPassword),
127 [&dbManager, &kvStore, &appId, &dbStatus, &options, &storeFactory](auto status, auto *store) {
128 dbStatus = status;
129 if (store == nullptr) {
130 return;
131 }
132 auto release = [dbManager](auto *store) {
133 dbManager->CloseKvStore(store);
134 };
135 auto dbStore = std::shared_ptr<DBStore>(store, release);
136 storeFactory.SetDbConfig(dbStore);
137 const Convertor &convertor = *(storeFactory.convertors_[options.kvStoreType]);
138 kvStore = std::make_shared<SingleStoreImpl>(dbStore, appId, options, convertor);
139 });
140 return kvStore;
141 }
142
143 /**
144 * @tc.name: IsRemoteChanged
145 * @tc.desc: is remote changed.
146 * @tc.type: FUNC
147 * @tc.require:
148 * @tc.author: cao zhijun
149 */
150 HWTEST_F(SingleStoreImplMockTest, IsRemoteChanged, testing::ext::TestSize.Level1)
151 {
152 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin IsRemoteChanged";
153 try {
154 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).Times(1);
155 std::shared_ptr<SingleStoreImpl> kvStore;
156 kvStore = CreateKVStore();
157 ASSERT_NE(kvStore, nullptr);
158 std::shared_ptr<KVDBServiceClient> client = make_shared<KVDBServiceClient>(nullptr);
159 ASSERT_NE(client, nullptr);
160 EXPECT_CALL(*devManagerMock, ToUUID(_)).WillOnce(Return(""));
161 bool ret = kvStore->IsRemoteChanged("123456789");
162 EXPECT_TRUE(ret);
163
164 EXPECT_CALL(*devManagerMock, ToUUID(_)).WillOnce(Return("123456789"));
165 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
166 ret = kvStore->IsRemoteChanged("123456789");
167 EXPECT_TRUE(ret);
168
169 EXPECT_CALL(*devManagerMock, ToUUID(_)).WillOnce(Return("123456789"));
170 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(client));
171 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(nullptr));
172 ret = kvStore->IsRemoteChanged("123456789");
173 EXPECT_TRUE(ret);
174
175 sptr<KVDBNotifierClient> testAgent = new (std::nothrow) KVDBNotifierClient();
176 ASSERT_NE(testAgent, nullptr);
177 EXPECT_CALL(*devManagerMock, ToUUID(_)).WillOnce(Return("123456789"));
178 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(client));
179 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(testAgent));
180 EXPECT_CALL(*kVDBNotifierClientMock, IsChanged(_, _)).WillOnce(Return(true));
181 ret = kvStore->IsRemoteChanged("123456789");
182 EXPECT_TRUE(ret);
183 } catch (...) {
184 EXPECT_TRUE(false);
185 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by IsRemoteChanged.";
186 }
187 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end IsRemoteChanged";
188 }
189
190 /**
191 * @tc.name: OnRemoteDied
192 * @tc.desc: remote died.
193 * @tc.type: FUNC
194 * @tc.require:
195 * @tc.author: cao zhijun
196 */
197 HWTEST_F(SingleStoreImplMockTest, OnRemoteDied, testing::ext::TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin OnRemoteDied";
200 try {
201 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).Times(1);
202 EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_INVALID));
203 std::shared_ptr<SingleStoreImpl> kvStore;
204 kvStore = CreateKVStore(false, false);
205 ASSERT_NE(kvStore, nullptr);
206 EXPECT_NE(kvStore->dbStore_, nullptr);
207 EXPECT_FALSE(kvStore->isApplication_);
208
209 kvStore->taskId_ = 1;
210 kvStore->OnRemoteDied();
211
212 kvStore->taskId_ = 0;
213 shared_ptr<Observer> observer = make_shared<Observer>();
214 shared_ptr<Observer> observer1 = make_shared<Observer>();
215 Convertor cvt;
216 Convertor cvt1;
217 shared_ptr<ObserverBridge> obsBridge = make_shared<ObserverBridge>(appId, storeId, 0, observer, cvt);
218 shared_ptr<ObserverBridge> obsBridge1 = make_shared<ObserverBridge>(appId, storeId, 0, observer1, cvt1);
219
220 uint32_t firs = 0;
221 firs |= SUBSCRIBE_TYPE_REMOTE;
222 pair<uint32_t, std::shared_ptr<ObserverBridge>> one(0, obsBridge);
223 pair<uint32_t, std::shared_ptr<ObserverBridge>> two(firs, obsBridge1);
224
225 kvStore->observers_.Insert(uintptr_t(observer.get()), one);
226 kvStore->observers_.Insert(uintptr_t(observer1.get()), two);
227 EXPECT_CALL(*observerBridgeMock, OnServiceDeath()).Times(1);
228 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).WillOnce(Return(1));
229 kvStore->OnRemoteDied();
230 kvStore->observers_.Erase(uintptr_t(observer.get()));
231 kvStore->observers_.Erase(uintptr_t(observer1.get()));
232 EXPECT_TRUE(kvStore->taskId_ == 1);
233 } catch (...) {
234 EXPECT_TRUE(false);
235 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by OnRemoteDied.";
236 }
237 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end OnRemoteDied";
238 }
239
240 /**
241 * @tc.name: Register
242 * @tc.desc: register.
243 * @tc.type: FUNC
244 * @tc.require:
245 * @tc.author: cao zhijun
246 */
247 HWTEST_F(SingleStoreImplMockTest, Register, testing::ext::TestSize.Level1)
248 {
249 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Register";
250 try {
251 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).Times(1);
252 EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_HAP));
253 std::shared_ptr<SingleStoreImpl> kvStore;
254 kvStore = CreateKVStore(false, false);
255 ASSERT_NE(kvStore, nullptr);
256 EXPECT_NE(kvStore->dbStore_, nullptr);
257 EXPECT_TRUE(kvStore->isApplication_);
258
259 shared_ptr<Observer> observer = make_shared<Observer>();
260 shared_ptr<Observer> observer1 = make_shared<Observer>();
261 Convertor cvt;
262 Convertor cvt1;
263 shared_ptr<ObserverBridge> obsBridge = make_shared<ObserverBridge>(appId, storeId, 0, observer, cvt);
264 shared_ptr<ObserverBridge> obsBridge1 = make_shared<ObserverBridge>(appId, storeId, 0, observer1, cvt1);
265
266 uint32_t firs = 0;
267 firs |= SUBSCRIBE_TYPE_CLOUD;
268 pair<uint32_t, std::shared_ptr<ObserverBridge>> one(0, obsBridge);
269 pair<uint32_t, std::shared_ptr<ObserverBridge>> two(firs, obsBridge1);
270
271 kvStore->observers_.Insert(uintptr_t(observer.get()), one);
272 kvStore->observers_.Insert(uintptr_t(observer1.get()), two);
273 EXPECT_CALL(*observerBridgeMock, RegisterRemoteObserver(_)).WillOnce(Return(ERROR));
274 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).WillOnce(Return(1));
275 kvStore->Register();
276 EXPECT_TRUE(kvStore->taskId_ == 1);
277
278 EXPECT_CALL(*observerBridgeMock, RegisterRemoteObserver(_)).WillOnce(Return(SUCCESS));
279 kvStore->Register();
280 kvStore->observers_.Erase(uintptr_t(observer.get()));
281 kvStore->observers_.Erase(uintptr_t(observer1.get()));
282 EXPECT_TRUE(kvStore->taskId_ == 0);
283 } catch (...) {
284 EXPECT_TRUE(false);
285 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Register.";
286 }
287 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Register";
288 }
289
290 /**
291 * @tc.name: Put_001
292 * @tc.desc: Put.
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(SingleStoreImplMockTest, Put_001, testing::ext::TestSize.Level1)
297 {
298 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Put_001";
299 try {
300 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).Times(1);
301 EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).Times(AnyNumber());
302 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
303 ASSERT_NE(kvStore, nullptr);
304 EXPECT_NE(kvStore->dbStore_, nullptr);
305 std::vector<uint8_t> vect;
306 EXPECT_CALL(*convertorMock, ToLocalDBKey(_)).WillOnce(Return(vect));
307 size_t maxTestKeyLen = 10;
308 std::string str(maxTestKeyLen, 'a');
309 Blob key(str);
310 Blob value("test_value");
311 Status status = kvStore->Put(key, value);
312 EXPECT_TRUE(status == INVALID_ARGUMENT);
313 } catch (...) {
314 EXPECT_TRUE(false);
315 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Put_001.";
316 }
317 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Put_001";
318 }
319
320
321 /**
322 * @tc.name: Put_002
323 * @tc.desc: Put.
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(SingleStoreImplMockTest, Put_002, testing::ext::TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Put_002";
330 try {
331 EXPECT_CALL(*taskExecutorMock, Schedule(_, _, _, _)).Times(AnyNumber());
332 EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).Times(AnyNumber());
333 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
334 ASSERT_NE(kvStore, nullptr);
335 EXPECT_NE(kvStore->dbStore_, nullptr);
336 std::vector<uint8_t> vect{3, 8};
337 EXPECT_CALL(*convertorMock, ToLocalDBKey(_)).WillOnce(Return(vect));
338 size_t overlongTestKeyLen = 4 * 1024 * 1024 + 1;
339 std::string str(overlongTestKeyLen, 'b');
340 Blob key1("key1");
341 Blob value1(str);
342 Status status = kvStore->Put(key1, value1);
343 EXPECT_TRUE(status == INVALID_ARGUMENT);
344 } catch (...) {
345 EXPECT_TRUE(false);
346 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Put_002.";
347 }
348 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Put_002";
349 }
350
351 /**
352 * @tc.name: PutBatch_001
353 * @tc.desc: PutBatch.
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(SingleStoreImplMockTest, PutBatch_001, testing::ext::TestSize.Level1)
358 {
359 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin PutBatch_001";
360 try {
361 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
362 ASSERT_NE(kvStore, nullptr);
363 EXPECT_NE(kvStore->dbStore_, nullptr);
364 kvStore->dbStore_ = nullptr;
365 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
366 std::vector<Entry> in;
367 for (int i = 0; i < 2; ++i) {
368 Entry entry;
369 entry.key = std::to_string(i).append("_k");
370 entry.value = std::to_string(i).append("_v");
371 in.emplace_back(entry);
372 }
373 Status status = kvStore->PutBatch(in);
374 EXPECT_TRUE(status == ALREADY_CLOSED);
375 } catch (...) {
376 EXPECT_TRUE(false);
377 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by PutBatch_001.";
378 }
379 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end PutBatch_001";
380 }
381
382 /**
383 * @tc.name: PutBatch_002
384 * @tc.desc: PutBatch.
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(SingleStoreImplMockTest, PutBatch_002, testing::ext::TestSize.Level1)
389 {
390 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin PutBatch_002";
391 try {
392 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
393 ASSERT_NE(kvStore, nullptr);
394 EXPECT_NE(kvStore->dbStore_, nullptr);
395 std::vector<Entry> in;
396 for (int i = 0; i < 2; ++i) {
397 Entry entry;
398 entry.key = std::to_string(i).append("_key");
399 entry.value = std::to_string(i).append("_val");
400 in.emplace_back(entry);
401 }
402 std::vector<uint8_t> vect;
403 EXPECT_CALL(*convertorMock, ToLocalDBKey(_)).WillOnce(Return(vect));
404 Status status = kvStore->PutBatch(in);
405 EXPECT_TRUE(status == INVALID_ARGUMENT);
406 } catch (...) {
407 EXPECT_TRUE(false);
408 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by PutBatch_002.";
409 }
410 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end PutBatch_002";
411 }
412
413 /**
414 * @tc.name: PutBatch_003
415 * @tc.desc: PutBatch.
416 * @tc.type: FUNC
417 * @tc.require:
418 */
419 HWTEST_F(SingleStoreImplMockTest, PutBatch_003, testing::ext::TestSize.Level1)
420 {
421 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin PutBatch_003";
422 try {
423 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
424 ASSERT_NE(kvStore, nullptr);
425 EXPECT_NE(kvStore->dbStore_, nullptr);
426 std::vector<Entry> in;
427 for (int i = 0; i < 2; ++i) {
428 Entry entry;
429 entry.key = std::to_string(i).append("_key");
430 entry.value = std::to_string(i).append("_val");
431 in.emplace_back(entry);
432 }
433 std::vector<uint8_t> vect;
434 EXPECT_CALL(*convertorMock, ToLocalDBKey(_)).WillOnce(Return(vect));
435 Status status = kvStore->PutBatch(in);
436 EXPECT_TRUE(status == INVALID_ARGUMENT);
437 } catch (...) {
438 EXPECT_TRUE(false);
439 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by PutBatch_003.";
440 }
441 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end PutBatch_003";
442 }
443
444 /**
445 * @tc.name: Delete
446 * @tc.desc: Delete Key.
447 * @tc.type: FUNC
448 * @tc.require:
449 */
450 HWTEST_F(SingleStoreImplMockTest, Delete, testing::ext::TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Delete";
453 try {
454 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
455 ASSERT_NE(kvStore, nullptr);
456 EXPECT_NE(kvStore->dbStore_, nullptr);
457 kvStore->dbStore_= nullptr;
458 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
459 Blob key1("key1");
460 Status status = kvStore->Delete(key1);
461 EXPECT_TRUE(status == ALREADY_CLOSED);
462 } catch (...) {
463 EXPECT_TRUE(false);
464 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Delete.";
465 }
466 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Delete";
467 }
468
469 /**
470 * @tc.name: DeleteBatch
471 * @tc.desc: DeleteBatch Keys.
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475 HWTEST_F(SingleStoreImplMockTest, DeleteBatch, testing::ext::TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin DeleteBatch";
478 try {
479 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
480 ASSERT_NE(kvStore, nullptr);
481 EXPECT_NE(kvStore->dbStore_, nullptr);
482 kvStore->dbStore_= nullptr;
483 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
484 std::vector<Key> keys;
485 for (int i = 0; i < 2; ++i) {
486 Key key = std::to_string(i).append("_k");
487 keys.emplace_back(key);
488 }
489 Status status = kvStore->DeleteBatch(keys);
490 EXPECT_TRUE(status == ALREADY_CLOSED);
491 } catch (...) {
492 EXPECT_TRUE(false);
493 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by DeleteBatch.";
494 }
495 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end DeleteBatch";
496 }
497
498 /**
499 * @tc.name: StartTransaction
500 * @tc.desc: Start Transaction.
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(SingleStoreImplMockTest, StartTransaction, testing::ext::TestSize.Level1)
505 {
506 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin StartTransaction";
507 try {
508 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
509 ASSERT_NE(kvStore, nullptr);
510 EXPECT_NE(kvStore->dbStore_, nullptr);
511 kvStore->dbStore_= nullptr;
512 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
513 Status status = kvStore->StartTransaction();
514 EXPECT_TRUE(status == ALREADY_CLOSED);
515 } catch (...) {
516 EXPECT_TRUE(false);
517 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by StartTransaction.";
518 }
519 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end StartTransaction";
520 }
521
522 /**
523 * @tc.name: Commit
524 * @tc.desc: Commit.
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(SingleStoreImplMockTest, Commit, testing::ext::TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Commit";
531 try {
532 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
533 ASSERT_NE(kvStore, nullptr);
534 EXPECT_NE(kvStore->dbStore_, nullptr);
535 kvStore->dbStore_= nullptr;
536 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
537 Status status = kvStore->Commit();
538 EXPECT_TRUE(status == ALREADY_CLOSED);
539 } catch (...) {
540 EXPECT_TRUE(false);
541 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Commit.";
542 }
543 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Commit";
544 }
545
546 /**
547 * @tc.name: Rollback
548 * @tc.desc: Rollback kvstore.
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(SingleStoreImplMockTest, Rollback, testing::ext::TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Rollback";
555 try {
556 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
557 ASSERT_NE(kvStore, nullptr);
558 EXPECT_NE(kvStore->dbStore_, nullptr);
559 kvStore->dbStore_= nullptr;
560 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
561 Status status = kvStore->Rollback();
562 EXPECT_TRUE(status == ALREADY_CLOSED);
563 } catch (...) {
564 EXPECT_TRUE(false);
565 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Rollback.";
566 }
567 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Rollback";
568 }
569
570 /**
571 * @tc.name: Get
572 * @tc.desc: Get.
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(SingleStoreImplMockTest, Get, testing::ext::TestSize.Level1)
577 {
578 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Get";
579 try {
580 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
581 ASSERT_NE(kvStore, nullptr);
582 EXPECT_NE(kvStore->dbStore_, nullptr);
583 kvStore->dbStore_= nullptr;
584 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
585 size_t testKeyLen = 10;
586 std::string str(testKeyLen, 'a');
587 Blob key(str);
588 Blob value("test_value");
589 Status status = kvStore->Get(key, value);
590 EXPECT_TRUE(status == ALREADY_CLOSED);
591 } catch (...) {
592 EXPECT_TRUE(false);
593 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Get.";
594 }
595 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Get";
596 }
597
598 /**
599 * @tc.name: GetEntries_001
600 * @tc.desc: Get Entries.
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(SingleStoreImplMockTest, GetEntries_001, testing::ext::TestSize.Level1)
605 {
606 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetEntries_001";
607 try {
608 std::vector<uint8_t> vct;
609 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
610 ASSERT_NE(kvStore, nullptr);
611 EXPECT_NE(kvStore->dbStore_, nullptr);
612 EXPECT_CALL(*convertorMock, GetPrefix(An<const Key&>())).WillOnce(Return(vct));
613 Blob key("test");
614 std::vector<Entry> vecs;
615 for (int i = 0; i < 2; ++i) {
616 Entry entry;
617 entry.key = std::to_string(i).append("_key");
618 entry.value = std::to_string(i).append("_val");
619 vecs.emplace_back(entry);
620 }
621 Status status = kvStore->GetEntries(key, vecs);
622 EXPECT_TRUE(status == INVALID_ARGUMENT);
623 } catch (...) {
624 EXPECT_TRUE(false);
625 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetEntries_001.";
626 }
627 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetEntries_001";
628 }
629
630 /**
631 * @tc.name: GetDeviceEntries
632 * @tc.desc: Get device entries.
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(SingleStoreImplMockTest, GetDeviceEntries, testing::ext::TestSize.Level1)
637 {
638 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetDeviceEntries";
639 try {
640 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
641 ASSERT_NE(kvStore, nullptr);
642 EXPECT_NE(kvStore->dbStore_, nullptr);
643 kvStore->dbStore_= nullptr;
644 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
645 std::vector<Entry> vcs;
646 for (int i = 0; i < 2; ++i) {
647 Entry entry;
648 entry.key = std::to_string(i).append("_key");
649 entry.value = std::to_string(i).append("_val");
650 vcs.emplace_back(entry);
651 }
652 std::string device = "test device";
653 Status status = kvStore->GetDeviceEntries(device, vcs);
654 EXPECT_TRUE(status == ALREADY_CLOSED);
655 } catch (...) {
656 EXPECT_TRUE(false);
657 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetDeviceEntries.";
658 }
659 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetDeviceEntries";
660 }
661
662 /**
663 * @tc.name: GetCount
664 * @tc.desc: Get count.
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 HWTEST_F(SingleStoreImplMockTest, GetCount, testing::ext::TestSize.Level1)
669 {
670 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetCount";
671 try {
672 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
673 ASSERT_NE(kvStore, nullptr);
674 EXPECT_NE(kvStore->dbStore_, nullptr);
675 kvStore->dbStore_= nullptr;
676 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
677 DataQuery query;
678 int cnt = 0;
679 Status status = kvStore->GetCount(query, cnt);
680 EXPECT_TRUE(status == ALREADY_CLOSED);
681 } catch (...) {
682 EXPECT_TRUE(false);
683 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetCount.";
684 }
685 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetCount";
686 }
687
688 /**
689 * @tc.name: GetCount
690 * @tc.desc: Get count.
691 * @tc.type: FUNC
692 * @tc.require:
693 */
694 HWTEST_F(SingleStoreImplMockTest, GetSecurityLevel, testing::ext::TestSize.Level1)
695 {
696 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetSecurityLevel";
697 try {
698 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
699 ASSERT_NE(kvStore, nullptr);
700 EXPECT_NE(kvStore->dbStore_, nullptr);
701 kvStore->dbStore_= nullptr;
702 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
703 SecurityLevel securityLevel = NO_LABEL;
704 Status status = kvStore->GetSecurityLevel(securityLevel);
705 EXPECT_TRUE(status == ALREADY_CLOSED);
706 } catch (...) {
707 EXPECT_TRUE(false);
708 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetSecurityLevel.";
709 }
710 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetSecurityLevel";
711 }
712
713 /**
714 * @tc.name: RemoveDeviceData_001
715 * @tc.desc: Remove device data.
716 * @tc.type: FUNC
717 * @tc.require:
718 */
719 HWTEST_F(SingleStoreImplMockTest, RemoveDeviceData_001, testing::ext::TestSize.Level1)
720 {
721 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin RemoveDeviceData_001";
722 try {
723 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
724 ASSERT_NE(kvStore, nullptr);
725 EXPECT_NE(kvStore->dbStore_, nullptr);
726 kvStore->dbStore_= nullptr;
727 EXPECT_TRUE(kvStore->dbStore_ == nullptr);
728 Status status = kvStore->RemoveDeviceData("testdevice");
729 EXPECT_TRUE(status == ALREADY_CLOSED);
730 } catch (...) {
731 EXPECT_TRUE(false);
732 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by RemoveDeviceData_001.";
733 }
734 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end RemoveDeviceData_001";
735 }
736
737 /**
738 * @tc.name: RemoveDeviceData_002
739 * @tc.desc: Remove device data.
740 * @tc.type: FUNC
741 * @tc.require:
742 */
743 HWTEST_F(SingleStoreImplMockTest, RemoveDeviceData_002, testing::ext::TestSize.Level1)
744 {
745 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin RemoveDeviceData_002";
746 try {
747 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
748 ASSERT_NE(kvStore, nullptr);
749 EXPECT_NE(kvStore->dbStore_, nullptr);
750 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
751 Status status = kvStore->RemoveDeviceData("testdevice");
752 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
753 } catch (...) {
754 EXPECT_TRUE(false);
755 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by RemoveDeviceData_002.";
756 }
757 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end RemoveDeviceData_002";
758 }
759
760 /**
761 * @tc.name: CloudSync_001
762 * @tc.desc: Cloud sync.
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(SingleStoreImplMockTest, CloudSync_001, testing::ext::TestSize.Level1)
767 {
768 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin CloudSync_001";
769 try {
770 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
771 ASSERT_NE(kvStore, nullptr);
772 EXPECT_NE(kvStore->dbStore_, nullptr);
773 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
774 AsyncDetail asyncDetail;
775 Status status = kvStore->CloudSync(asyncDetail);
776 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
777 } catch (...) {
778 EXPECT_TRUE(false);
779 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by CloudSync_001.";
780 }
781 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end CloudSync_001";
782 }
783
784 /**
785 * @tc.name: CloudSync_002
786 * @tc.desc: Cloud sync.
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(SingleStoreImplMockTest, CloudSync_002, testing::ext::TestSize.Level1)
791 {
792 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin CloudSync_002";
793 try {
794 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
795 ASSERT_NE(kvStore, nullptr);
796 EXPECT_NE(kvStore->dbStore_, nullptr);
797 std::shared_ptr<KVDBServiceClient> ser = make_shared<KVDBServiceClient>(nullptr);
798 ASSERT_NE(ser, nullptr);
799 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(ser));
800 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(nullptr));
801 AsyncDetail asyncDetail;
802 Status status = kvStore->CloudSync(asyncDetail);
803 EXPECT_TRUE(status == ILLEGAL_STATE);
804 } catch (...) {
805 EXPECT_TRUE(false);
806 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by CloudSync_002.";
807 }
808 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end CloudSync_002";
809 }
810
811 /**
812 * @tc.name: SetSyncParam
813 * @tc.desc: Set sync param.
814 * @tc.type: FUNC
815 * @tc.require:
816 */
817 HWTEST_F(SingleStoreImplMockTest, SetSyncParam, testing::ext::TestSize.Level1)
818 {
819 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SetSyncParam";
820 try {
821 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
822 ASSERT_NE(kvStore, nullptr);
823 EXPECT_NE(kvStore->dbStore_, nullptr);
824 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
825 KvSyncParam syncParam{ 500 };
826 Status status = kvStore->SetSyncParam(syncParam);
827 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
828 } catch (...) {
829 EXPECT_TRUE(false);
830 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SetSyncParam.";
831 }
832 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SetSyncParam";
833 }
834
835 /**
836 * @tc.name: GetSyncParam
837 * @tc.desc: Get sync param.
838 * @tc.type: FUNC
839 * @tc.require:
840 */
841 HWTEST_F(SingleStoreImplMockTest, GetSyncParam, testing::ext::TestSize.Level1)
842 {
843 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetSyncParam";
844 try {
845 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
846 ASSERT_NE(kvStore, nullptr);
847 EXPECT_NE(kvStore->dbStore_, nullptr);
848 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
849 KvSyncParam syncParam;
850 Status status = kvStore->GetSyncParam(syncParam);
851 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
852 } catch (...) {
853 EXPECT_TRUE(false);
854 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetSyncParam.";
855 }
856 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetSyncParam";
857 }
858
859 /**
860 * @tc.name: SetCapabilityEnabled_001
861 * @tc.desc: Set capability enabled.
862 * @tc.type: FUNC
863 * @tc.require:
864 */
865 HWTEST_F(SingleStoreImplMockTest, SetCapabilityEnabled_001, testing::ext::TestSize.Level1)
866 {
867 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SetCapabilityEnabled_001";
868 try {
869 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
870 ASSERT_NE(kvStore, nullptr);
871 EXPECT_NE(kvStore->dbStore_, nullptr);
872 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
873 Status status = kvStore->SetCapabilityEnabled(false);
874 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
875 } catch (...) {
876 EXPECT_TRUE(false);
877 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SetCapabilityEnabled_001.";
878 }
879 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SetCapabilityEnabled_001";
880 }
881
882 /**
883 * @tc.name: SetCapabilityEnabled_002
884 * @tc.desc: Set capability enabled.
885 * @tc.type: FUNC
886 * @tc.require:
887 */
888 HWTEST_F(SingleStoreImplMockTest, SetCapabilityEnabled_002, testing::ext::TestSize.Level1)
889 {
890 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SetCapabilityEnabled_002";
891 try {
892 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
893 ASSERT_NE(kvStore, nullptr);
894 EXPECT_NE(kvStore->dbStore_, nullptr);
895 std::shared_ptr<KVDBServiceClient> service = make_shared<KVDBServiceClient>(nullptr);
896 ASSERT_NE(service, nullptr);
897 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(service));
898 Status status = kvStore->SetCapabilityEnabled(true);
899 EXPECT_TRUE(status == ERROR);
900 } catch (...) {
901 EXPECT_TRUE(false);
902 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SetCapabilityEnabled_002.";
903 }
904 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SetCapabilityEnabled_002";
905 }
906
907 /**
908 * @tc.name: SetCapabilityRange
909 * @tc.desc: Set capability range.
910 * @tc.type: FUNC
911 * @tc.require:
912 */
913 HWTEST_F(SingleStoreImplMockTest, SetCapabilityRange, testing::ext::TestSize.Level1)
914 {
915 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SetCapabilityRange";
916 try {
917 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
918 ASSERT_NE(kvStore, nullptr);
919 EXPECT_NE(kvStore->dbStore_, nullptr);
920 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
921 std::vector<std::string> localLabels{"local", "near"};
922 std::vector<std::string> remoteLabels{"remote", "far"};
923 Status status = kvStore->SetCapabilityRange(localLabels, remoteLabels);
924 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
925 } catch (...) {
926 EXPECT_TRUE(false);
927 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SetCapabilityRange.";
928 }
929 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SetCapabilityRange";
930 }
931
932 /**
933 * @tc.name: SubscribeWithQuery_001
934 * @tc.desc: Subscribe with query.
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(SingleStoreImplMockTest, SubscribeWithQuery_001, testing::ext::TestSize.Level1)
939 {
940 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SubscribeWithQuery_001";
941 try {
942 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
943 ASSERT_NE(kvStore, nullptr);
944 EXPECT_NE(kvStore->dbStore_, nullptr);
945 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
946 std::vector<std::string> devices{"dev1", "dev2"};
947 DataQuery query;
948 Status status = kvStore->SubscribeWithQuery(devices, query);
949 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
950 } catch (...) {
951 EXPECT_TRUE(false);
952 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SubscribeWithQuery_001";
953 }
954 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SubscribeWithQuery_001";
955 }
956
957 /**
958 * @tc.name: SubscribeWithQuery_002
959 * @tc.desc: Subscribe with query.
960 * @tc.type: FUNC
961 * @tc.require:
962 */
963 HWTEST_F(SingleStoreImplMockTest, SubscribeWithQuery_002, testing::ext::TestSize.Level1)
964 {
965 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SubscribeWithQuery_002";
966 try {
967 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
968 ASSERT_NE(kvStore, nullptr);
969 EXPECT_NE(kvStore->dbStore_, nullptr);
970 std::shared_ptr<KVDBServiceClient> serv = make_shared<KVDBServiceClient>(nullptr);
971 ASSERT_NE(serv, nullptr);
972 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(serv));
973 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(nullptr));
974 std::vector<std::string> devices{"dev0", "dev1"};
975 DataQuery query;
976 Status status = kvStore->SubscribeWithQuery(devices, query);
977 EXPECT_TRUE(status == ILLEGAL_STATE);
978 } catch (...) {
979 EXPECT_TRUE(false);
980 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SubscribeWithQuery_002";
981 }
982 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SubscribeWithQuery_002";
983 }
984
985 /**
986 * @tc.name: UnsubscribeWithQuery_001
987 * @tc.desc: Unsubscribe with query.
988 * @tc.type: FUNC
989 * @tc.require:
990 */
991 HWTEST_F(SingleStoreImplMockTest, UnsubscribeWithQuery_001, testing::ext::TestSize.Level1)
992 {
993 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin UnsubscribeWithQuery_001";
994 try {
995 std::shared_ptr<SingleStoreImpl> kvStore = CreateKVStore(false, false);
996 ASSERT_NE(kvStore, nullptr);
997 EXPECT_NE(kvStore->dbStore_, nullptr);
998 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
999 std::vector<std::string> devs{"dev0", "dev1"};
1000 DataQuery quer;
1001 Status status = kvStore->UnsubscribeWithQuery(devs, quer);
1002 EXPECT_TRUE(status == SERVER_UNAVAILABLE);
1003 } catch (...) {
1004 EXPECT_TRUE(false);
1005 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by UnsubscribeWithQuery_001";
1006 }
1007 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end UnsubscribeWithQuery_001";
1008 }
1009
1010 /**
1011 * @tc.name: UnsubscribeWithQuery_002
1012 * @tc.desc: Unsubscribe with query.
1013 * @tc.type: FUNC
1014 * @tc.require:
1015 */
1016 HWTEST_F(SingleStoreImplMockTest, UnsubscribeWithQuery_002, testing::ext::TestSize.Level1)
1017 {
1018 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin UnsubscribeWithQuery_002";
1019 try {
1020 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1021 ASSERT_NE(kv, nullptr);
1022 EXPECT_NE(kv->dbStore_, nullptr);
1023 std::shared_ptr<KVDBServiceClient> serv = make_shared<KVDBServiceClient>(nullptr);
1024 ASSERT_NE(serv, nullptr);
1025 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(serv));
1026 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(nullptr));
1027 std::vector<std::string> devs{"dev3", "dev4"};
1028 DataQuery quer;
1029 Status status = kv->UnsubscribeWithQuery(devs, quer);
1030 EXPECT_TRUE(status == ILLEGAL_STATE);
1031 } catch (...) {
1032 EXPECT_TRUE(false);
1033 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by UnsubscribeWithQuery_002";
1034 }
1035 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end UnsubscribeWithQuery_002";
1036 }
1037
1038 /**
1039 * @tc.name: Restore_001
1040 * @tc.desc: restore kv.
1041 * @tc.type: FUNC
1042 * @tc.require:
1043 */
1044 HWTEST_F(SingleStoreImplMockTest, Restore_001, testing::ext::TestSize.Level1)
1045 {
1046 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Restore_001";
1047 try {
1048 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1049 ASSERT_NE(kv, nullptr);
1050 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
1051 std::string baseDirect = "/data/service/el1/public/database/SingleStoreImplTest";
1052 std::string file = "test.txt";
1053 kv->isApplication_ = false;
1054 Status status = kv->Restore(file, baseDirect);
1055 EXPECT_TRUE(status != SUCCESS);
1056 } catch (...) {
1057 EXPECT_TRUE(false);
1058 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Restore_001";
1059 }
1060 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Restore_001";
1061 }
1062
1063 /**
1064 * @tc.name: Restore_002
1065 * @tc.desc: restore kv.
1066 * @tc.type: FUNC
1067 * @tc.require:
1068 */
1069 HWTEST_F(SingleStoreImplMockTest, Restore_002, testing::ext::TestSize.Level1)
1070 {
1071 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin Restore_002";
1072 try {
1073 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1074 ASSERT_NE(kv, nullptr);
1075 std::shared_ptr<KVDBServiceClient> serv = make_shared<KVDBServiceClient>(nullptr);
1076 ASSERT_NE(serv, nullptr);
1077 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(serv));
1078 std::string baseDirect = "/data/service/el1/public/database/SingleStoreImplTest";
1079 std::string file = "test1.txt";
1080 kv->isApplication_ = true;
1081 kv->apiVersion_ = 15; // version
1082 Status status = kv->Restore(file, baseDirect);
1083 EXPECT_TRUE(status != SUCCESS);
1084 } catch (...) {
1085 EXPECT_TRUE(false);
1086 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by Restore_002";
1087 }
1088 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end Restore_002";
1089 }
1090
1091 /**
1092 * @tc.name: GetResultSet
1093 * @tc.desc: Get result Set.
1094 * @tc.type: FUNC
1095 * @tc.require:
1096 */
1097 HWTEST_F(SingleStoreImplMockTest, GetResultSet, testing::ext::TestSize.Level1)
1098 {
1099 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetResultSet";
1100 try {
1101 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1102 ASSERT_NE(kv, nullptr);
1103 kv->dbStore_= nullptr;
1104 EXPECT_TRUE(kv->dbStore_ == nullptr);
1105 SingleStoreImpl::DBQuery dbQuer;
1106 std::shared_ptr<KvStoreResultSet> output;
1107 Status status = kv->GetResultSet(dbQuer, output);
1108 EXPECT_TRUE(status == ALREADY_CLOSED);
1109 } catch (...) {
1110 EXPECT_TRUE(false);
1111 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetResultSet";
1112 }
1113 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetResultSet";
1114 }
1115
1116 /**
1117 * @tc.name: GetEntries
1118 * @tc.desc: Get entries.
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(SingleStoreImplMockTest, GetEntries, testing::ext::TestSize.Level1)
1123 {
1124 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin GetEntries";
1125 try {
1126 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1127 ASSERT_NE(kv, nullptr);
1128 kv->dbStore_= nullptr;
1129 EXPECT_TRUE(kv->dbStore_ == nullptr);
1130 std::vector<Entry> vects;
1131 SingleStoreImpl::DBQuery dbQuer;
1132 Status status = kv->GetEntries(dbQuer, vects);
1133 EXPECT_TRUE(status == ALREADY_CLOSED);
1134 } catch (...) {
1135 EXPECT_TRUE(false);
1136 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by GetEntries";
1137 }
1138 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end GetEntries";
1139 }
1140
1141 /**
1142 * @tc.name: DoSync_001
1143 * @tc.desc: do sync.
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 */
1147 HWTEST_F(SingleStoreImplMockTest, DoSync_001, testing::ext::TestSize.Level1)
1148 {
1149 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin DoSync_001";
1150 try {
1151 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1152 ASSERT_NE(kv, nullptr);
1153 kv->isClientSync_ = false;
1154 ASSERT_FALSE(kv->isClientSync_);
1155 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
1156 SingleStoreImpl::SyncInfo syInfo;
1157 std::shared_ptr<SingleStoreImpl::SyncCallback> obser;
1158 auto res = kv->DoSync(syInfo, obser);
1159 EXPECT_TRUE(res == SERVER_UNAVAILABLE);
1160 } catch (...) {
1161 EXPECT_TRUE(false);
1162 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by DoSync_001";
1163 }
1164 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end DoSync_001";
1165 }
1166
1167 /**
1168 * @tc.name: DoSync_002
1169 * @tc.desc: do sync.
1170 * @tc.type: FUNC
1171 * @tc.require:
1172 */
1173 HWTEST_F(SingleStoreImplMockTest, DoSync_002, testing::ext::TestSize.Level1)
1174 {
1175 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin DoSync_002";
1176 try {
1177 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1178 ASSERT_NE(kv, nullptr);
1179 kv->isClientSync_ = false;
1180 std::shared_ptr<KVDBServiceClient> servic = make_shared<KVDBServiceClient>(nullptr);
1181 ASSERT_NE(servic, nullptr);
1182 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(servic));
1183 EXPECT_CALL(*kVDBServiceClientMock, GetServiceAgent(_)).WillOnce(Return(nullptr));
1184 SingleStoreImpl::SyncInfo syInfo;
1185 std::shared_ptr<SingleStoreImpl::SyncCallback> observer;
1186 auto res = kv->DoSync(syInfo, observer);
1187 EXPECT_TRUE(res == ILLEGAL_STATE);
1188 } catch (...) {
1189 EXPECT_TRUE(false);
1190 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by DoSync_002";
1191 }
1192 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end DoSync_002";
1193 }
1194
1195 /**
1196 * @tc.name: SetConfig
1197 * @tc.desc: set config.
1198 * @tc.type: FUNC
1199 * @tc.require:
1200 */
1201 HWTEST_F(SingleStoreImplMockTest, SetConfig, testing::ext::TestSize.Level1)
1202 {
1203 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin SetConfig";
1204 try {
1205 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1206 ASSERT_NE(kv, nullptr);
1207 EXPECT_CALL(*kVDBServiceClientMock, GetInstance()).WillOnce(Return(nullptr));
1208 StoreConfig storeConfig;
1209 auto res = kv->SetConfig(storeConfig);
1210 EXPECT_TRUE(res == SERVER_UNAVAILABLE);
1211 } catch (...) {
1212 EXPECT_TRUE(false);
1213 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by SetConfig";
1214 }
1215 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end SetConfig";
1216 }
1217
1218 /**
1219 * @tc.name: DoNotifyChange
1220 * @tc.desc: Do notify change.
1221 * @tc.type: FUNC
1222 * @tc.require:
1223 */
1224 HWTEST_F(SingleStoreImplMockTest, DoNotifyChange, testing::ext::TestSize.Level1)
1225 {
1226 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin DoNotifyChange";
1227 try {
1228 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1229 ASSERT_NE(kv, nullptr);
1230 kv->cloudAutoSync_ = false;
1231 kv->DoNotifyChange();
1232 EXPECT_TRUE(!kv->cloudAutoSync_);
1233 } catch (...) {
1234 EXPECT_TRUE(false);
1235 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by DoNotifyChange";
1236 }
1237 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end DoNotifyChange";
1238 }
1239
1240 /**
1241 * @tc.name: IsRebuild
1242 * @tc.desc: is rebuild.
1243 * @tc.type: FUNC
1244 * @tc.require:
1245 */
1246 HWTEST_F(SingleStoreImplMockTest, IsRebuild, testing::ext::TestSize.Level1)
1247 {
1248 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-begin IsRebuild";
1249 try {
1250 std::shared_ptr<SingleStoreImpl> kv = CreateKVStore(false, false);
1251 ASSERT_NE(kv, nullptr);
1252 kv->dbStore_= nullptr;
1253 EXPECT_TRUE(kv->dbStore_ == nullptr);
1254 auto res = kv->IsRebuild();
1255 EXPECT_FALSE(res);
1256 } catch (...) {
1257 EXPECT_TRUE(false);
1258 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-an exception occurred by IsRebuild";
1259 }
1260 GTEST_LOG_(INFO) << "SingleStoreImplMockTest-end IsRebuild";
1261 }
1262 } // namespace OHOS::DistributedKv