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 "UdmfServiceImplTest"
17 #include "udmf_service_impl.h"
18 #include "accesstoken_kit.h"
19 #include "account_delegate.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 "preprocess_utils.h"
29 #include "runtime_store.h"
30 #include "text.h"
31 #include "plain_text.h"
32 #include "token_setproc.h"
33
34 using namespace testing::ext;
35 using namespace OHOS::Security::AccessToken;
36 using namespace OHOS::UDMF;
37 using Entry = DistributedDB::Entry;
38 using Key = DistributedDB::Key;
39 using Value = DistributedDB::Value;
40 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
41 using UnifiedData = OHOS::UDMF::UnifiedData;
42 using Summary = OHOS::UDMF::Summary;
43 namespace OHOS::Test {
44 namespace DistributedDataTest {
45
GrantPermissionNative()46 static void GrantPermissionNative()
47 {
48 const char **perms = new const char *[3];
49 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
50 perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
51 perms[2] = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE"; // perms[2] is a permission parameter
52 TokenInfoParams infoInstance = {
53 .dcapsNum = 0,
54 .permsNum = 3,
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 UdmfServiceImplTest : 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
88 static constexpr const char *STORE_ID = "drag";
89 static constexpr uint32_t TOKEN_ID = 5;
90 static constexpr const char *APP_ID = "appId";
91 };
92
93 /**
94 * @tc.name: SaveData001
95 * @tc.desc: Abnormal test of SaveData, unifiedData is invalid
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(UdmfServiceImplTest, SaveData001, TestSize.Level1)
100 {
101 CustomOption option;
102 UnifiedData data;
103 std::string key = "";
104 option.intention = UD_INTENTION_BASE;
105 UdmfServiceImpl udmfServiceImpl;
106 int32_t ret = udmfServiceImpl.SaveData(option, data, key);
107 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
108 }
109
110 /**
111 * @tc.name: RetrieveData001
112 * @tc.desc: Abnormal test of RetrieveData, query.key is invalid
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(UdmfServiceImplTest, RetrieveData001, TestSize.Level1)
117 {
118 QueryOption query;
119 UnifiedData data;
120 query.intention = UD_INTENTION_BASE;
121 UdmfServiceImpl udmfServiceImpl;
122 int32_t ret = udmfServiceImpl.RetrieveData(query, data);
123 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
124 }
125
126 /**
127 * @tc.name: IsPermissionInCache002
128 * @tc.desc: Abnormal test of IsPermissionInCache, privilegeCache_ has no query.key
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(UdmfServiceImplTest, IsPermissionInCache002, TestSize.Level1)
133 {
134 QueryOption query;
135 UdmfServiceImpl udmfServiceImpl;
136 bool ret = udmfServiceImpl.IsPermissionInCache(query);
137 EXPECT_EQ(ret, false);
138 }
139
140 /**
141 * @tc.name: UpdateData001
142 * @tc.desc: Abnormal test of UpdateData, query.key is invalid
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(UdmfServiceImplTest, UpdateData001, TestSize.Level1)
147 {
148 QueryOption query;
149 UnifiedData data;
150 UdmfServiceImpl udmfServiceImpl;
151 int32_t ret = udmfServiceImpl.UpdateData(query, data);
152 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
153 }
154
155 /**
156 * @tc.name: GetSummary001
157 * @tc.desc: Abnormal test of UpdateData, query.key is invalid
158 * @tc.type: FUNC
159 * @tc.require:
160 */
161 HWTEST_F(UdmfServiceImplTest, GetSummary001, TestSize.Level1)
162 {
163 QueryOption query;
164 Summary summary;
165 UdmfServiceImpl udmfServiceImpl;
166 int32_t ret = udmfServiceImpl.GetSummary(query, summary);
167 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
168 }
169
170 /**
171 * @tc.name: Sync001
172 * @tc.desc: Abnormal test of Sync, query.key is invalid
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(UdmfServiceImplTest, Sync001, TestSize.Level1)
177 {
178 QueryOption query;
179 std::vector<std::string> devices = {"device1"};
180 UdmfServiceImpl udmfServiceImpl;
181 int32_t ret = udmfServiceImpl.Sync(query, devices);
182 EXPECT_EQ(ret, E_NO_PERMISSION);
183 }
184
185 /**
186 * @tc.name: VerifyPermission001
187 * @tc.desc: Abnormal test of VerifyPermission, permission is empty
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(UdmfServiceImplTest, VerifyPermission001, TestSize.Level1)
192 {
193 std::string permission;
194 uint32_t callerTokenId = 0;
195 UdmfServiceImpl udmfServiceImpl;
196 bool ret = udmfServiceImpl.VerifyPermission(permission, callerTokenId);
197 EXPECT_FALSE(ret);
198 }
199
200 /**
201 * @tc.name: IsRemoteData001
202 * @tc.desc: Abnormal test of IsRemoteData, query.key is invalid
203 * @tc.type: FUNC
204 * @tc.require:
205 */
206 HWTEST_F(UdmfServiceImplTest, IsRemoteData001, TestSize.Level1)
207 {
208 QueryOption query;
209 bool result = false;
210 UdmfServiceImpl udmfServiceImpl;
211 int32_t ret = udmfServiceImpl.IsRemoteData(query, result);
212 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
213 }
214
215 /**
216 * @tc.name: SetAppShareOption001
217 * @tc.desc: Abnormal test of SetAppShareOption, intention is empty
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(UdmfServiceImplTest, SetAppShareOption001, TestSize.Level1)
222 {
223 std::string intention = "";
224 int32_t shareOption = 1;
225 UdmfServiceImpl udmfServiceImpl;
226 int32_t ret = udmfServiceImpl.SetAppShareOption(intention, shareOption);
227 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
228 }
229
230
231 /**
232 * @tc.name: SetAppShareOption002
233 * @tc.desc: Abnormal test of SetAppShareOption, shareOption > SHARE_OPTIONS_BUTT
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(UdmfServiceImplTest, SetAppShareOption002, TestSize.Level1)
238 {
239 std::string intention = "intention";
240 int32_t shareOption = 4;
241 UdmfServiceImpl udmfServiceImpl;
242 int32_t ret = udmfServiceImpl.SetAppShareOption(intention, shareOption);
243 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
244 }
245
246 /**
247 * @tc.name: SetAppShareOption003
248 * @tc.desc: Abnormal test of SetAppShareOption, shareOption = SHARE_OPTIONS_BUTT
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(UdmfServiceImplTest, SetAppShareOption003, TestSize.Level1)
253 {
254 std::string intention = "intention";
255 int32_t shareOption = 3;
256 UdmfServiceImpl udmfServiceImpl;
257 int32_t ret = udmfServiceImpl.SetAppShareOption(intention, shareOption);
258 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
259 }
260
261 /**
262 * @tc.name: SetAppShareOption004
263 * @tc.desc: Abnormal test of SetAppShareOption, shareOption < IN_APP
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(UdmfServiceImplTest, SetAppShareOption004, TestSize.Level1)
268 {
269 std::string intention = "intention";
270 int32_t shareOption = -1;
271 UdmfServiceImpl udmfServiceImpl;
272 int32_t ret = udmfServiceImpl.SetAppShareOption(intention, shareOption);
273 EXPECT_EQ(ret, E_INVALID_PARAMETERS);
274 }
275
276 /**
277 * @tc.name: OnUserChangeTest001
278 * @tc.desc: OnUserChange test
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(UdmfServiceImplTest, OnUserChangeTest001, TestSize.Level1)
283 {
284 // Clear store
285 StoreCache::GetInstance().CloseStores();
286 auto stores = StoreCache::GetInstance().stores_.Size();
287 ASSERT_EQ(stores, 0);
288 // Init store
289 StoreCache::GetInstance().GetStore("SystemShare");
290 stores = StoreCache::GetInstance().stores_.Size();
291 ASSERT_EQ(stores, 1);
292
293 uint32_t code = static_cast<uint32_t>(DistributedData::AccountStatus::DEVICE_ACCOUNT_STOPPING);
294 std::string user = "OH_USER_test";
295 std::string account = "OH_ACCOUNT_test";
296 UdmfServiceImpl udmfServiceImpl;
297 auto status = udmfServiceImpl.OnUserChange(code, user, account);
298 ASSERT_EQ(status, UDMF::E_OK);
299 stores = StoreCache::GetInstance().stores_.Size();
300 ASSERT_EQ(stores, 0);
301 }
302
303 /**
304 * @tc.name: OnUserChangeTest002
305 * @tc.desc: OnUserChange test
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(UdmfServiceImplTest, OnUserChangeTest002, TestSize.Level1)
310 {
311 // Clear store
312 StoreCache::GetInstance().CloseStores();
313 auto stores = StoreCache::GetInstance().stores_.Size();
314 ASSERT_EQ(stores, 0);
315 // Init store
316 StoreCache::GetInstance().GetStore(STORE_ID);
317 stores = StoreCache::GetInstance().stores_.Size();
318 ASSERT_EQ(stores, 1);
319
320 uint32_t code = static_cast<uint32_t>(DistributedData::AccountStatus::DEVICE_ACCOUNT_STOPPED);
321 std::string user = "OH_USER_test";
322 std::string account = "OH_ACCOUNT_test";
323 UdmfServiceImpl udmfServiceImpl;
324 auto status = udmfServiceImpl.OnUserChange(code, user, account);
325 ASSERT_EQ(status, UDMF::E_OK);
326 stores = StoreCache::GetInstance().stores_.Size();
327 ASSERT_EQ(stores, 0);
328 }
329
330 /**
331 * @tc.name: OnUserChangeTest003
332 * @tc.desc: OnUserChange test
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(UdmfServiceImplTest, OnUserChangeTest003, TestSize.Level1)
337 {
338 // Clear store
339 StoreCache::GetInstance().CloseStores();
340 auto stores = StoreCache::GetInstance().stores_.Size();
341 ASSERT_EQ(stores, 0);
342 // Init store
343 StoreCache::GetInstance().GetStore(STORE_ID);
344 stores = StoreCache::GetInstance().stores_.Size();
345 ASSERT_EQ(stores, 1);
346
347 uint32_t code = static_cast<uint32_t>(DistributedData::AccountStatus::DEVICE_ACCOUNT_SWITCHED);
348 std::string user = "OH_USER_test";
349 std::string account = "OH_ACCOUNT_test";
350 UdmfServiceImpl udmfServiceImpl;
351 auto status = udmfServiceImpl.OnUserChange(code, user, account);
352 ASSERT_EQ(status, UDMF::E_OK);
353 stores = StoreCache::GetInstance().stores_.Size();
354 ASSERT_EQ(stores, 0);
355 }
356
357 /**
358 * @tc.name: OnUserChangeTest004
359 * @tc.desc: OnUserChange test
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(UdmfServiceImplTest, OnUserChangeTest004, TestSize.Level1)
364 {
365 // Clear store
366 StoreCache::GetInstance().CloseStores();
367 auto stores = StoreCache::GetInstance().stores_.Size();
368 ASSERT_EQ(stores, 0);
369 // Init store
370 StoreCache::GetInstance().GetStore(STORE_ID);
371 stores = StoreCache::GetInstance().stores_.Size();
372 ASSERT_EQ(stores, 1);
373
374 uint32_t code = static_cast<uint32_t>(DistributedData::AccountStatus::DEVICE_ACCOUNT_UNLOCKED);
375 std::string user = "OH_USER_test";
376 std::string account = "OH_ACCOUNT_test";
377 UdmfServiceImpl udmfServiceImpl;
378 auto status = udmfServiceImpl.OnUserChange(code, user, account);
379 ASSERT_EQ(status, UDMF::E_OK);
380 stores = StoreCache::GetInstance().stores_.Size();
381 ASSERT_EQ(stores, 1);
382 }
383
384 /**
385 * @tc.name: SaveMetaData001
386 * @tc.desc: Abnormal testcase of GetRuntime
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(UdmfServiceImplTest, SaveMetaData001, TestSize.Level0)
391 {
392 auto store = std::make_shared<RuntimeStore>(STORE_ID);
393 bool result = store->Init();
394 EXPECT_TRUE(result);
395
396 result = store->Init();
397 EXPECT_TRUE(result);
398 }
399
400 /**
401 * @tc.name: SaveMetaData001
402 * @tc.desc: Abnormal testcase of GetRuntime
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(UdmfServiceImplTest, SyncTest001, TestSize.Level0)
407 {
408 QueryOption query;
409 query.key = "udmf://drag/ohos.test.demo1/_aS6adWi7<Dehfffffffffffffffff";
410 query.tokenId = 1;
411 query.intention = UD_INTENTION_DRAG;
412 UdmfServiceImpl udmfServiceImpl;
413 DistributedData::StoreMetaData meta = DistributedData::StoreMetaData("100", "distributeddata", "drag");
414 std::vector<std::string> devices = {"remote_device"};
415
416 auto ret = udmfServiceImpl.Sync(query, devices);
417 EXPECT_EQ(ret, UDMF::E_NO_PERMISSION);
418 }
419
420 /**
421 * @tc.name: ResolveAutoLaunch001
422 * @tc.desc: test ResolveAutoLaunch
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(UdmfServiceImplTest, ResolveAutoLaunch001, TestSize.Level0)
427 {
428 auto store = std::make_shared<RuntimeStore>(STORE_ID);
429 bool result = store->Init();
430 EXPECT_TRUE(result);
431
432 DistributedDB::AutoLaunchParam param {
433 .userId = "100",
434 .appId = "distributeddata",
435 .storeId = "drag",
436 };
437 std::string identifier = "identifier";
438 std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
439 auto ret = udmfServiceImpl->ResolveAutoLaunch(identifier, param);
440 EXPECT_EQ(ret, UDMF::E_OK);
441 }
442
443 /**
444 * @tc.name: TransferToEntriesIfNeedTest001
445 * @tc.desc: TransferToEntriesIfNeed test
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 HWTEST_F(UdmfServiceImplTest, TransferToEntriesIfNeedTest001, TestSize.Level1)
450 {
451 UnifiedData data;
452 QueryOption query;
453 auto record1 = std::make_shared<UnifiedRecord>();
454 auto record2 = std::make_shared<UnifiedRecord>();
455 data.AddRecord(record1);
456 data.AddRecord(record2);
457 auto properties = std::make_shared<UnifiedDataProperties>();
458 properties->tag = "records_to_entries_data_format";
459 data.SetProperties(properties);
460 query.tokenId = 1;
461 UdmfServiceImpl udmfServiceImpl;
462 udmfServiceImpl.TransferToEntriesIfNeed(query, data);
463 EXPECT_TRUE(data.IsNeedTransferToEntries());
464 int recordSize = 2;
465 EXPECT_EQ(data.GetRecords().size(), recordSize);
466 }
467 /**
468 * @tc.name: IsValidInput001
469 * @tc.desc: invalid unifiedData
470 * @tc.type: FUNC
471 */
472 HWTEST_F(UdmfServiceImplTest, IsValidInput001, TestSize.Level1)
473 {
474 QueryOption query;
475 UnifiedData unifiedData;
476 UnifiedKey key;
477
478 UdmfServiceImpl impl;
479 bool result = impl.IsValidInput(query, unifiedData, key);
480 EXPECT_FALSE(result);
481 }
482
483 /**
484 * @tc.name: IsValidInput002
485 * @tc.desc: invalid key
486 * @tc.type: FUNC
487 */
488 HWTEST_F(UdmfServiceImplTest, IsValidInput002, TestSize.Level1)
489 {
490 QueryOption query;
491 UnifiedData unifiedData;
492 auto record1 = std::make_shared<UnifiedRecord>();
493 auto record2 = std::make_shared<UnifiedRecord>();
494 unifiedData.AddRecord(record1);
495 unifiedData.AddRecord(record2);
496 UnifiedKey key;
497
498 UdmfServiceImpl impl;
499 bool result = impl.IsValidInput(query, unifiedData, key);
500 EXPECT_FALSE(result);
501 }
502
503 /**
504 * @tc.name: IsValidInput003
505 * @tc.desc: valid input
506 * @tc.type: FUNC
507 */
508 HWTEST_F(UdmfServiceImplTest, IsValidInput003, TestSize.Level1)
509 {
510 QueryOption query;
511 query.intention = Intention::UD_INTENTION_DATA_HUB;
512 query.key = "udmf://DataHub/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
513 UnifiedData unifiedData;
514 auto record1 = std::make_shared<UnifiedRecord>();
515 auto record2 = std::make_shared<UnifiedRecord>();
516 unifiedData.AddRecord(record1);
517 unifiedData.AddRecord(record2);
518 UnifiedKey key("udmf://DataHub/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7");
519 EXPECT_TRUE(key.IsValid());
520
521 UdmfServiceImpl impl;
522 bool result = impl.IsValidInput(query, unifiedData, key);
523 EXPECT_TRUE(result);
524 }
525
526 /**
527 * @tc.name: IsValidInput004
528 * @tc.desc: invalid intention
529 * @tc.type: FUNC
530 */
531 HWTEST_F(UdmfServiceImplTest, IsValidInput004, TestSize.Level1)
532 {
533 QueryOption query;
534 query.intention = Intention::UD_INTENTION_DRAG;
535 UnifiedData unifiedData;
536 UnifiedKey key("udmf://drag/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7");
537
538 UdmfServiceImpl impl;
539 bool result = impl.IsValidInput(query, unifiedData, key);
540 EXPECT_FALSE(result);
541 }
542
543 /**
544 * @tc.name: UpdateData002
545 * @tc.desc: invalid parameter
546 * @tc.type: FUNC
547 */
548 HWTEST_F(UdmfServiceImplTest, UpdateData002, TestSize.Level1)
549 {
550 QueryOption query;
551 query.intention = Intention::UD_INTENTION_DATA_HUB;
552 query.key = "udmf://DataHub/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
553 query.tokenId = 99999;
554 UnifiedData unifiedData;
555 auto record1 = std::make_shared<UnifiedRecord>();
556 auto record2 = std::make_shared<UnifiedRecord>();
557 unifiedData.AddRecord(record1);
558 unifiedData.AddRecord(record2);
559
560 UdmfServiceImpl impl;
561 EXPECT_NE(impl.UpdateData(query, unifiedData), E_OK);
562 }
563
564 /**
565 * @tc.name: UpdateData003
566 * @tc.desc: invalid parameter
567 * @tc.type: FUNC
568 */
569 HWTEST_F(UdmfServiceImplTest, UpdateData003, TestSize.Level1)
570 {
571 QueryOption query;
572 query.intention = Intention::UD_INTENTION_DATA_HUB;
573 query.key = "udmf://DataHub/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
574 query.tokenId = static_cast<uint32_t>(IPCSkeleton::GetCallingTokenID());
575 UnifiedData unifiedData;
576 auto record1 = std::make_shared<UnifiedRecord>();
577 auto record2 = std::make_shared<UnifiedRecord>();
578 unifiedData.AddRecord(record1);
579 unifiedData.AddRecord(record2);
580
581 UdmfServiceImpl impl;
582 EXPECT_NE(impl.UpdateData(query, unifiedData), E_OK);
583 }
584
585 /**
586 * @tc.name: UpdateData004
587 * @tc.desc: invalid parameter
588 * @tc.type: FUNC
589 */
590 HWTEST_F(UdmfServiceImplTest, UpdateData004, TestSize.Level1)
591 {
592 QueryOption query;
593 UnifiedData unifiedData;
594
595 query.key = "invalid_key";
596 UdmfServiceImpl impl;
597 EXPECT_EQ(impl.UpdateData(query, unifiedData), E_INVALID_PARAMETERS);
598 }
599
600 /**
601 * @tc.name: SaveData002
602 * @tc.desc: invalid parameter
603 * @tc.type: FUNC
604 */
605 HWTEST_F(UdmfServiceImplTest, SaveData002, TestSize.Level1)
606 {
607 CustomOption option;
608 QueryOption query;
609 UnifiedData unifiedData;
610 std::string key = "";
611
612 UdmfServiceImpl impl;
613 EXPECT_EQ(impl.SaveData(option, unifiedData, key), E_INVALID_PARAMETERS);
614 }
615
616 /**
617 * @tc.name: SaveData003
618 * @tc.desc: invalid parameter
619 * @tc.type: FUNC
620 */
621 HWTEST_F(UdmfServiceImplTest, SaveData003, TestSize.Level1)
622 {
623 CustomOption option;
624 QueryOption query;
625 UnifiedData unifiedData;
626 auto record1 = std::make_shared<UnifiedRecord>();
627 auto record2 = std::make_shared<UnifiedRecord>();
628 unifiedData.AddRecord(record1);
629 unifiedData.AddRecord(record2);
630 std::string key = "";
631 option.intention = Intention::UD_INTENTION_BASE;
632
633 UdmfServiceImpl impl;
634 EXPECT_EQ(impl.SaveData(option, unifiedData, key), E_INVALID_PARAMETERS);
635 }
636
637 /**
638 * @tc.name: SaveData004
639 * @tc.desc: invalid parameter
640 * @tc.type: FUNC
641 */
642 HWTEST_F(UdmfServiceImplTest, SaveData004, TestSize.Level1)
643 {
644 CustomOption option;
645 QueryOption query;
646 UnifiedData unifiedData;
647 auto record1 = std::make_shared<UnifiedRecord>();
648 auto record2 = std::make_shared<UnifiedRecord>();
649 unifiedData.AddRecord(record1);
650 unifiedData.AddRecord(record2);
651 std::string key = "";
652 option.intention = Intention::UD_INTENTION_DATA_HUB;
653 option.tokenId = 99999;
654
655 UdmfServiceImpl impl;
656 EXPECT_NE(impl.SaveData(option, unifiedData, key), E_OK);
657 }
658
659 /**
660 * @tc.name: IsValidInput005
661 * @tc.desc: valid input
662 * @tc.type: FUNC
663 */
664 HWTEST_F(UdmfServiceImplTest, IsValidInput005, TestSize.Level1)
665 {
666 QueryOption query;
667 query.intention = Intention::UD_INTENTION_DRAG;
668 query.key = "udmf://drag/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7";
669 UnifiedData unifiedData;
670 auto record1 = std::make_shared<UnifiedRecord>();
671 auto record2 = std::make_shared<UnifiedRecord>();
672 unifiedData.AddRecord(record1);
673 unifiedData.AddRecord(record2);
674 UnifiedKey key("udmf://drag/aaa/N]2fIEMbrJj@<hH7zpXzzQ>wp:jMuPa7");
675 EXPECT_TRUE(key.IsValid());
676
677 UdmfServiceImpl impl;
678 bool result = impl.IsValidInput(query, unifiedData, key);
679 EXPECT_FALSE(result);
680 }
681
682 /**
683 * @tc.name: PushDelayData001
684 * @tc.desc: valid input
685 * @tc.type: FUNC
686 */
687 HWTEST_F(UdmfServiceImplTest, PushDelayData001, TestSize.Level1)
688 {
689 UnifiedData unifiedData;
690 auto record1 = std::make_shared<UnifiedRecord>();
691 auto record2 = std::make_shared<UnifiedRecord>();
692 unifiedData.AddRecord(record1);
693 unifiedData.AddRecord(record2);
694 std::string key = "invalid key";
695
696 UdmfServiceImpl impl;
697 auto result = impl.PushDelayData(key, unifiedData);
698 EXPECT_NE(result, E_OK);
699 }
700
701 /**
702 * @tc.name: CheckAppId001
703 * @tc.desc: invalid bundleName
704 * @tc.type: FUNC
705 */
706 HWTEST_F(UdmfServiceImplTest, CheckAppId001, TestSize.Level1)
707 {
708 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
709 runtime->appId = "appId";
710 std::string bundleName = "ohos.test.demo1";
711
712 UdmfServiceImpl impl;
713 int32_t result = impl.CheckAppId(runtime, bundleName);
714 EXPECT_EQ(result, E_INVALID_PARAMETERS);
715 }
716
717 /**
718 * @tc.name: CheckAppId002
719 * @tc.desc: invalid runtime
720 * @tc.type: FUNC
721 */
722 HWTEST_F(UdmfServiceImplTest, CheckAppId002, TestSize.Level1)
723 {
724 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
725 std::string bundleName = "ohos.test.demo1";
726
727 UdmfServiceImpl impl;
728 int32_t result = impl.CheckAppId(runtime, bundleName);
729 EXPECT_EQ(result, E_INVALID_PARAMETERS);
730 }
731
732 /**
733 * @tc.name: CheckDeleteDataPermission001
734 * @tc.desc: runtime is null
735 * @tc.type: FUNC
736 */
737 HWTEST_F(UdmfServiceImplTest, CheckDeleteDataPermission001, TestSize.Level1)
738 {
739 std::string appId;
740 std::shared_ptr<Runtime> runtime;
741 QueryOption query;
742 UdmfServiceImpl impl;
743 bool ret = impl.CheckDeleteDataPermission(appId, runtime, query);
744 EXPECT_FALSE(ret);
745 }
746
747 /**
748 * @tc.name: CheckDeleteDataPermission002
749 * @tc.desc: query.tokenId is invalid
750 * @tc.type: FUNC
751 */
752 HWTEST_F(UdmfServiceImplTest, CheckDeleteDataPermission002, TestSize.Level1)
753 {
754 std::string appId;
755 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
756 runtime->tokenId = TOKEN_ID;
757 QueryOption query;
758 UdmfServiceImpl impl;
759 bool ret = impl.CheckDeleteDataPermission(appId, runtime, query);
760 EXPECT_FALSE(ret);
761 }
762
763 /**
764 * @tc.name: CheckDeleteDataPermission003
765 * @tc.desc: Normal test
766 * @tc.type: FUNC
767 */
768 HWTEST_F(UdmfServiceImplTest, CheckDeleteDataPermission003, TestSize.Level1)
769 {
770 std::string appId;
771 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
772 runtime->tokenId = TOKEN_ID;
773 QueryOption query;
774 query.tokenId = TOKEN_ID;
775 UdmfServiceImpl impl;
776 bool ret = impl.CheckDeleteDataPermission(appId, runtime, query);
777 EXPECT_TRUE(ret);
778 }
779
780 /**
781 * @tc.name: CheckDeleteDataPermission004
782 * @tc.desc: bundleName is empty
783 * @tc.type: FUNC
784 */
785 HWTEST_F(UdmfServiceImplTest, CheckDeleteDataPermission004, TestSize.Level1)
786 {
787 std::string appId;
788 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
789 runtime->appId = APP_ID;
790 QueryOption query;
791 query.tokenId = TOKEN_ID;
792 UdmfServiceImpl impl;
793 bool ret = impl.CheckDeleteDataPermission(appId, runtime, query);
794 EXPECT_FALSE(ret);
795 }
796
797 /**
798 * @tc.name: VerifyDataAccessPermission001
799 * @tc.desc: no permission
800 * @tc.type: FUNC
801 */
802 HWTEST_F(UdmfServiceImplTest, VerifyDataAccessPermission001, TestSize.Level1)
803 {
804 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
805 const QueryOption query;
806 UnifiedData unifiedData;
807
808 UdmfServiceImpl impl;
809 auto result = impl.VerifyDataAccessPermission(runtime, query, unifiedData);
810 EXPECT_EQ(result, E_NO_PERMISSION);
811 }
812
813 /**
814 * @tc.name: VerifyDataAccessPermission002
815 * @tc.desc: runtime is nullptr
816 * @tc.type: FUNC
817 */
818 HWTEST_F(UdmfServiceImplTest, VerifyDataAccessPermission002, TestSize.Level1)
819 {
820 std::shared_ptr<Runtime> runtime = std::make_shared<Runtime>();
821 Privilege privilege {
822 .tokenId = TOKEN_ID,
823 .readPermission = STORE_ID,
824 .writePermission = STORE_ID,
825 };
826 runtime->privileges = { privilege };
827 QueryOption query;
828 query.tokenId = TOKEN_ID;
829 UnifiedData unifiedData;
830
831 UdmfServiceImpl impl;
832 auto result = impl.VerifyDataAccessPermission(runtime, query, unifiedData);
833 EXPECT_EQ(runtime->privileges[0].tokenId, query.tokenId);
834 EXPECT_EQ(result, OHOS::UDMF::E_OK);
835 }
836 }; // namespace DistributedDataTest
837 }; // namespace OHOS::Test
838