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 #define LOG_TAG "UdmfRunTimeStoreTest"
17 #include <openssl/rand.h>
18
19 #include "accesstoken_kit.h"
20 #include "bootstrap.h"
21 #include "device_manager_adapter.h"
22 #include "executor_pool.h"
23 #include "gtest/gtest.h"
24 #include "ipc_skeleton.h"
25 #include "kvstore_meta_manager.h"
26 #include "metadata/meta_data_manager.h"
27 #include "nativetoken_kit.h"
28 #include "text.h"
29 #include "token_setproc.h"
30 #define private public
31 #include "store/runtime_store.h"
32 #undef private
33
34 using namespace testing::ext;
35 using namespace OHOS::DistributedData;
36 using namespace OHOS::Security::AccessToken;
37 using namespace OHOS::UDMF;
38 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
39 using Entry = DistributedDB::Entry;
40 using Key = DistributedDB::Key;
41 using Value = DistributedDB::Value;
42 using UnifiedData = OHOS::UDMF::UnifiedData;
43 using Summary = OHOS::UDMF::Summary;
44 namespace OHOS::Test {
45 namespace DistributedDataTest {
46
GrantPermissionNative()47 static void GrantPermissionNative()
48 {
49 const char **perms = new const char *[2];
50 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
51 perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
52 TokenInfoParams infoInstance = {
53 .dcapsNum = 0,
54 .permsNum = 2,
55 .aclsNum = 0,
56 .dcaps = nullptr,
57 .perms = perms,
58 .acls = nullptr,
59 .processName = "distributed_data_test",
60 .aplStr = "system_basic",
61 };
62 uint64_t tokenId = GetAccessTokenId(&infoInstance);
63 SetSelfTokenID(tokenId);
64 AccessTokenKit::ReloadNativeTokenInfo();
65 delete[] perms;
66 }
67
68 class UdmfRunTimeStoreTest : public testing::Test {
69 public:
SetUpTestCase(void)70 static void SetUpTestCase(void)
71 {
72 GrantPermissionNative();
73 DistributedData::Bootstrap::GetInstance().LoadComponents();
74 DistributedData::Bootstrap::GetInstance().LoadDirectory();
75 DistributedData::Bootstrap::GetInstance().LoadCheckers();
76 size_t max = 2;
77 size_t min = 1;
78 auto executors = std::make_shared<OHOS::ExecutorPool>(max, min);
79 DmAdapter::GetInstance().Init(executors);
80 DistributedKv::KvStoreMetaManager::GetInstance().BindExecutor(executors);
81 DistributedKv::KvStoreMetaManager::GetInstance().InitMetaParameter();
82 DistributedKv::KvStoreMetaManager::GetInstance().InitMetaListener();
83 }
TearDownTestCase(void)84 static void TearDownTestCase(void){};
SetUp()85 void SetUp(){};
TearDown()86 void TearDown(){};
87 void GetRandomKey(std::vector<uint8_t>& key, uint32_t defaultSize);
88 void GetRandomValue(std::vector<uint8_t>& value, uint32_t defaultSize);
89
90 const uint32_t MAX_KEY_SIZE = 1024;
91 const uint32_t MAX_VALUE_SIZE = 4 * 1024 * 1024;
92 const std::string STORE_ID = "drag";
93 const std::string KEY_PREFIX = "TEST_";
94 const std::string EMPTY_DEVICE_ID = "";
95 static constexpr size_t tempUdataRecordSize = 1;
96 };
97
GetRandomKey(std::vector<uint8_t> & key,uint32_t defaultSize)98 void UdmfRunTimeStoreTest::GetRandomKey(std::vector<uint8_t>& key, uint32_t defaultSize)
99 {
100 key.resize(defaultSize);
101 RAND_bytes(key.data(), defaultSize);
102
103 if (defaultSize >= KEY_PREFIX.length()) {
104 vector<uint8_t> vectorPrefix(KEY_PREFIX.begin(), KEY_PREFIX.end());
105 std::copy(vectorPrefix.begin(), vectorPrefix.end(), key.begin());
106 }
107 }
108
GetRandomValue(std::vector<uint8_t> & value,uint32_t defaultSize)109 void UdmfRunTimeStoreTest::GetRandomValue(std::vector<uint8_t>& value, uint32_t defaultSize)
110 {
111 value.resize(defaultSize);
112 RAND_bytes(value.data(), defaultSize);
113 }
114
115 /**
116 * @tc.name: PutEntries001
117 * @tc.desc: check for legal parameters, sum size of all entries is smaller than 512M.
118 * @tc.type: FUNC
119 * @tc.require:
120 */
121 HWTEST_F(UdmfRunTimeStoreTest, PutEntries001, TestSize.Level1)
122 {
123 auto store = std::make_shared<RuntimeStore>(STORE_ID);
124 bool result = store->Init();
125 EXPECT_EQ(true, result);
126
127 Key key;
128 Value value;
129 GetRandomValue(value, MAX_KEY_SIZE); // 1K
130 vector<Entry> entrysRand;
131 for (int i = 0; i < 129; ++i) {
132 GetRandomKey(key, MAX_KEY_SIZE); // 1K
133 entrysRand.push_back({ key, value });
134 }
135
136 int32_t status = store->PutEntries(entrysRand);
137 EXPECT_EQ(E_OK, status);
138
139 vector<Entry> entries;
140 status = store->GetEntries(KEY_PREFIX, entries);
141 EXPECT_EQ(E_OK, status);
142 EXPECT_EQ(129, entries.size());
143
144 status = store->Delete(KEY_PREFIX);
145 EXPECT_EQ(E_OK, status);
146 }
147
148 /**
149 * @tc.name: PutEntries002
150 * @tc.desc: check for legal parameters, sum size of all entries is equal to 512M.
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(UdmfRunTimeStoreTest, PutEntries002, TestSize.Level1)
155 {
156 auto store = std::make_shared<RuntimeStore>(STORE_ID);
157 bool result = store->Init();
158 EXPECT_EQ(true, result);
159
160 Key key;
161 Value value;
162 GetRandomKey(key, MAX_KEY_SIZE); // 1K
163 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
164 vector<Entry> entrysRand(127, { key, value });
165 Value emptyValue;
166 for (int i = 0; i < 3969; i++) {
167 entrysRand.push_back({ key, emptyValue });
168 }
169 int32_t status = store->PutEntries(entrysRand);
170 EXPECT_EQ(E_OK, status);
171
172 vector<Entry> entries;
173 status = store->GetEntries(KEY_PREFIX, entries);
174 EXPECT_EQ(E_OK, status);
175 EXPECT_EQ(1, entries.size());
176
177 status = store->Delete(KEY_PREFIX);
178 EXPECT_EQ(E_OK, status);
179 }
180
181 /**
182 * @tc.name: PutEntries003
183 * @tc.desc: test rollback, sum size of all entries is larger to 512M.
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(UdmfRunTimeStoreTest, PutEntries003, TestSize.Level1)
188 {
189 auto store = std::make_shared<RuntimeStore>(STORE_ID);
190 bool result = store->Init();
191 EXPECT_EQ(true, result);
192
193 Key key;
194 Value value;
195 GetRandomKey(key, MAX_KEY_SIZE); // 1K
196 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
197 vector<Entry> entrysRand(127, { key, value });
198 Value emptyValue;
199 for (int i = 0; i < 3970; i++) {
200 entrysRand.push_back({ key, emptyValue });
201 }
202
203 int32_t status = store->PutEntries(entrysRand);
204 EXPECT_EQ(E_DB_ERROR, status);
205
206 vector<Entry> entries;
207 status = store->GetEntries(KEY_PREFIX, entries);
208 EXPECT_EQ(E_OK, status);
209 EXPECT_EQ(0, entries.size());
210 }
211
212 /**
213 * @tc.name: PutEntries004
214 * @tc.desc: test rollback, illegal size of key or value.
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(UdmfRunTimeStoreTest, PutEntries004, TestSize.Level1)
219 {
220 auto store = std::make_shared<RuntimeStore>(STORE_ID);
221 bool result = store->Init();
222 EXPECT_EQ(true, result);
223
224 Key key;
225 Key keyInvalid;
226 Value value;
227 Value valueInvalid;
228 GetRandomKey(key, MAX_KEY_SIZE); // 1K
229 GetRandomKey(keyInvalid, MAX_KEY_SIZE + 1); // 1K + 1
230 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
231 GetRandomValue(valueInvalid, MAX_VALUE_SIZE + 1); // 4M + 1
232 vector<Entry> entrysMix1(1, { keyInvalid, value });
233 vector<Entry> entrysMix2(1, { key, valueInvalid });
234
235 int32_t status = store->PutEntries(entrysMix1);
236 EXPECT_EQ(E_DB_ERROR, status);
237 vector<Entry> entries;
238 status = store->GetEntries(KEY_PREFIX, entries);
239 EXPECT_EQ(E_OK, status);
240 EXPECT_EQ(0, entries.size());
241
242 status = store->PutEntries(entrysMix2);
243 EXPECT_EQ(E_DB_ERROR, status);
244 entries.clear();
245 status = store->GetEntries(KEY_PREFIX, entries);
246 EXPECT_EQ(E_OK, status);
247 EXPECT_EQ(0, entries.size());
248 }
249
250 /**
251 * @tc.name: PutEntries005
252 * @tc.desc: test rollback, mix illegal entries and legal entries.
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(UdmfRunTimeStoreTest, PutEntries005, TestSize.Level1)
257 {
258 auto store = std::make_shared<RuntimeStore>(STORE_ID);
259 bool result = store->Init();
260 EXPECT_EQ(true, result);
261
262 Key key;
263 Key keyInvalid;
264 Value value;
265 Value valueInvalid;
266 vector<Entry> entrysRand;
267 for (int i = 0; i < 129; ++i) {
268 GetRandomKey(key, MAX_KEY_SIZE); // 1K
269 GetRandomValue(value, MAX_KEY_SIZE); // 1K
270 entrysRand.push_back({ key, value });
271 }
272
273 GetRandomKey(keyInvalid, MAX_KEY_SIZE + 1); // 1K + 1
274 GetRandomValue(value, MAX_KEY_SIZE); // 1K
275 entrysRand[128] = { keyInvalid, value };
276 int32_t status = store->PutEntries(entrysRand);
277 EXPECT_EQ(E_DB_ERROR, status);
278 vector<Entry> entries;
279 status = store->GetEntries(KEY_PREFIX, entries);
280 EXPECT_EQ(E_OK, status);
281 EXPECT_EQ(0, entries.size());
282
283 GetRandomKey(key, MAX_KEY_SIZE); // 1K
284 GetRandomValue(valueInvalid, MAX_VALUE_SIZE + 1); // 4M + 1
285 entrysRand[128] = { key, valueInvalid };
286 status = store->PutEntries(entrysRand);
287 EXPECT_EQ(E_DB_ERROR, status);
288 status = store->GetEntries(KEY_PREFIX, entries);
289 EXPECT_EQ(E_OK, status);
290 EXPECT_EQ(0, entries.size());
291 }
292
293 /**
294 * @tc.name: DeleteEntries001
295 * @tc.desc: check for legal parameters, delete entries success.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(UdmfRunTimeStoreTest, DeleteEntries001, TestSize.Level1)
300 {
301 auto store = std::make_shared<RuntimeStore>(STORE_ID);
302 bool result = store->Init();
303 EXPECT_EQ(true, result);
304
305 Value value;
306 GetRandomValue(value, MAX_KEY_SIZE); // 1K
307 vector<Key> keys(129);
308 vector<Entry> entrysRand;
309 for (int i = 0; i < 129; ++i) {
310 GetRandomKey(keys[i], MAX_KEY_SIZE); // 1K
311 entrysRand.push_back({ keys[i], value });
312 }
313
314 int32_t status = store->PutEntries(entrysRand);
315 EXPECT_EQ(E_OK, status);
316
317 vector<Entry> entries;
318 status = store->GetEntries(KEY_PREFIX, entries);
319 EXPECT_EQ(E_OK, status);
320 EXPECT_EQ(129, entries.size());
321
322 status = store->DeleteEntries(keys);
323 EXPECT_EQ(E_OK, status);
324
325 entries.clear();
326 status = store->GetEntries(KEY_PREFIX, entries);
327 EXPECT_EQ(E_OK, status);
328 EXPECT_EQ(0, entries.size());
329 }
330
331 /**
332 * @tc.name: DeleteEntries002
333 * @tc.desc: check for illegal parameters, delete entries error.
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337 HWTEST_F(UdmfRunTimeStoreTest, DeleteEntries002, TestSize.Level1)
338 {
339 auto store = std::make_shared<RuntimeStore>(STORE_ID);
340 bool result = store->Init();
341 EXPECT_TRUE(result);
342 Key key;
343 Value value;
344 GetRandomKey(key, MAX_KEY_SIZE); // 1K
345 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
346 vector<Entry> entrysRand(127, { key, value });
347 vector<Key> keys(3970);
348 Value emptyValue;
349 for (int i = 0; i < 3970; ++i) {
350 GetRandomKey(keys[i], 3970);
351 entrysRand.push_back({ keys[i], emptyValue });
352 }
353
354 int32_t status = store->PutEntries(entrysRand);
355 EXPECT_EQ(E_DB_ERROR, status);
356
357 vector<Entry> entries;
358 status = store->GetEntries(KEY_PREFIX, entries);
359 EXPECT_EQ(E_OK, status);
360 EXPECT_EQ(0, entries.size());
361
362 status = store->DeleteEntries(keys);
363 EXPECT_EQ(E_DB_ERROR, status);
364
365 entries.clear();
366 status = store->GetEntries(KEY_PREFIX, entries);
367 EXPECT_EQ(E_OK, status);
368 EXPECT_EQ(0, entries.size());
369 }
370
371 /**
372 * @tc.name: Init
373 * @tc.desc: check for illegal parameters, delete entries error.
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(UdmfRunTimeStoreTest, Init, TestSize.Level1)
378 {
379 auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice();
380 auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(EMPTY_DEVICE_ID);
381 EXPECT_TRUE(uuid.empty());
382 dvInfo.uuid = EMPTY_DEVICE_ID;
383 auto store = std::make_shared<RuntimeStore>(STORE_ID);
384 bool result = store->Init();
385 EXPECT_TRUE(result);
386 }
387
388 /**
389 * @tc.name: Get001
390 * @tc.desc: check for illegal parameters, delete entries error.
391 * @tc.type: FUNC
392 * @tc.require:
393 */
394 HWTEST_F(UdmfRunTimeStoreTest, Get001, TestSize.Level1)
395 {
396 auto store = std::make_shared<RuntimeStore>(STORE_ID);
397 bool result = store->Init();
398 EXPECT_TRUE(result);
399
400 Key key;
401 Key keyInvalid;
402 Value value;
403 Value valueInvalid;
404 GetRandomKey(key, MAX_KEY_SIZE); // 1K
405 GetRandomKey(keyInvalid, MAX_KEY_SIZE + 1); // 1K + 1
406 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
407 GetRandomValue(valueInvalid, MAX_VALUE_SIZE + 1); // 4M + 1
408 vector<Entry> entrysMix1(1, { keyInvalid, value });
409 vector<Entry> entrysMix2(1, { key, valueInvalid });
410 UnifiedData unifiedData;
411 int32_t status = store->PutEntries(entrysMix1);
412 EXPECT_EQ(E_DB_ERROR, status);
413 status = store->GetEntries(KEY_PREFIX, entrysMix1);
414 EXPECT_EQ(E_OK, status);
415
416 status = store->Get(KEY_PREFIX, unifiedData);
417 EXPECT_EQ(E_NOT_FOUND, status);
418 }
419
420 /**
421 * @tc.name: Get002
422 * @tc.desc: check for legal parameters, delete entries error.
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(UdmfRunTimeStoreTest, Get002, TestSize.Level1)
427 {
428 auto store = std::make_shared<RuntimeStore>(STORE_ID);
429 bool result = store->Init();
430 EXPECT_TRUE(result);
431
432 Key key;
433 Value value;
434 GetRandomKey(key, MAX_KEY_SIZE); // 1K
435 GetRandomValue(value, MAX_VALUE_SIZE); // 4M
436 vector<Entry> entrysRand(127, { key, value });
437 Value emptyValue;
438 for (int i = 0; i < 3970; i++) {
439 entrysRand.push_back({ key, emptyValue });
440 }
441 auto status = store->PutEntries(entrysRand);
442 EXPECT_EQ(E_DB_ERROR, status);
443 status = store->GetEntries(EMPTY_DEVICE_ID, entrysRand);
444 EXPECT_EQ(E_OK, status);
445 UnifiedData data1;
446 status = store->Get(EMPTY_DEVICE_ID, data1);
447 EXPECT_EQ(E_NOT_FOUND, status);
448 }
449
450 /**
451 * @tc.name: GetDetailsFromUData
452 * @tc.desc: check for legal parameters, delete entries error.
453 * @tc.type: FUNC
454 * @tc.require:
455 */
456 HWTEST_F(UdmfRunTimeStoreTest, GetDetailsFromUData, TestSize.Level1)
457 {
458 auto store = std::make_shared<RuntimeStore>(STORE_ID);
459 bool result = store->Init();
460 EXPECT_TRUE(result);
461
462 Key key;
463 Value value;
464 GetRandomValue(value, MAX_KEY_SIZE); // 1K
465 vector<Entry> entrysRand;
466 for (int i = 0; i < 129; ++i) {
467 GetRandomKey(key, MAX_KEY_SIZE); // 1K
468 entrysRand.push_back({ key, value });
469 }
470
471 int32_t status = store->PutEntries(entrysRand);
472 EXPECT_EQ(E_OK, status);
473 vector<Entry> entries;
474 status = store->GetEntries(KEY_PREFIX, entries);
475 EXPECT_EQ(E_OK, status);
476 EXPECT_EQ(129, entries.size());
477 UnifiedData data1;
478 UDDetails details1;
479 details1.insert({ "udmf_key", "udmf_value" });
480 auto records = data1.GetRecords();
481 EXPECT_EQ(records.size(), 0);
482 status = store->GetDetailsFromUData(data1, details1);
483 EXPECT_FALSE(status);
484 }
485
486 /**
487 * @tc.name: GetDetailsFromUData01
488 * @tc.desc: check for legal parameters, delete entries error.
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(UdmfRunTimeStoreTest, GetDetailsFromUData01, TestSize.Level1)
493 {
494 auto store = std::make_shared<RuntimeStore>(STORE_ID);
495 bool result = store->Init();
496 EXPECT_TRUE(result);
497
498 Key key;
499 Value value;
500 GetRandomValue(value, MAX_KEY_SIZE); // 1K
501 vector<Entry> entrysRand;
502 for (int i = 0; i < 129; ++i) {
503 GetRandomKey(key, MAX_KEY_SIZE); // 1K
504 entrysRand.push_back({ key, value });
505 }
506
507 int32_t status = store->PutEntries(entrysRand);
508 EXPECT_EQ(E_OK, status);
509 vector<Entry> entries;
510 status = store->GetEntries(KEY_PREFIX, entries);
511 EXPECT_EQ(E_OK, status);
512 UDDetails details1;
513 details1.insert({ "udmf_key", "udmf_value" });
514 UnifiedData inputData;
515 std::vector<std::shared_ptr<UnifiedRecord>> inputRecords;
516 for (int32_t i = 0; i < 512; ++i) {
517 inputRecords.emplace_back(std::make_shared<Text>());
518 }
519 inputData.SetRecords(inputRecords);
520 UnifiedData outputData;
521 auto outputRecords = outputData.GetRecords();
522 ASSERT_EQ(inputRecords.size(), 512);
523 ASSERT_EQ(0, outputRecords.size());
524 status = store->GetDetailsFromUData(inputData, details1);
525 EXPECT_FALSE(status);
526 }
527
528 /**
529 * @tc.name: GetSummary
530 * @tc.desc: check for legal parameters, delete entries error.
531 * @tc.type: FUNC
532 * @tc.require:
533 */
534 HWTEST_F(UdmfRunTimeStoreTest, GetSummary, TestSize.Level1)
535 {
536 auto store = std::make_shared<RuntimeStore>(STORE_ID);
537 bool result = store->Init();
538 EXPECT_TRUE(result);
539
540 UnifiedData data;
541 UDDetails details;
542 details.insert({ "udmf_key", "udmf_value" });
543 Text text;
544 text.SetDetails(details);
545 std::shared_ptr<UnifiedRecord> record1 = std::make_shared<Text>(text);
546 data.AddRecord(record1);
547
548 Summary summary;
549 auto status = store->GetSummary(KEY_PREFIX, summary);
550 ASSERT_EQ(status, E_DB_ERROR);
551 }
552 }; // namespace DistributedDataTest
553 }; // namespace OHOS::Test