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 <string>
17
18 #include "lnn_kv_adapter.h"
19 #include "lnn_kv_data_change_listener.h"
20 #include "softbus_error_code.h"
21 #include "gtest/gtest.h"
22 #include "lnn_parameter_utils.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace OHOS {
28
29 namespace {
30 const std::string APP_ID = "dsoftbus";
31 const std::string STORE_ID = "dsoftbus_kv_db_test";
32 shared_ptr<KVAdapter> kvStore = nullptr;
33 shared_ptr<DistributedKv::KvStoreObserver> kvStoreObserver = nullptr;
34 constexpr int32_t MAX_STRING_LEN = 4096;
35 constexpr int32_t MAX_MAP_SIZE = 10000;
36 const std::string DATABASE_DIR = "/data/service/el1/public/database/dsoftbus";
37 } // namespace
38
39 class KVAdapterTest : public testing::Test {
40 protected:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void KVAdapterTest::SetUpTestCase(void)
48 {
49 kvStore = make_shared<KVAdapter>(APP_ID, STORE_ID);
50 }
51
TearDownTestCase(void)52 void KVAdapterTest::TearDownTestCase(void) { }
53
SetUp()54 void KVAdapterTest::SetUp()
55 {
56 kvStore->Init();
57 }
58
TearDown()59 void KVAdapterTest::TearDown()
60 {
61 kvStore->DeInit();
62 }
63
64 /**
65 * @tc.name: Init001
66 * @tc.desc: Init succeed.
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70 HWTEST_F(KVAdapterTest, Init001, TestSize.Level1)
71 {
72 kvStore->DeInit();
73 EXPECT_EQ(SOFTBUS_OK, kvStore->Init());
74 }
75
76 /**
77 * @tc.name: UnInit001
78 * @tc.desc: UnInit succeed.
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(KVAdapterTest, UnInit001, TestSize.Level1)
83 {
84 EXPECT_EQ(SOFTBUS_OK, kvStore->DeInit());
85 }
86
87 /**
88 * @tc.name: Put001
89 * @tc.desc: Put succeed.
90 * @tc.type: FUNC
91 * @tc.require:
92 */
93 HWTEST_F(KVAdapterTest, Put001, TestSize.Level1)
94 {
95 EXPECT_EQ(SOFTBUS_OK, kvStore->Put("key1", "value1"));
96 }
97
98 /**
99 * @tc.name: Put002
100 * @tc.desc: Put failed, Param is invalid.
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(KVAdapterTest, Put002, TestSize.Level1)
105 {
106 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put("", "value1"));
107 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put("key1", ""));
108 }
109
110 /**
111 * @tc.name: Put003
112 * @tc.desc: Put failed, kvDBPtr is null.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(KVAdapterTest, Put003, TestSize.Level1)
117 {
118 kvStore->DeInit();
119 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Put("key1", "value1"));
120 }
121
122 /**
123 * @tc.name: Put004
124 * @tc.desc: Put first if.
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(KVAdapterTest, Put004, TestSize.Level1)
129 {
130 string key = "key";
131 string value = "value";
132 EXPECT_EQ(SOFTBUS_OK, kvStore->Put(key, value));
133
134 for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
135 value += 'a';
136 }
137 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
138
139 value = "";
140 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
141
142 for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
143 key += 'a';
144 }
145 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
146
147 key = "";
148 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
149 }
150
151 /**
152 * @tc.name: PutBatch001
153 * @tc.desc: PutBatch succeed.
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(KVAdapterTest, PutBatch001, TestSize.Level1)
158 {
159 map<string, string> values;
160 values.insert(pair<string, string>("key2", "value2"));
161 values.insert(pair<string, string>("key3", "value3"));
162 EXPECT_EQ(SOFTBUS_OK, kvStore->PutBatch(values));
163 }
164
165 /**
166 * @tc.name: PutBatch002
167 * @tc.desc: PutBatch failed, Param is invalid.
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(KVAdapterTest, PutBatch002, TestSize.Level1)
172 {
173 map<string, string> values;
174 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->PutBatch(values));
175
176 for (int32_t i = 0; i < MAX_MAP_SIZE + 5; i++) {
177 values[to_string(i)] = "value";
178 }
179 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->PutBatch(values));
180 }
181
182 /**
183 * @tc.name: PutBatch003
184 * @tc.desc: PutBatch failed, kvDBPtr is null.
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(KVAdapterTest, PutBatch003, TestSize.Level1)
189 {
190 map<string, string> values;
191 values.insert(pair<string, string>("key1", "value1"));
192 values.insert(pair<string, string>("key2", "value2"));
193 kvStore->DeInit();
194 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->PutBatch(values));
195 }
196
197 /**
198 * @tc.name: Delete001
199 * @tc.desc: Delete succeed.
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(KVAdapterTest, Delete001, TestSize.Level1)
204 {
205 kvStore->Put("key4", "value4");
206 EXPECT_EQ(SOFTBUS_OK, kvStore->Delete("key4"));
207 }
208
209 /**
210 * @tc.name: Delete002
211 * @tc.desc: Delete failed, kvDBPtr is null.
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(KVAdapterTest, Delete002, TestSize.Level1)
216 {
217 kvStore->Put("key5", "value5");
218 kvStore->DeInit();
219 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Delete("key5"));
220 }
221
222 /**
223 * @tc.name: DeleteByPrefix001
224 * @tc.desc: DeleteByPrefix succeed.
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(KVAdapterTest, DeleteByPrefix001, TestSize.Level1)
229 {
230 kvStore->Put("key6", "value6");
231 kvStore->Put("key7", "value7");
232 EXPECT_EQ(SOFTBUS_OK, kvStore->DeleteByPrefix("key"));
233 }
234
235 /**
236 * @tc.name: DeleteByPrefix002
237 * @tc.desc: DeleteByPrefix failed, kvDBPtr is null.
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(KVAdapterTest, DeleteByPrefix002, TestSize.Level1)
242 {
243 kvStore->Put("key8", "value8");
244 kvStore->Put("key9", "value9");
245 kvStore->DeInit();
246 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->DeleteByPrefix("key"));
247 }
248
249 /**
250 * @tc.name: DeleteByPrefix003
251 * @tc.desc: DeleteByPrefix failed, keyPrefix is empty.
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(KVAdapterTest, DeleteByPrefix003, TestSize.Level1)
256 {
257 std::string keyPrefix = "";
258 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->DeleteByPrefix(keyPrefix));
259 }
260
261 /**
262 * @tc.name: DeleteByPrefix004
263 * @tc.desc: DeleteByPrefix failed, keyPrefix length exceeds MAX_STRING_LEN.
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(KVAdapterTest, DeleteByPrefix004, TestSize.Level1)
268 {
269 std::string keyPrefix(MAX_STRING_LEN + 1, 'a');
270 EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->DeleteByPrefix(keyPrefix));
271 }
272
273 /**
274 * @tc.name: Get001
275 * @tc.desc: Get succeed.
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(KVAdapterTest, Get001, TestSize.Level1)
280 {
281 kvStore->Put("key10", "value10");
282 string value;
283 EXPECT_EQ(SOFTBUS_OK, kvStore->Get("key10", value));
284 EXPECT_EQ("value10", value);
285 }
286
287 /**
288 * @tc.name: Get002
289 * @tc.desc: Get failed, kvDBPtr is null.
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(KVAdapterTest, Get002, TestSize.Level1)
294 {
295 kvStore->Put("key11", "value11");
296 kvStore->DeInit();
297 string value;
298 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Get("key11", value));
299 }
300
301 /**
302 * @tc.name: SetCloudAbility001
303 * @tc.desc: SetCloudAbility succeed.
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(KVAdapterTest, SetCloudAbility001, TestSize.Level1)
308 {
309 EXPECT_EQ(SOFTBUS_OK, kvStore->SetCloudAbility(true));
310 }
311
312 /**
313 * @tc.name: SetCloudAbility002
314 * @tc.desc: SetCloudAbility failed, kvDBPtr is null.
315 * @tc.type: FUNC
316 * @tc.require:
317 */
318 HWTEST_F(KVAdapterTest, SetCloudAbility002, TestSize.Level1)
319 {
320 kvStore->DeInit();
321 EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->SetCloudAbility(true));
322 }
323
324 /**
325 * @tc.name: RegisterDataChangeListener001
326 * @tc.desc: RegisterDataChangeListener failed, cloud sync disabled.
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(KVAdapterTest, RegisterDataChangeListener001, TestSize.Level1)
331 {
332 kvStoreObserver = std::make_shared<DistributedKv::KvStoreObserver>();
333 EXPECT_NE(SOFTBUS_OK, kvStore->RegisterDataChangeListener(kvStoreObserver));
334 }
335
336 /**
337 * @tc.name: DeRegisterDataChangeListener001
338 * @tc.desc: DeRegisterDataChangeListener failed, cloud sync disabled.
339 * @tc.type: FUNC
340 * @tc.require:
341 */
342 HWTEST_F(KVAdapterTest, DeRegisterDataChangeListener001, TestSize.Level1)
343 {
344 EXPECT_NE(SOFTBUS_OK, kvStore->DeRegisterDataChangeListener());
345 }
346
347 /**
348 * @tc.name: CloudSync001
349 * @tc.desc: CloudSync failed, cloud sync disabled.
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(KVAdapterTest, CloudSync001, TestSize.Level1)
354 {
355 if (!IsCloudSyncEnabled()) {
356 EXPECT_EQ(SOFTBUS_KV_CLOUD_DISABLED, kvStore->CloudSync());
357 } else {
358 EXPECT_EQ(SOFTBUS_KV_CLOUD_SYNC_FAIL, kvStore->CloudSync());
359 }
360 }
361
362 /**
363 * @tc.name: CloudSyncCallback001
364 * @tc.desc: CloudSyncCallback succeed.
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(KVAdapterTest, CloudSyncCallback001, TestSize.Level1)
369 {
370 DistributedKv::ProgressDetail detail;
371 detail.code = DistributedKv::Status::SUCCESS;
372 detail.progress = DistributedKv::Progress::SYNC_FINISH;
373 EXPECT_NO_FATAL_FAILURE(kvStore->CloudSyncCallback(std::move(detail)));
374 }
375
376 /**
377 * @tc.name: CloudSyncCallback002
378 * @tc.desc: CloudSyncCallback failed, Status code is ERROR.
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(KVAdapterTest, CloudSyncCallback002, TestSize.Level1)
383 {
384 DistributedKv::ProgressDetail detail;
385 detail.code = DistributedKv::Status::ERROR;
386 detail.progress = DistributedKv::Progress::SYNC_FINISH;
387 EXPECT_NO_FATAL_FAILURE(kvStore->CloudSyncCallback(std::move(detail)));
388 }
389 } // namespace OHOS
390