1 /*
2 * Copyright (c) 2023 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 #define private public
17 #define protected public
18 #include <string>
19 #include <vector>
20 #include <memory>
21 #include "gtest/gtest.h"
22 #include "refbase.h"
23 #include "distributed_device_profile_constants.h"
24 #include "distributed_device_profile_errors.h"
25 #include "distributed_device_profile_enums.h"
26 #include "ikv_adapter.h"
27 #include "kv_adapter.h"
28 #include "kv_data_change_listener.h"
29 #include "kv_sync_completed_listener.h"
30 #include "kv_store_death_recipient.h"
31 #undef private
32 #undef protected
33
34 namespace OHOS {
35 namespace DistributedDeviceProfile {
36 using namespace testing::ext;
37 using namespace std;
38
39 namespace {
40 const std::string APP_ID = "distributed_device_profile_service";
41 const std::string STORE_ID = "dp_kv_store";
42 shared_ptr<IKVAdapter> kvStore = nullptr;
43 }
44
45 class KVAdapterTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase(void)53 void KVAdapterTest::SetUpTestCase(void)
54 {
55 kvStore = make_shared<KVAdapter>(APP_ID, STORE_ID,
56 make_shared<KvDataChangeListener>(STORE_ID),
57 make_shared<KvSyncCompletedListener>(STORE_ID),
58 make_shared<KvDeathRecipient>(STORE_ID),
59 DistributedKv::TYPE_DYNAMICAL);
60 }
61
TearDownTestCase(void)62 void KVAdapterTest::TearDownTestCase(void) {
63 }
64
SetUp()65 void KVAdapterTest::SetUp()
66 {
67 kvStore->Init();
68 }
69
TearDown()70 void KVAdapterTest::TearDown()
71 {
72 kvStore->UnInit();
73 }
74
75 /**
76 * @tc.name: Init001
77 * @tc.desc: Init succeed.
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(KVAdapterTest, Init001, TestSize.Level1)
82 {
83 kvStore->UnInit();
84 EXPECT_EQ(DP_SUCCESS, kvStore->Init());
85 }
86
87 /**
88 * @tc.name: UnInit001
89 * @tc.desc: UnInit succeed.
90 * @tc.type: FUNC
91 * @tc.require:
92 */
93 HWTEST_F(KVAdapterTest, UnInit001, TestSize.Level1)
94 {
95 EXPECT_EQ(DP_SUCCESS, kvStore->UnInit());
96 }
97
98 /**
99 * @tc.name: Put001
100 * @tc.desc: Put succeed.
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(KVAdapterTest, Put001, TestSize.Level1)
105 {
106 EXPECT_EQ(DP_SUCCESS, kvStore->Put("key1", "value1"));
107 }
108
109 /**
110 * @tc.name: Put002
111 * @tc.desc: Put failed, Param is invalid.
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(KVAdapterTest, Put002, TestSize.Level1)
116 {
117 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put("", "value1"));
118 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put("key1", ""));
119 }
120
121 /**
122 * @tc.name: Put003
123 * @tc.desc: Put failed, kvDBPtr is null.
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(KVAdapterTest, Put003, TestSize.Level1)
128 {
129 kvStore->UnInit();
130 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->Put("key1", "value1"));
131 }
132
133 /**
134 * @tc.name: Put004
135 * @tc.desc: Put first if.
136 * @tc.type: FUNC
137 * @tc.require:
138 */
139 HWTEST_F(KVAdapterTest, Put004, TestSize.Level1)
140 {
141 string key = "key";
142 string value = "value";
143 EXPECT_EQ(DP_SUCCESS, kvStore->Put(key, value));
144
145 for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
146 value += 'a';
147 }
148 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put(key, value));
149
150 value = "";
151 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put(key, value));
152
153 for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
154 key += 'a';
155 }
156 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put(key, value));
157
158 key = "";
159 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Put(key, value));
160 }
161
162 /**
163 * @tc.name: PutBatch001
164 * @tc.desc: PutBatch succeed.
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(KVAdapterTest, PutBatch001, TestSize.Level1)
169 {
170 map<string, string> values;
171 values.insert(pair<string, string>("key2", "value2"));
172 values.insert(pair<string, string>("key3", "value3"));
173 EXPECT_EQ(DP_SUCCESS, kvStore->PutBatch(values));
174 }
175
176 /**
177 * @tc.name: PutBatch002
178 * @tc.desc: PutBatch failed, Param is invalid.
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(KVAdapterTest, PutBatch002, TestSize.Level1)
183 {
184 map<string, string> values;
185 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->PutBatch(values));
186
187 for (int32_t i = 0; i< MAX_PROFILE_SIZE + 5; i++) {
188 values[to_string(i)] = "value";
189 }
190 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->PutBatch(values));
191 }
192
193 /**
194 * @tc.name: PutBatch003
195 * @tc.desc: PutBatch failed, kvDBPtr is null.
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(KVAdapterTest, PutBatch003, TestSize.Level1)
200 {
201 map<string, string> values;
202 values.insert(pair<string, string>("key1", "value1"));
203 values.insert(pair<string, string>("key2", "value2"));
204 kvStore->UnInit();
205 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->PutBatch(values));
206 }
207
208 /**
209 * @tc.name: Delete001
210 * @tc.desc: Delete succeed.
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(KVAdapterTest, Delete001, TestSize.Level1)
215 {
216 kvStore->Put("key4", "value4");
217 EXPECT_EQ(DP_SUCCESS, kvStore->Delete("key4"));
218 }
219
220 /**
221 * @tc.name: Delete002
222 * @tc.desc: Delete failed, kvDBPtr is null.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(KVAdapterTest, Delete002, TestSize.Level1)
227 {
228 kvStore->Put("key5", "value5");
229 kvStore->UnInit();
230 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->Delete("key5"));
231 }
232
233 /**
234 * @tc.name: DeleteByPrefix001
235 * @tc.desc: DeleteByPrefix succeed.
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(KVAdapterTest, DeleteByPrefix001, TestSize.Level1)
240 {
241 kvStore->Put("key6", "value6");
242 kvStore->Put("key7", "value7");
243 EXPECT_EQ(DP_SUCCESS, kvStore->DeleteByPrefix("key"));
244 }
245
246 /**
247 * @tc.name: DeleteByPrefix002
248 * @tc.desc: DeleteByPrefix failed, kvDBPtr is null.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(KVAdapterTest, DeleteByPrefix002, TestSize.Level1)
253 {
254 kvStore->Put("key8", "value8");
255 kvStore->Put("key9", "value9");
256 kvStore->UnInit();
257 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->DeleteByPrefix("key"));
258 }
259
260 /**
261 * @tc.name: Get001
262 * @tc.desc: Get succeed.
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(KVAdapterTest, Get001, TestSize.Level1)
267 {
268 kvStore->Put("key10", "value10");
269 string value;
270 EXPECT_EQ(DP_SUCCESS, kvStore->Get("key10", value));
271 EXPECT_EQ("value10", value);
272 }
273
274 /**
275 * @tc.name: Get002
276 * @tc.desc: Get failed, kvDBPtr is null.
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(KVAdapterTest, Get002, TestSize.Level1)
281 {
282 kvStore->Put("key11", "value11");
283 kvStore->UnInit();
284 string value;
285 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->Get("key11", value));
286 }
287
288 /**
289 * @tc.name: GetByPrefix001
290 * @tc.desc: GetByPrefix succeed.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(KVAdapterTest, GetByPrefix001, TestSize.Level1)
295 {
296 kvStore->Put("GetByPrefix001a", "value");
297 kvStore->Put("GetByPrefix001b", "value");
298 map<string, string> values;
299 EXPECT_EQ(DP_SUCCESS, kvStore->GetByPrefix("GetByPrefix001", values));
300 EXPECT_EQ(2, values.size());
301 }
302
303 /**
304 * @tc.name: GetByPrefix002
305 * @tc.desc: GetByPrefix failed, kvDBPtr is null.
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(KVAdapterTest, GetByPrefix002, TestSize.Level1)
310 {
311 kvStore->Put("GetByPrefix002a", "value");
312 kvStore->Put("GetByPrefix002b", "value");
313 kvStore->UnInit();
314 map<string, string> values;
315 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->GetByPrefix("GetByPrefix002", values));
316 }
317
318 /**
319 * @tc.name: GetByPrefix003
320 * @tc.desc: GetByPrefix failed, AllEntries size is invalid.
321 * @tc.type: FUNC
322 * @tc.require:
323 */
324 HWTEST_F(KVAdapterTest, GetByPrefix003, TestSize.Level1)
325 {
326 map<string, string> values;
327 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->GetByPrefix("GetByPrefix003", values));
328 }
329
330 /**
331 * @tc.name: Sync001
332 * @tc.desc: Sync failed, kvStorePtr is nullptr.
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(KVAdapterTest, Sync001, TestSize.Level1)
337 {
338 kvStore->UnInit();
339 vector<string> deviceList;
340 EXPECT_EQ(DP_KV_DB_PTR_NULL, kvStore->Sync(deviceList, SyncMode::PUSH));
341 }
342
343 /**
344 * @tc.name: Sync002
345 * @tc.desc: Sync failed, deviceList is invalid.
346 * @tc.type: FUNC
347 * @tc.require:
348 */
349 HWTEST_F(KVAdapterTest, Sync002, TestSize.Level1)
350 {
351 vector<string> deviceList;
352 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Sync(deviceList, SyncMode::PUSH));
353
354 for (int32_t i = 0; i < MAX_DEVICE_SIZE + 5; i++) {
355 deviceList.emplace_back("deviceId");
356 }
357 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Sync(deviceList, SyncMode::PUSH));
358 }
359
360 /**
361 * @tc.name: Sync003
362 * @tc.desc: syncMode all.
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(KVAdapterTest, Sync003, TestSize.Level1)
367 {
368 vector<string> deviceList;
369 deviceList.emplace_back("deviceId");
370 SyncMode mode = SyncMode::PUSH;
371 kvStore->Sync(deviceList, mode);
372
373 mode = SyncMode::MAX;
374 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Sync(deviceList, mode));
375
376 mode = SyncMode::MIN;
377 EXPECT_EQ(DP_INVALID_PARAMS, kvStore->Sync(deviceList, mode));
378 }
379
380 /**
381 * @tc.name: DeleteKvStore001
382 * @tc.desc: syncMode all.
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(KVAdapterTest, DeleteKvStore001, TestSize.Level1)
387 {
388 shared_ptr<KVAdapter> kvStore_;
389 kvStore_= make_shared<KVAdapter>(APP_ID, STORE_ID,
390 make_shared<KvDataChangeListener>(STORE_ID),
391 make_shared<KvSyncCompletedListener>(STORE_ID),
392 make_shared<KvDeathRecipient>(STORE_ID),
393 DistributedKv::TYPE_DYNAMICAL);
394 int32_t ret = kvStore_->DeleteKvStore();
395 EXPECT_EQ(DP_SUCCESS, ret);
396 }
397 } // namespace DistributedDeviceProfile
398 } // namespace OHOS
399