1 /*
2 * Copyright (c) 2021-2022 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 <gtest/gtest.h>
17
18 #include "account_log_wrapper.h"
19 #define private public
20 #include "app_account_info.h"
21 #undef private
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::AccountSA;
27
28 namespace {
29 const std::string STRING_OWNER = "com.example.owner";
30 const std::string STRING_NAME = "name";
31 const std::string STRING_EXTRA_INFO = "extra_info";
32 const std::string STRING_BUNDLE_NAME = "com.example.third_party";
33 const std::string STRING_BUNDLE_NAME_TWO = "com.example.bundletwo";
34 const std::string STRING_ASSOCIATED_KEY = "associated_key";
35 const std::string STRING_ASSOCIATED_VALUE = "associated_value";
36 const std::string STRING_ASSOCIATED_DATA = "{\"associated_key\": \"associated_value\"}";
37 const std::string STRING_CREDENTIAL_TYPE = "password";
38 const std::string STRING_CREDENTIAL = "1024";
39 const std::string STRING_ACCOUNT_CREDENTIAL = "{\"password\": \"1024\"}";
40 const std::string STRING_TOKEN = "token123";
41 const std::string STRING_AUTH_TYPE = "getSocialData";
42 const std::string STRING_EMPTY = "";
43
44 const bool SYNC_ENABLE_TRUE = true;
45 const bool SYNC_ENABLE_FALSE = false;
46
47 constexpr std::size_t SIZE_ZERO = 0;
48 constexpr std::size_t SIZE_ONE = 1;
49 constexpr int32_t MAX_TOKEN_NUMBER = 128;
50 constexpr int32_t OVERLOAD_MAX_TOKEN_NUMBER = 135;
51 constexpr int32_t MAX_OAUTH_LIST_SIZE = 512;
52 } // namespace
53
54 class AppAccountInfoTest : public testing::Test {
55 public:
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
58 void SetUp(void) override;
59 void TearDown(void) override;
60 };
61
SetUpTestCase(void)62 void AppAccountInfoTest::SetUpTestCase(void)
63 {}
64
TearDownTestCase(void)65 void AppAccountInfoTest::TearDownTestCase(void)
66 {}
67
SetUp(void)68 void AppAccountInfoTest::SetUp(void) __attribute__((no_sanitize("cfi")))
69 {
70 testing::UnitTest *test = testing::UnitTest::GetInstance();
71 ASSERT_NE(test, nullptr);
72 const testing::TestInfo *testinfo = test->current_test_info();
73 ASSERT_NE(testinfo, nullptr);
74 string testCaseName = string(testinfo->name());
75 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
76 }
77
TearDown(void)78 void AppAccountInfoTest::TearDown(void)
79 {}
80
81 /**
82 * @tc.name: AppAccountInfo_GetOwner_0100
83 * @tc.desc: Get the owner with valid data.
84 * @tc.type: FUNC
85 * @tc.require: issueI4M8FW
86 */
87 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetOwner_0100, TestSize.Level0)
88 {
89 ACCOUNT_LOGI("AppAccountInfo_GetOwner_0100");
90
91 // make an owner
92 std::string owner = STRING_OWNER;
93
94 // make info with an owner
95 AppAccountInfo appAccountInfo;
96 appAccountInfo.owner_ = owner;
97
98 // get the owner
99 std::string ownerFromInfo;
100 appAccountInfo.GetOwner(ownerFromInfo);
101
102 // check the owner
103 EXPECT_EQ(owner, ownerFromInfo);
104 }
105
106 /**
107 * @tc.name: AppAccountInfo_SetOwner_0100
108 * @tc.desc: Set the owner with valid data.
109 * @tc.type: FUNC
110 * @tc.require: issueI4M8FW
111 */
112 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOwner_0100, TestSize.Level1)
113 {
114 ACCOUNT_LOGI("AppAccountInfo_SetOwner_0100");
115
116 // make an owner
117 std::string owner = STRING_OWNER;
118
119 // make info
120 AppAccountInfo appAccountInfo;
121
122 // set the owner
123 appAccountInfo.SetOwner(owner);
124
125 // check the owner
126 EXPECT_EQ(owner, appAccountInfo.owner_);
127 }
128
129 /**
130 * @tc.name: AppAccountInfo_GetName_0100
131 * @tc.desc: Get the name with valid data.
132 * @tc.type: FUNC
133 * @tc.require: issueI4M8FW
134 */
135 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetName_0100, TestSize.Level1)
136 {
137 ACCOUNT_LOGI("AppAccountInfo_GetName_0100");
138
139 // make a name
140 std::string name = STRING_NAME;
141
142 // make info with a name
143 AppAccountInfo appAccountInfo;
144 appAccountInfo.name_ = name;
145
146 // get the name
147 std::string nameFromInfo;
148 appAccountInfo.GetName(nameFromInfo);
149
150 // check the name
151 EXPECT_EQ(name, nameFromInfo);
152 }
153
154 /**
155 * @tc.name: AppAccountInfo_SetName_0100
156 * @tc.desc: Set the name with valid data.
157 * @tc.type: FUNC
158 * @tc.require: issueI4M8FW
159 */
160 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetName_0100, TestSize.Level1)
161 {
162 ACCOUNT_LOGI("AppAccountInfo_SetName_0100");
163
164 // make a name
165 std::string name = STRING_NAME;
166
167 // make info
168 AppAccountInfo appAccountInfo;
169
170 // set the name
171 appAccountInfo.SetName(name);
172
173 // check the name
174 EXPECT_EQ(name, appAccountInfo.name_);
175 }
176
177 /**
178 * @tc.name: AppAccountInfo_GetExtraInfo_0100
179 * @tc.desc: Get the extra info with valid data.
180 * @tc.type: FUNC
181 * @tc.require: issueI4M8FW
182 */
183 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetExtraInfo_0100, TestSize.Level1)
184 {
185 ACCOUNT_LOGI("AppAccountInfo_GetExtraInfo_0100");
186
187 // make extra info
188 std::string extraInfo = STRING_EXTRA_INFO;
189
190 // make info with extra info
191 AppAccountInfo appAccountInfo;
192 appAccountInfo.extraInfo_ = extraInfo;
193
194 // get the extra info
195 std::string extraInfoFromInfo;
196 appAccountInfo.GetExtraInfo(extraInfoFromInfo);
197
198 // check the extra info
199 EXPECT_EQ(extraInfo, extraInfoFromInfo);
200 }
201
202 /**
203 * @tc.name: AppAccountInfo_SetExtraInfo_0100
204 * @tc.desc: Set the extra info with valid data.
205 * @tc.type: FUNC
206 * @tc.require: issueI4M8FW
207 */
208 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetExtraInfo_0100, TestSize.Level1)
209 {
210 ACCOUNT_LOGI("AppAccountInfo_SetExtraInfo_0100");
211
212 // make extra info
213 std::string extraInfo = STRING_EXTRA_INFO;
214
215 // make info
216 AppAccountInfo appAccountInfo;
217
218 // set the extra info
219 appAccountInfo.SetExtraInfo(extraInfo);
220
221 // check the extra info
222 EXPECT_EQ(extraInfo, appAccountInfo.extraInfo_);
223 }
224
225 /**
226 * @tc.name: AppAccountInfo_EnableAppAccess_0100
227 * @tc.desc: Enable the app access with valid data.
228 * @tc.type: FUNC
229 * @tc.require: issueI4M8FW
230 */
231 HWTEST_F(AppAccountInfoTest, AppAccountInfo_EnableAppAccess_0100, TestSize.Level1)
232 {
233 ACCOUNT_LOGI("AppAccountInfo_EnableAppAccess_0100");
234
235 // make a bundle name
236 std::string bundleName = STRING_BUNDLE_NAME;
237
238 // make info
239 AppAccountInfo appAccountInfo;
240
241 // enable the app access
242 ErrCode result = appAccountInfo.EnableAppAccess(bundleName);
243 EXPECT_EQ(result, ERR_OK);
244
245 // check the app access
246 EXPECT_EQ(appAccountInfo.authorizedApps_.size(), SIZE_ONE);
247 EXPECT_EQ(bundleName, *(appAccountInfo.authorizedApps_.begin()));
248 }
249
250 /**
251 * @tc.name: AppAccountInfo_DisableAppAccess_0100
252 * @tc.desc: Disable the app access with valid data.
253 * @tc.type: FUNC
254 * @tc.require: issueI4M8FW
255 */
256 HWTEST_F(AppAccountInfoTest, AppAccountInfo_DisableAppAccess_0100, TestSize.Level1)
257 {
258 ACCOUNT_LOGI("AppAccountInfo_DisableAppAccess_0100");
259
260 // make a bundle name
261 std::string bundleName = STRING_BUNDLE_NAME;
262
263 // make info with a bundle name
264 AppAccountInfo appAccountInfo;
265 appAccountInfo.authorizedApps_.emplace(bundleName);
266
267 // disable the app access
268 ErrCode result = appAccountInfo.DisableAppAccess(bundleName);
269 EXPECT_EQ(result, ERR_OK);
270
271 // check the app access
272 EXPECT_EQ(appAccountInfo.authorizedApps_.size(), SIZE_ZERO);
273 }
274
275 /**
276 * @tc.name: AppAccountInfo_GetAuthorizedApps_0100
277 * @tc.desc: Get the authorized apps with valid data.
278 * @tc.type: FUNC
279 * @tc.require: issueI4M8FW
280 */
281 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetAuthorizedApps_0100, TestSize.Level1)
282 {
283 ACCOUNT_LOGI("AppAccountInfo_GetAuthorizedApps_0100");
284
285 // make a bundle name
286 std::string bundleName = STRING_BUNDLE_NAME;
287
288 // make authorized apps
289 std::set<std::string> apps;
290 apps.emplace(bundleName);
291
292 // make info with authorized apps
293 AppAccountInfo appAccountInfo;
294 appAccountInfo.authorizedApps_ = apps;
295
296 // get the authorized apps
297 std::set<std::string> appsFromInfo;
298 appAccountInfo.GetAuthorizedApps(appsFromInfo);
299
300 // check the authorized apps
301 EXPECT_EQ(appsFromInfo.size(), SIZE_ONE);
302 EXPECT_EQ(bundleName, *(appsFromInfo.begin()));
303 }
304
305 /**
306 * @tc.name: AppAccountInfo_SetAuthorizedApps_0100
307 * @tc.desc: Set the authorized apps with valid data.
308 * @tc.type: FUNC
309 * @tc.require: issueI4M8FW
310 */
311 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetAuthorizedApps_0100, TestSize.Level1)
312 {
313 ACCOUNT_LOGI("AppAccountInfo_SetAuthorizedApps_0100");
314
315 // make a bundle name
316 std::string bundleName = STRING_BUNDLE_NAME;
317
318 // make authorized apps
319 std::set<std::string> apps;
320 apps.emplace(bundleName);
321
322 // make info
323 AppAccountInfo appAccountInfo;
324
325 // set the authorized apps
326 appAccountInfo.SetAuthorizedApps(apps);
327
328 // check the authorized apps
329 EXPECT_EQ(appAccountInfo.authorizedApps_.size(), SIZE_ONE);
330 EXPECT_EQ(bundleName, *(appAccountInfo.authorizedApps_.begin()));
331 }
332
333 /**
334 * @tc.name: AppAccountInfo_GetSyncEnable_0100
335 * @tc.desc: Get the sync enable with valid data.
336 * @tc.type: FUNC
337 * @tc.require: issueI4M8FW
338 */
339 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetSyncEnable_0100, TestSize.Level1)
340 {
341 ACCOUNT_LOGI("AppAccountInfo_GetSyncEnable_0100");
342
343 // make sync enable
344 bool syncEnable = SYNC_ENABLE_TRUE;
345
346 // make info with sync enable
347 AppAccountInfo appAccountInfo;
348 appAccountInfo.syncEnable_ = syncEnable;
349
350 // get the sync enable
351 bool syncEnableFromInfo = SYNC_ENABLE_FALSE;
352 appAccountInfo.GetSyncEnable(syncEnableFromInfo);
353
354 // check the sync enable
355 EXPECT_EQ(syncEnable, syncEnableFromInfo);
356 }
357
358 /**
359 * @tc.name: AppAccountInfo_SetSyncEnable_0100
360 * @tc.desc: Set the sync enable with valid data.
361 * @tc.type: FUNC
362 * @tc.require: issueI4M8FW
363 */
364 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetSyncEnable_0100, TestSize.Level1)
365 {
366 ACCOUNT_LOGI("AppAccountInfo_SetSyncEnable_0100");
367
368 // make sync enable
369 bool syncEnable = SYNC_ENABLE_TRUE;
370
371 // make info
372 AppAccountInfo appAccountInfo;
373
374 // set the sync enable
375 appAccountInfo.SetSyncEnable(syncEnable);
376
377 // check the sync enable
378 EXPECT_EQ(syncEnable, appAccountInfo.syncEnable_);
379 }
380
381 /**
382 * @tc.name: AppAccountInfo_InitCustomData_0100
383 * @tc.desc: Set the custom data with valid data.
384 * @tc.type: FUNC
385 * @tc.require: issueI5RWXN
386 */
387 HWTEST_F(AppAccountInfoTest, AppAccountInfo_InitCustomData_0100, TestSize.Level1)
388 {
389 ACCOUNT_LOGI("AppAccountInfo_InitCustomData_0100");
390
391 // make custom data
392 std::map<std::string, std::string> customData;
393 customData.emplace(STRING_ASSOCIATED_KEY, STRING_ASSOCIATED_VALUE);
394
395 // make info
396 AppAccountInfo appAccountInfo;
397
398 ErrCode result = appAccountInfo.InitCustomData(customData);
399 EXPECT_EQ(result, ERR_OK);
400
401 std::string test_value;
402 appAccountInfo.GetAssociatedData(STRING_ASSOCIATED_KEY, test_value);
403
404 EXPECT_EQ(STRING_ASSOCIATED_VALUE, test_value);
405 }
406
407 /**
408 * @tc.name: AppAccountInfo_GetAssociatedData_0100
409 * @tc.desc: Get the associated data with valid data.
410 * @tc.type: FUNC
411 * @tc.require: issueI4M8FW
412 */
413 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetAssociatedData_0100, TestSize.Level1)
414 {
415 ACCOUNT_LOGI("AppAccountInfo_GetAssociatedData_0100");
416
417 // make associated data
418 std::string associatedData = STRING_ASSOCIATED_DATA;
419
420 // make info with associated data
421 AppAccountInfo appAccountInfo;
422 appAccountInfo.associatedData_ = associatedData;
423
424 // get the associated data
425 std::string value;
426 ErrCode result = appAccountInfo.GetAssociatedData(STRING_ASSOCIATED_KEY, value);
427 EXPECT_EQ(result, ERR_OK);
428
429 // check the associated value
430 EXPECT_EQ(value, STRING_ASSOCIATED_VALUE);
431 }
432
433 /**
434 * @tc.name: AppAccountInfo_SetAssociatedData_0100
435 * @tc.desc: Set the associated data with valid data.
436 * @tc.type: FUNC
437 * @tc.require: issueI4M8FW
438 */
439 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetAssociatedData_0100, TestSize.Level1)
440 {
441 ACCOUNT_LOGI("AppAccountInfo_SetAssociatedData_0100");
442
443 // make associated data
444 std::string key = STRING_ASSOCIATED_KEY;
445 std::string value = STRING_ASSOCIATED_VALUE;
446
447 // make info
448 AppAccountInfo appAccountInfo;
449
450 // set the associated data
451 ErrCode result = appAccountInfo.SetAssociatedData(key, value);
452 EXPECT_EQ(result, ERR_OK);
453
454 // check the associated data
455 auto jsonObject = Json::parse(appAccountInfo.associatedData_);
456 if (jsonObject.is_discarded()) {
457 jsonObject = Json::object();
458 }
459 EXPECT_NE(jsonObject.find(key), jsonObject.end());
460 EXPECT_EQ(value, jsonObject[key]);
461 }
462
463 /**
464 * @tc.name: AppAccountInfo_GetAccountCredential_0100
465 * @tc.desc: Get the account credential with valid data.
466 * @tc.type: FUNC
467 * @tc.require: issueI4M8FW
468 */
469 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetAccountCredential_0100, TestSize.Level1)
470 {
471 ACCOUNT_LOGI("AppAccountInfo_GetAccountCredential_0100");
472
473 // make account credential
474 std::string accountCredential = STRING_ACCOUNT_CREDENTIAL;
475
476 // make info with account credential
477 AppAccountInfo appAccountInfo;
478 appAccountInfo.accountCredential_ = accountCredential;
479
480 // get the credential
481 std::string credential;
482 ErrCode result = appAccountInfo.GetAccountCredential(STRING_CREDENTIAL_TYPE, credential);
483 EXPECT_EQ(result, ERR_OK);
484
485 // check the credential
486 EXPECT_EQ(credential, STRING_CREDENTIAL);
487 }
488
489 /**
490 * @tc.name: AppAccountInfo_SetAccountCredential_0100
491 * @tc.desc: Set the account credential with valid data.
492 * @tc.type: FUNC
493 * @tc.require: issueI4M8FW
494 */
495 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetAccountCredential_0100, TestSize.Level1)
496 {
497 ACCOUNT_LOGI("AppAccountInfo_SetAccountCredential_0100");
498
499 // make account credential
500 std::string type = STRING_CREDENTIAL_TYPE;
501 std::string credential = STRING_CREDENTIAL;
502
503 // make info
504 AppAccountInfo appAccountInfo;
505
506 // set the account credential
507 ErrCode result = appAccountInfo.SetAccountCredential(type, credential);
508 EXPECT_EQ(result, ERR_OK);
509
510 // check the account credential
511 auto jsonObject = Json::parse(appAccountInfo.accountCredential_);
512 if (jsonObject.is_discarded()) {
513 jsonObject = Json::object();
514 }
515 EXPECT_NE(jsonObject.find(type), jsonObject.end());
516 EXPECT_EQ(credential, jsonObject[type]);
517 }
518
519 /**
520 * @tc.name: AppAccountInfo_GetOAuthList_0100
521 * @tc.desc: Get a oauth list with non-existent auth type.
522 * @tc.type: FUNC
523 * @tc.require: issueI4M8FW
524 */
525 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetOAuthList_0100, TestSize.Level1)
526 {
527 ACCOUNT_LOGI("AppAccountInfo_GetOAuthList_0100");
528 AppAccountInfo appAccountInfo;
529 std::set<std::string> oauthList;
530 ErrCode result = appAccountInfo.GetOAuthList(STRING_AUTH_TYPE, oauthList);
531 EXPECT_EQ(result, ERR_OK);
532 EXPECT_TRUE(oauthList.empty());
533 }
534
535 /**
536 * @tc.name: AppAccountInfo_GetOAuthList_0200
537 * @tc.desc: Get a oauth list with existent auth type.
538 * @tc.type: FUNC
539 * @tc.require: issueI4M8FW
540 */
541 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetOAuthList_0200, TestSize.Level1)
542 {
543 ACCOUNT_LOGI("AppAccountInfo_GetOAuthList_0200");
544 AppAccountInfo appAccountInfo;
545 std::set<std::string> oauthList;
546 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, true);
547 EXPECT_EQ(result, ERR_OK);
548 result = appAccountInfo.GetOAuthList(STRING_AUTH_TYPE, oauthList);
549 EXPECT_EQ(result, ERR_OK);
550 EXPECT_FALSE(oauthList.empty());
551 }
552
553 /**
554 * @tc.name: AppAccountInfo_GetAllOAuthTokens_0100
555 * @tc.desc: Get a oauth list with existent auth type.
556 * @tc.type: FUNC
557 * @tc.require: issueI4M8FW
558 */
559 HWTEST_F(AppAccountInfoTest, AppAccountInfo_GetAllOAuthTokens_0100, TestSize.Level1)
560 {
561 ACCOUNT_LOGI("AppAccountInfo_GetAllOAuthTokens_0100");
562 AppAccountInfo appAccountInfo;
563 std::vector<OAuthTokenInfo> tokens;
564 ErrCode result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, STRING_TOKEN);
565 EXPECT_EQ(result, ERR_OK);
566 result = appAccountInfo.GetAllOAuthTokens(tokens);
567 EXPECT_EQ(result, ERR_OK);
568 ASSERT_EQ(tokens.size(), 1);
569 EXPECT_EQ(tokens[0].token, STRING_TOKEN);
570 }
571
572 /**
573 * @tc.name: AppAccountInfo_ReadTokenInfos_0100
574 * @tc.desc: ReadTokenInfos abnormal branch.
575 * @tc.type: FUNC
576 * @tc.require:
577 */
578 HWTEST_F(AppAccountInfoTest, AppAccountInfo_ReadTokenInfos_0100, TestSize.Level1)
579 {
580 AppAccountInfo appAccountInfo;
581 std::map<std::string, OAuthTokenInfo> tokenInfos;
582 for (int32_t i = 0; i < OVERLOAD_MAX_TOKEN_NUMBER; ++i) {
583 std::string key = STRING_AUTH_TYPE + std::to_string(i);
584 OAuthTokenInfo testOAuthTokenInfo;
585 testOAuthTokenInfo.authType = std::to_string(i);
586 tokenInfos[key] = testOAuthTokenInfo;
587 }
588 Parcel data;
589 EXPECT_EQ(appAccountInfo.WriteTokenInfos(tokenInfos, data), true);
590 EXPECT_EQ(appAccountInfo.ReadTokenInfos(tokenInfos, data), false);
591 }
592
593 /**
594 * @tc.name: AppAccountInfo_ReadTokenInfos_0200
595 * @tc.desc: ReadTokenInfos normal branch.
596 * @tc.type: FUNC
597 * @tc.require:
598 */
599 HWTEST_F(AppAccountInfoTest, AppAccountInfo_ReadTokenInfos_0200, TestSize.Level1)
600 {
601 AppAccountInfo appAccountInfo;
602 std::map<std::string, OAuthTokenInfo> tokenInfos;
603 Parcel data;
604 std::set<std::string> authList;
605 authList.insert(STRING_NAME);
606 uint32_t size = 1;
607 ASSERT_EQ(data.WriteUint32(size), true);
608 ASSERT_EQ(data.WriteString(STRING_AUTH_TYPE), true);
609 ASSERT_EQ(data.WriteString(STRING_TOKEN), true);
610 ASSERT_EQ(appAccountInfo.WriteStringSet(authList, data), true);
611 bool result = appAccountInfo.ReadTokenInfos(tokenInfos, data);
612 ASSERT_EQ(result, true);
613 ASSERT_EQ(tokenInfos.empty(), false);
614 ASSERT_EQ(tokenInfos[STRING_AUTH_TYPE].authType, STRING_AUTH_TYPE);
615 ASSERT_EQ(tokenInfos[STRING_AUTH_TYPE].token, STRING_TOKEN);
616 }
617
618 /**
619 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0100
620 * @tc.desc: Set oauth token visibility with non-existent auth type.
621 * @tc.type: FUNC
622 * @tc.require: issueI4M8FW
623 */
624 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0100, TestSize.Level1)
625 {
626 ACCOUNT_LOGI("AppAccountInfo_SetOAuthTokenVisibility_0100");
627 AppAccountInfo appAccountInfo;
628 bool isVisible = true;
629 for (int32_t i = 0; i < MAX_TOKEN_NUMBER; ++i) {
630 std::string key = STRING_AUTH_TYPE + std::to_string(i);
631 appAccountInfo.SetOAuthTokenVisibility(key, STRING_BUNDLE_NAME, true);
632 appAccountInfo.CheckOAuthTokenVisibility(key, STRING_BUNDLE_NAME, isVisible);
633 EXPECT_TRUE(isVisible);
634 }
635 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, true);
636 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_MAX_SIZE);
637 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible);
638 EXPECT_FALSE(isVisible);
639 }
640
641 /**
642 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0200
643 * @tc.desc: Set oauth token visibility with non-existent auth type.
644 * @tc.type: FUNC
645 * @tc.require: issueI4M8FW
646 */
647 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0200, TestSize.Level1)
648 {
649 ACCOUNT_LOGI("AppAccountInfo_SetOAuthTokenVisibility_0200");
650 AppAccountInfo appAccountInfo;
651 bool isVisible = true;
652 for (int32_t i = 0; i < MAX_OAUTH_LIST_SIZE; ++i) {
653 std::string key = STRING_BUNDLE_NAME + std::to_string(i);
654 appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, key, true);
655 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, key, isVisible);
656 EXPECT_TRUE(isVisible);
657 }
658 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, true);
659 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_LIST_MAX_SIZE);
660 result = appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible);
661 EXPECT_FALSE(isVisible);
662 }
663
664 /**
665 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0300
666 * @tc.desc: Set oauth token visibility with existent auth type.
667 * @tc.type: FUNC
668 * @tc.require: issueI4M8FW
669 */
670 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0300, TestSize.Level1)
671 {
672 ACCOUNT_LOGI("AppAccountInfo_SetOAuthTokenVisibility_0300");
673 AppAccountInfo appAccountInfo;
674 appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, true);
675 bool isVisible = false;
676 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible);
677 EXPECT_TRUE(isVisible);
678 appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME_TWO, true);
679 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME_TWO, isVisible);
680 EXPECT_TRUE(isVisible);
681 }
682
683 /**
684 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0400
685 * @tc.desc: Setoauthtokenvisibility success with bundlename is owner.
686 * @tc.type: FUNC
687 * @tc.require: issueI4M8FW
688 */
689 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0400, TestSize.Level1)
690 {
691 AppAccountInfo appAccountInfo;
692 appAccountInfo.owner_ = STRING_OWNER;
693 bool isVisible = false;
694 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_OWNER, isVisible);
695 ASSERT_EQ(result, ERR_OK);
696 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_OWNER, isVisible);
697 EXPECT_TRUE(isVisible);
698 }
699
700 /**
701 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0500
702 * @tc.desc: Setoauthtokenvisibility success with isVisible is false.
703 * @tc.type: FUNC
704 * @tc.require: issueI4M8FW
705 */
706 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0500, TestSize.Level1)
707 {
708 AppAccountInfo appAccountInfo;
709 bool isVisible = false;
710 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible);
711 ASSERT_EQ(result, ERR_OK);
712 appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible);
713 EXPECT_FALSE(isVisible);
714 }
715
716 /**
717 * @tc.name: AppAccountInfo_SetOAuthTokenVisibility_0600
718 * @tc.desc: Setoauthtokenvisibility failed with authType is not exist of func api9.
719 * @tc.type: FUNC
720 * @tc.require: issueI4M8FW
721 */
722 HWTEST_F(AppAccountInfoTest, AppAccountInfo_SetOAuthTokenVisibility_0600, TestSize.Level1)
723 {
724 AppAccountInfo appAccountInfo;
725 bool isVisible = false;
726 int32_t apiVersion = 9;
727 ErrCode result = appAccountInfo.SetOAuthTokenVisibility(
728 STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible, apiVersion);
729 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TYPE_NOT_EXIST);
730 result = appAccountInfo.CheckOAuthTokenVisibility(STRING_AUTH_TYPE, STRING_BUNDLE_NAME, isVisible, apiVersion);
731 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TYPE_NOT_EXIST);
732 }
733
734 /**
735 * @tc.name: AppAccountInfo_OAuthToken_0100
736 * @tc.desc: Get, set, delete oauth token.
737 * @tc.type: FUNC
738 * @tc.require: issueI4M8FW
739 */
740 HWTEST_F(AppAccountInfoTest, AppAccountInfo_OAuthToken_0100, TestSize.Level1)
741 {
742 ACCOUNT_LOGI("AppAccountInfo_GetOAuthToken_0100");
743 AppAccountInfo appAccountInfo;
744 std::string token;
745 ErrCode result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
746 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
747 token = STRING_TOKEN;
748 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
749 EXPECT_EQ(result, ERR_OK);
750 token = STRING_EMPTY;
751 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
752 EXPECT_EQ(result, ERR_OK);
753 EXPECT_EQ(token, STRING_TOKEN);
754 result = appAccountInfo.DeleteOAuthToken(STRING_AUTH_TYPE, token);
755 EXPECT_EQ(result, ERR_OK);
756 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
757 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
758 }
759
760 /**
761 * @tc.name: AppAccountInfo_OAuthToken_0200
762 * @tc.desc: Get, set, delete oauth token with api9 func, and test delete self token.
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(AppAccountInfoTest, AppAccountInfo_OAuthToken_0200, TestSize.Level1)
767 {
768 ACCOUNT_LOGI("AppAccountInfo_OAuthToken_0200");
769 AppAccountInfo appAccountInfo;
770 std::string token;
771 int32_t apiVersion = 9;
772 ErrCode result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
773 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
774 token = STRING_TOKEN;
775 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
776 EXPECT_EQ(result, ERR_OK);
777 token = STRING_EMPTY;
778 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
779 EXPECT_EQ(result, ERR_OK);
780 EXPECT_EQ(token, STRING_TOKEN);
781 result = appAccountInfo.DeleteAuthToken(STRING_AUTH_TYPE, token, true);
782 EXPECT_EQ(result, ERR_OK);
783 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
784 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
785 }
786
787 /**
788 * @tc.name: AppAccountInfo_OAuthToken_0300
789 * @tc.desc: Get, set, delete oauth token with api9 func, and test delete other token.
790 * @tc.type: FUNC
791 * @tc.require:
792 */
793 HWTEST_F(AppAccountInfoTest, AppAccountInfo_OAuthToken_0300, TestSize.Level1)
794 {
795 ACCOUNT_LOGI("AppAccountInfo_OAuthToken_0300");
796 AppAccountInfo appAccountInfo;
797 std::string token;
798 int32_t apiVersion = 9;
799 ErrCode result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
800 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
801 token = STRING_TOKEN;
802 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
803 EXPECT_EQ(result, ERR_OK);
804 token = STRING_EMPTY;
805 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
806 EXPECT_EQ(result, ERR_OK);
807 EXPECT_EQ(token, STRING_TOKEN);
808 result = appAccountInfo.DeleteAuthToken(STRING_AUTH_TYPE, token, false);
809 EXPECT_EQ(result, ERR_OK);
810 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
811 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
812 }
813
814 /**
815 * @tc.name: AppAccountInfo_OAuthToken_0400
816 * @tc.desc: Get, set, delete oauth token with api9 func, and test delete self invalid token.
817 * @tc.type: FUNC
818 * @tc.require:
819 */
820 HWTEST_F(AppAccountInfoTest, AppAccountInfo_OAuthToken_0400, TestSize.Level1)
821 {
822 ACCOUNT_LOGI("AppAccountInfo_OAuthToken_0400");
823 AppAccountInfo appAccountInfo;
824 std::string token;
825 int32_t apiVersion = 9;
826 ErrCode result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
827 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
828 token = STRING_TOKEN;
829 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
830 EXPECT_EQ(result, ERR_OK);
831 std::string newToken = "test_new_token";
832 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, newToken);
833 EXPECT_EQ(result, ERR_OK);
834 token = STRING_EMPTY;
835 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
836 EXPECT_EQ(result, ERR_OK);
837 EXPECT_EQ(token, newToken);
838 result = appAccountInfo.DeleteAuthToken(STRING_AUTH_TYPE, token, true);
839 EXPECT_EQ(result, ERR_OK);
840 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
841 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
842 }
843
844 /**
845 * @tc.name: AppAccountInfo_OAuthToken_0500
846 * @tc.desc: Get, set, delete oauth token with api9 func, and test delete other invalid token.
847 * @tc.type: FUNC
848 * @tc.require:
849 */
850 HWTEST_F(AppAccountInfoTest, AppAccountInfo_OAuthToken_0500, TestSize.Level1)
851 {
852 ACCOUNT_LOGI("AppAccountInfo_OAuthToken_0500");
853 AppAccountInfo appAccountInfo;
854 std::string token;
855 int32_t apiVersion = 9;
856 ErrCode result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token);
857 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
858 token = STRING_TOKEN;
859 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
860 EXPECT_EQ(result, ERR_OK);
861 std::string newToken = "test_new_token";
862 result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, newToken);
863 EXPECT_EQ(result, ERR_OK);
864 token = STRING_EMPTY;
865 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
866 EXPECT_EQ(result, ERR_OK);
867 EXPECT_EQ(token, newToken);
868 result = appAccountInfo.DeleteAuthToken(STRING_AUTH_TYPE, token, false);
869 EXPECT_EQ(result, ERR_OK);
870 result = appAccountInfo.GetOAuthToken(STRING_AUTH_TYPE, token, apiVersion);
871 EXPECT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_NOT_EXIST);
872 }
873
874 /**
875 * @tc.name: AppAccountInfo SetOAuthToken test
876 * @tc.desc: Func SetOAuthToken success with authType is in oauthTokens.
877 * @tc.type: FUNC
878 * @tc.require
879 */
880 HWTEST_F(AppAccountInfoTest, SetOAuthToken002, TestSize.Level0)
881 {
882 AppAccountInfo appAccountInfo;
883 OAuthTokenInfo oauthTokenInfo;
884 oauthTokenInfo.token = STRING_TOKEN;
885 std::string token = STRING_TOKEN;
886 appAccountInfo.oauthTokens_[STRING_AUTH_TYPE] = oauthTokenInfo;
887 ErrCode result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
888 ASSERT_EQ(result, ERR_OK);
889 ASSERT_EQ(appAccountInfo.oauthTokens_[STRING_AUTH_TYPE].token, token);
890 }
891
892 /**
893 * @tc.name: AppAccountInfo SetOAuthToken test
894 * @tc.desc: Func SetOAuthToken falied with oauthTokens oversize.
895 * @tc.type: FUNC
896 * @tc.require
897 */
898 HWTEST_F(AppAccountInfoTest, SetOAuthToken003, TestSize.Level0)
899 {
900 AppAccountInfo appAccountInfo;
901 OAuthTokenInfo oauthTokenInfo;
902 for (int i = 0; i <= MAX_TOKEN_NUMBER; i++) {
903 std::string key = STRING_AUTH_TYPE + std::to_string(i);
904 appAccountInfo.oauthTokens_[key] = oauthTokenInfo;
905 }
906 std::string token;
907 ErrCode result = appAccountInfo.SetOAuthToken(STRING_AUTH_TYPE, token);
908 ASSERT_EQ(result, ERR_APPACCOUNT_SERVICE_OAUTH_TOKEN_MAX_SIZE);
909 }
910
911 /**
912 * @tc.name: AppAccountInfo_Marshalling_0100
913 * @tc.desc: Marshalling Unmarshalling with valid data.
914 * @tc.type: FUNC
915 * @tc.require: issueI4M8FW
916 */
917 HWTEST_F(AppAccountInfoTest, AppAccountInfo_Marshalling_0100, TestSize.Level0)
918 {
919 ACCOUNT_LOGI("AppAccountInfo_Marshalling_0100");
920
921 // make some data
922 std::string owner = STRING_OWNER;
923 std::string name = STRING_NAME;
924 std::string extraInfo = STRING_EXTRA_INFO;
925 std::set<std::string> authorizedApps;
926 authorizedApps.emplace(STRING_OWNER);
927 bool syncEnable = SYNC_ENABLE_TRUE;
928 std::string associatedData = STRING_ASSOCIATED_DATA;
929 std::string accountCredential = STRING_ACCOUNT_CREDENTIAL;
930
931 // make info with an owner
932 AppAccountInfo appAccountInfo;
933
934 appAccountInfo.owner_ = owner;
935 appAccountInfo.name_ = name;
936 appAccountInfo.extraInfo_ = extraInfo;
937 appAccountInfo.authorizedApps_ = authorizedApps;
938 appAccountInfo.syncEnable_ = syncEnable;
939 appAccountInfo.associatedData_ = associatedData;
940 appAccountInfo.accountCredential_ = accountCredential;
941
942 // marshalling
943 Parcel parcel;
944 EXPECT_EQ(appAccountInfo.Marshalling(parcel), true);
945
946 // unmarshalling
947 auto infoPtr = AppAccountInfo::Unmarshalling(parcel);
948 EXPECT_NE(infoPtr, nullptr);
949
950 // check the data
951 EXPECT_EQ(owner, infoPtr->owner_);
952 EXPECT_EQ(name, infoPtr->name_);
953 EXPECT_EQ(extraInfo, infoPtr->extraInfo_);
954 EXPECT_EQ(authorizedApps.size(), infoPtr->authorizedApps_.size());
955 EXPECT_EQ(*(authorizedApps.begin()), *(infoPtr->authorizedApps_.begin()));
956 EXPECT_EQ(syncEnable, infoPtr->syncEnable_);
957 EXPECT_EQ(associatedData, infoPtr->associatedData_);
958 EXPECT_EQ(accountCredential, infoPtr->accountCredential_);
959 }
960
961 /**
962 * @tc.name: AppAccountInfo GetName test
963 * @tc.desc: Func GetName.
964 * @tc.type: FUNC
965 * @tc.require
966 */
967 HWTEST_F(AppAccountInfoTest, GetName001, TestSize.Level0)
968 {
969 AppAccountInfo testInfo;
970 testInfo.SetName("test");
971 EXPECT_EQ(testInfo.GetName(), "test");
972 testInfo.SetOwner("test");
973 EXPECT_EQ(testInfo.GetOwner(), "test");
974 }
975
976 /**
977 * @tc.name: AppAccountInfo WriteStringMap test
978 * @tc.desc: Func WriteStringMap.
979 * @tc.type: FUNC
980 * @tc.require
981 */
982 HWTEST_F(AppAccountInfoTest, WriteStringMap001, TestSize.Level0)
983 {
984 AppAccountInfo testInfo;
985 Parcel data;
986 std::map<std::string, std::string> stringSet;
987 std::map<std::string, std::string> stringMap;
988 stringSet["testkey"] = "testvalue";
989 EXPECT_EQ(testInfo.WriteStringMap(stringSet, data), true);
990 EXPECT_EQ(testInfo.ReadStringMap(stringMap, data), true);
991 EXPECT_EQ(stringMap["testkey"], "testvalue");
992 }