1 /*
2 * Copyright (c) 2023-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 <gtest/gtest.h>
17 #include <thread>
18 #include "account_error_no.h"
19 #include "account_log_wrapper.h"
20 #define private public
21 #include "domain_account_plugin_death_recipient.h"
22 #include "domain_account_plugin_service.h"
23 #include "domain_account_callback_service.h"
24 #include "domain_has_domain_info_callback.h"
25 #include "inner_domain_account_manager.h"
26 #undef private
27 #include "os_account_manager.h"
28 #include "mock_domain_account_callback_stub.h"
29 #include "mock_domain_plugin.h"
30 #include "mock_inner_os_account_manager.h"
31
32 namespace OHOS {
33 namespace AccountSA {
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS::AccountSA;
37 using namespace OHOS;
38 using namespace AccountSA;
39
40 namespace {
41 const std::string STRING_TEST_NAME = "name";
42 const std::string TEST_NO_DOUND_NAME = "test_no_bound_name";
43 const std::string TEST_DOMAIN_ACCOUNT_NAME = "test_domain_account_name";
44 const std::string TEST_DOMAIN = "test_domain";
45 const std::string TEST_ACCOUNT_ID = "test_account_id";
46 const std::int32_t MAIN_ACCOUNT_ID = 100;
47 const int32_t WAIT_TIME = 20;
48 const std::vector<uint8_t> TEST_TOKEN = {0};
49 const std::vector<uint8_t> TEST_PASSWORD = {0};
50 std::shared_ptr<MockDomainPlugin> g_plugin = std::make_shared<MockDomainPlugin>();
51 } // namespace
52
53 class DomainAccountManagerInnerServiceTest : public testing::Test {
54 public:
55 static void SetUpTestCase(void);
56 static void TearDownTestCase(void);
57 void SetUp();
58 void TearDown();
59 };
60
SetUpTestCase(void)61 void DomainAccountManagerInnerServiceTest::SetUpTestCase(void)
62 {}
63
TearDownTestCase(void)64 void DomainAccountManagerInnerServiceTest::TearDownTestCase(void)
65 {}
66
SetUp(void)67 void DomainAccountManagerInnerServiceTest::SetUp(void) __attribute__((no_sanitize("cfi")))
68 {
69 testing::UnitTest *test = testing::UnitTest::GetInstance();
70 ASSERT_NE(test, nullptr);
71 const testing::TestInfo *testinfo = test->current_test_info();
72 ASSERT_NE(testinfo, nullptr);
73 string testCaseName = string(testinfo->name());
74 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
75 }
76
TearDown(void)77 void DomainAccountManagerInnerServiceTest::TearDown(void)
78 {}
79
80 /**
81 * @tc.name: DomainAccountManagerInnerServiceTest001
82 * @tc.desc: Test Auth func with no loical id bound domain info.
83 * @tc.type: FUNC
84 * @tc.require: issueI64KAM
85 */
86 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest001, TestSize.Level1)
87 {
88 DomainAccountInfo domainInfo;
89 domainInfo.accountName_ = TEST_NO_DOUND_NAME;
90 domainInfo.domain_ = TEST_DOMAIN;
91 domainInfo.accountId_ = TEST_ACCOUNT_ID;
92
93 EXPECT_EQ(InnerDomainAccountManager::GetInstance().Auth(domainInfo, TEST_PASSWORD, nullptr), ERR_OK);
94 }
95
96 /**
97 * @tc.name: DomainAccountManagerInnerServiceTest002
98 * @tc.desc: Test Auth func with loical id has domain info.
99 * @tc.type: FUNC
100 * @tc.require: issueI64KAM
101 */
102 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest002, TestSize.Level1)
103 {
104 DomainAccountInfo domainInfo;
105 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
106 domainInfo.domain_ = TEST_DOMAIN;
107 domainInfo.accountId_ = TEST_ACCOUNT_ID;
108
109 EXPECT_EQ(InnerDomainAccountManager::GetInstance().Auth(domainInfo, TEST_PASSWORD, nullptr), ERR_OK);
110 }
111
112 /**
113 * @tc.name: DomainAccountManagerInnerServiceTest003
114 * @tc.desc: Test AuthWithPopup with current activated id is not exist.
115 * @tc.type: FUNC
116 * @tc.require: issueI64KAM
117 */
118 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest003, TestSize.Level1)
119 {
120 EXPECT_EQ(InnerDomainAccountManager::GetInstance().AuthWithPopup(0, nullptr),
121 ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR);
122 }
123
124 /**
125 * @tc.name: DomainAccountManagerInnerServiceTest004
126 * @tc.desc: Test AuthWithToken.
127 * @tc.type: FUNC
128 * @tc.require: issueI64KAM
129 */
130 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest004, TestSize.Level1)
131 {
132 EXPECT_EQ(InnerDomainAccountManager::GetInstance().AuthWithToken(MAIN_ACCOUNT_ID, TEST_TOKEN),
133 ERR_DOMAIN_ACCOUNT_SERVICE_NOT_DOMAIN_ACCOUNT);
134 }
135
136 /**
137 * @tc.name: DomainAccountManagerInnerServiceTest005
138 * @tc.desc: Test StartAuth with callback is nullptr.
139 * @tc.type: FUNC
140 * @tc.require: issueI64KAM
141 */
142 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest005, TestSize.Level1)
143 {
144 DomainAccountInfo domainInfo;
145 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
146 domainInfo.domain_ = TEST_DOMAIN;
147 domainInfo.accountId_ = TEST_ACCOUNT_ID;
148 EXPECT_EQ(InnerDomainAccountManager::GetInstance().StartAuth(
149 nullptr, domainInfo, TEST_TOKEN, nullptr, AUTH_WITH_CREDENTIAL_MODE), ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
150 }
151
152 /**
153 * @tc.name: DomainAccountManagerInnerServiceTest006
154 * @tc.desc: Test StartAuth with auth mode is invalid.
155 * @tc.type: FUNC
156 * @tc.require: issueI64KAM
157 */
158 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest006, TestSize.Level1)
159 {
160 DomainAccountInfo domainInfo;
161 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
162 domainInfo.domain_ = TEST_DOMAIN;
163 domainInfo.accountId_ = TEST_ACCOUNT_ID;
164 sptr<IDomainAccountPlugin> testPlugin = new (std::nothrow) DomainAccountPluginService(nullptr);
165 ASSERT_NE(testPlugin, nullptr);
166 sptr<IDomainAccountCallback> innerCallback = new (std::nothrow) InnerDomainAuthCallback(MAIN_ACCOUNT_ID, nullptr);
167 ASSERT_NE(innerCallback, nullptr);
168 EXPECT_EQ(InnerDomainAccountManager::GetInstance().StartAuth(testPlugin,
169 domainInfo, TEST_TOKEN, innerCallback, AUTH_MODE_END), ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
170 }
171
172 /**
173 * @tc.name: DomainAccountManagerInnerServiceTest007
174 * @tc.desc: Test RegisterPlugin with plugin is nullptr.
175 * @tc.type: FUNC
176 * @tc.require: issueI64KAM
177 */
178 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest007, TestSize.Level1)
179 {
180 EXPECT_EQ(InnerDomainAccountManager::GetInstance().RegisterPlugin(nullptr), ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
181 }
182
183 /**
184 * @tc.name: DomainAccountManagerInnerServiceTest008
185 * @tc.desc: Test GetAuthStatusInfo with plugin is nullptr.
186 * @tc.type: FUNC
187 * @tc.require: issueI64KAM
188 */
189 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest008, TestSize.Level1)
190 {
191 DomainAccountInfo domainInfo;
192 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
193 domainInfo.domain_ = TEST_DOMAIN;
194 domainInfo.accountId_ = TEST_ACCOUNT_ID;
195 int32_t res = InnerDomainAccountManager::GetInstance().GetAuthStatusInfo(domainInfo, nullptr);
196 if (InnerDomainAccountManager::GetInstance().plugin_ != nullptr) {
197 EXPECT_EQ(res, ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST);
198 } else {
199 EXPECT_EQ(res, ERR_OK);
200 }
201 }
202
203 /**
204 * @tc.name: DomainAccountManagerInnerServiceTest009
205 * @tc.desc: Test GetAuthStatusInfo with plugin is nullptr.
206 * @tc.type: FUNC
207 * @tc.require: issueI64KAM
208 */
209 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest009, TestSize.Level1)
210 {
211 GetDomainAccountInfoOptions options;
212 options.accountInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
213 options.accountInfo.domain_ = TEST_DOMAIN;
214 EXPECT_EQ(InnerDomainAccountManager::GetInstance().StartHasDomainAccount(nullptr, options, nullptr),
215 ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
216 }
217
218 /**
219 * @tc.name: DomainAccountManagerInnerServiceTest010
220 * @tc.desc: Test StartOnAccountBound with plugin is nullptr.
221 * @tc.type: FUNC
222 * @tc.require: issueI64KAM
223 */
224 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest010, TestSize.Level1)
225 {
226 DomainAccountInfo domainInfo;
227 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
228 domainInfo.domain_ = TEST_DOMAIN;
229 domainInfo.accountId_ = TEST_ACCOUNT_ID;
230 auto callback = std::make_shared<MockDomainAccountCallback>();
231 ASSERT_NE(callback, nullptr);
232 EXPECT_CALL(*callback, OnResult(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST, _)).Times(Exactly(1));
233 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
234 ASSERT_NE(testCallback, nullptr);
235 InnerDomainAccountManager::GetInstance().StartOnAccountBound(nullptr, domainInfo, MAIN_ACCOUNT_ID, testCallback);
236 }
237
238 /**
239 * @tc.name: DomainAccountManagerInnerServiceTest011
240 * @tc.desc: Test StartOnAccountUnBound with plugin is nullptr.
241 * @tc.type: FUNC
242 * @tc.require: issueI64KAM
243 */
244 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest011, TestSize.Level1)
245 {
246 DomainAccountInfo domainInfo;
247 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
248 domainInfo.domain_ = TEST_DOMAIN;
249 domainInfo.accountId_ = TEST_ACCOUNT_ID;
250 auto callback = std::make_shared<MockDomainAccountCallback>();
251 ASSERT_NE(callback, nullptr);
252 EXPECT_CALL(*callback, OnResult(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST, _)).Times(Exactly(1));
253 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
254 ASSERT_NE(testCallback, nullptr);
255 InnerDomainAccountManager::GetInstance().StartOnAccountUnBound(nullptr, domainInfo, testCallback);
256 }
257
258 /**
259 * @tc.name: DomainAccountManagerInnerServiceTest012
260 * @tc.desc: Test StartGetDomainAccountInfo with plugin is nullptr.
261 * @tc.type: FUNC
262 * @tc.require: issueI64KAM
263 */
264 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest012, TestSize.Level1)
265 {
266 auto callback = std::make_shared<MockDomainAccountCallback>();
267 ASSERT_NE(callback, nullptr);
268 EXPECT_CALL(*callback, OnResult(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST, _)).Times(Exactly(1));
269 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
270 ASSERT_NE(testCallback, nullptr);
271 GetDomainAccountInfoOptions options;
272 options.accountInfo.domain_ = TEST_DOMAIN;
273 options.accountInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
274 InnerDomainAccountManager::GetInstance().StartGetDomainAccountInfo(nullptr, options, testCallback);
275 }
276
277 /**
278 * @tc.name: DomainAccountManagerInnerServiceTest013
279 * @tc.desc: Test GetAccessToken callback is nullptr.
280 * @tc.type: FUNC
281 * @tc.require: issueI64KAM
282 */
283 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest013, TestSize.Level1)
284 {
285 DomainAccountInfo info;
286 AAFwk::WantParams parameters;
287 ASSERT_EQ(InnerDomainAccountManager::GetInstance().GetAccessToken(info, parameters, nullptr),
288 ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
289 }
290
291 /**
292 * @tc.name: DomainAccountManagerInnerServiceTest014
293 * @tc.desc: Test StartGetAccessToken callback is nullptr.
294 * @tc.type: FUNC
295 * @tc.require: issueI64KAM
296 */
297 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest014, TestSize.Level1)
298 {
299 DomainAccountInfo info;
300 AAFwk::WantParams parameters;
301 std::vector<uint8_t> accountToken;
302 GetAccessTokenOptions option;
303 ASSERT_EQ(
304 InnerDomainAccountManager::GetInstance().StartGetAccessToken(nullptr, accountToken, info, option, nullptr),
305 ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
306 }
307
308 /**
309 * @tc.name: DomainAccountManagerInnerServiceTest015
310 * @tc.desc: Test StartGetAccessToken plugin is nullptr.
311 * @tc.type: FUNC
312 * @tc.require: issueI64KAM
313 */
314 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest015, TestSize.Level1)
315 {
316 std::vector<uint8_t> accountToken;
317 DomainAccountInfo info;
318 bool isValid = false;
319 InnerDomainAccountManager::GetInstance().plugin_ = nullptr;
320 ASSERT_EQ(InnerDomainAccountManager::GetInstance().CheckUserToken(accountToken, isValid, info),
321 ConvertToJSErrCode(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST));
322 }
323
324 /**
325 * @tc.name: DomainAccountManagerInnerServiceTest016
326 * @tc.desc: Test GetAuthStatusInfo callback is nullptr.
327 * @tc.type: FUNC
328 * @tc.require: issueI64KAM
329 */
330 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest016, TestSize.Level1)
331 {
332 DomainAccountInfo info;
333 int32_t res = InnerDomainAccountManager::GetInstance().GetAuthStatusInfo(info, nullptr);
334 if (InnerDomainAccountManager::GetInstance().plugin_ != nullptr) {
335 EXPECT_EQ(res, ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST);
336 } else {
337 EXPECT_EQ(res, ERR_OK);
338 }
339 }
340
341 /**
342 * @tc.name: DomainAccountManagerInnerServiceTest017
343 * @tc.desc: Test GetAuthStatusInfo success.
344 * @tc.type: FUNC
345 * @tc.require: issueI64KAM
346 */
347 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest017, TestSize.Level1)
348 {
349 DomainAccountInfo info;
350 int32_t res = InnerDomainAccountManager::GetInstance().GetAuthStatusInfo(info, nullptr);
351 if (InnerDomainAccountManager::GetInstance().plugin_ != nullptr) {
352 EXPECT_EQ(res, ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST);
353 } else {
354 EXPECT_EQ(res, ERR_OK);
355 }
356 }
357
358 /**
359 * @tc.name: DomainAccountManagerInnerServiceTest018
360 * @tc.desc: Test GetAuthStatusInfo success.
361 * @tc.type: FUNC
362 * @tc.require: issueI64KAM
363 */
364 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest018, TestSize.Level1)
365 {
366 GetDomainAccountInfoOptions options;
367 ASSERT_EQ(InnerDomainAccountManager::GetInstance().StartHasDomainAccount(nullptr, options, nullptr),
368 ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
369 }
370
371 /**
372 * @tc.name: DomainAccountManagerInnerServiceTest019
373 * @tc.desc: Test StartOnAccountBound plugin is nullptr.
374 * @tc.type: FUNC
375 * @tc.require: issueI64KAM
376 */
377 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest019, TestSize.Level1)
378 {
379 DomainAccountInfo info;
380 int32_t localId = 1;
381 auto callback = std::make_shared<MockDomainAccountCallback>();
382 ASSERT_NE(callback, nullptr);
383 EXPECT_CALL(*callback, OnResult(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST, _)).Times(Exactly(1));
384 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
385 ASSERT_NE(testCallback, nullptr);
386 InnerDomainAccountManager::GetInstance().StartOnAccountBound(nullptr, info, localId, testCallback);
387 }
388
389 /**
390 * @tc.name: DomainAccountManagerInnerServiceTest020
391 * @tc.desc: Test StartGetDomainAccountInfo plugin is nullptr.
392 * @tc.type: FUNC
393 * @tc.require: issueI64KAM
394 */
395 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest020, TestSize.Level1)
396 {
397 GetDomainAccountInfoOptions options;
398 options.accountInfo.accountName_ = "test";
399 options.accountInfo.domain_ = "test";
400 auto callback = std::make_shared<MockDomainAccountCallback>();
401 ASSERT_NE(callback, nullptr);
402 EXPECT_CALL(*callback, OnResult(ERR_DOMAIN_ACCOUNT_SERVICE_PLUGIN_NOT_EXIST, _)).Times(Exactly(1));
403 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
404 ASSERT_NE(testCallback, nullptr);
405 InnerDomainAccountManager::GetInstance().StartGetDomainAccountInfo(nullptr, options, testCallback);
406 }
407
408 /**
409 * @tc.name: DomainAccountManagerInnerServiceTest021
410 * @tc.desc: Test IsAccountTokenValid success.
411 * @tc.type: FUNC
412 * @tc.require: issueI64KAM
413 */
414 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest021, TestSize.Level1)
415 {
416 DomainAccountInfo info;
417 std::vector<uint8_t> token;
418 auto callback = std::make_shared<MockDomainAccountCallback>();
419 ASSERT_NE(callback, nullptr);
420 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
421 ASSERT_NE(testCallback, nullptr);
422 ASSERT_EQ(InnerDomainAccountManager::GetInstance().IsAccountTokenValid(info, token, nullptr), ERR_OK);
423 }
424
425 /**
426 * @tc.name: DomainAccountManagerInnerServiceTest022
427 * @tc.desc: Test StartIsAccountTokenValid with plugin is not nullptr.
428 * @tc.type: FUNC
429 * @tc.require: issueI64KAM
430 */
431 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest022, TestSize.Level1)
432 {
433 DomainAccountInfo domainInfo;
434 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
435 domainInfo.domain_ = TEST_DOMAIN;
436 domainInfo.accountId_ = TEST_ACCOUNT_ID;
437 auto callback = std::make_shared<MockDomainAccountCallback>();
438 ASSERT_NE(callback, nullptr);
439 EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
440 sptr<MockDomainAccountCallbackStub> testCallback = new (std::nothrow) MockDomainAccountCallbackStub(callback);
441 ASSERT_NE(testCallback, nullptr);
442 std::vector<uint8_t> token;
443 sptr<DomainAccountPluginService> pluginService = new (std::nothrow) DomainAccountPluginService(g_plugin);
444 ASSERT_NE(pluginService, nullptr);
445 InnerDomainAccountManager::GetInstance().StartIsAccountTokenValid(pluginService, domainInfo, token, testCallback);
446 std::unique_lock<std::mutex> lock(testCallback->mutex);
447 testCallback->cv.wait_for(
__anon3f97eba30202() 448 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
449 }
450
451 /**
452 * @tc.name: DomainAccountManagerInnerServiceTest023
453 * @tc.desc: Test GetAuthStatusInfo with plugin is not nullptr.
454 * @tc.type: FUNC
455 * @tc.require: issueI64KAM
456 */
457 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest023, TestSize.Level1)
458 {
459 DomainAccountInfo domainInfo;
460 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
461 domainInfo.domain_ = TEST_DOMAIN;
462 domainInfo.accountId_ = TEST_ACCOUNT_ID;
463 sptr<DomainAccountPluginService> pluginService = new (std::nothrow) DomainAccountPluginService(g_plugin);
464 ASSERT_NE(pluginService, nullptr);
465 InnerDomainAccountManager::GetInstance().plugin_ = pluginService;
466 EXPECT_EQ(InnerDomainAccountManager::GetInstance().GetAuthStatusInfo(domainInfo, nullptr), ERR_OK);
467 }
468
469 /**
470 * @tc.name: DomainAccountManagerInnerServiceTest024
471 * @tc.desc: Test StartAuth with plugin is not nullptr.
472 * @tc.type: FUNC
473 * @tc.require: issueI64KAM
474 */
475 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest024, TestSize.Level1)
476 {
477 DomainAccountInfo domainInfo;
478 domainInfo.accountName_ = TEST_DOMAIN_ACCOUNT_NAME;
479 domainInfo.domain_ = TEST_DOMAIN;
480 domainInfo.accountId_ = TEST_ACCOUNT_ID;
481 std::vector<uint8_t> authData;
482 std::shared_ptr<DomainAccountCallback> callback = nullptr;
483 sptr<DomainAccountCallbackService> callbackService = new (std::nothrow) DomainAccountCallbackService(callback);
484 ASSERT_NE(callbackService, nullptr);
485 sptr<DomainAccountPluginService> pluginService = new (std::nothrow) DomainAccountPluginService(g_plugin);
486 ASSERT_NE(pluginService, nullptr);
487 EXPECT_EQ(InnerDomainAccountManager::GetInstance().StartAuth(
488 pluginService, domainInfo, authData, callbackService, AUTH_WITH_TOKEN_MODE), ERR_OK);
489 EXPECT_EQ(InnerDomainAccountManager::GetInstance().StartAuth(
490 pluginService, domainInfo, authData, callbackService, AUTH_MODE_END), ERR_ACCOUNT_COMMON_INVALID_PARAMETER);
491 }
492
493 /**
494 * @tc.name: DomainAccountManagerInnerServiceTest025
495 * @tc.desc: LoaderLib CloseLib.
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest025, TestSize.Level0)
500 {
501 InnerDomainAccountManager *instance = new (std::nothrow) InnerDomainAccountManager();
502 instance->libHandle_ = nullptr;
503 std::string rightPath = "/rightPath/";
504 std::string rightSoName = "right.z.so";
505 //LoadLib success
506 instance->LoaderLib(rightPath, rightSoName);
507 EXPECT_NE(instance->libHandle_, nullptr);
508 //CloseLib path
509 instance->CloseLib();
510 EXPECT_EQ(instance->libHandle_, nullptr);
511 //CloseLib path libHandle_ nullper
512 instance->CloseLib();
513 EXPECT_EQ(instance->libHandle_, nullptr);
514 //empty libName
515 instance->LoaderLib(rightPath, "");
516 EXPECT_EQ(instance->libHandle_, nullptr);
517 //error path
518 instance->LoaderLib("/", rightSoName);
519 EXPECT_EQ(instance->libHandle_, nullptr);
520 //error libName
521 std::string errorlibName = "error.z.so";
522 instance->LoaderLib(rightPath, errorlibName);
523 EXPECT_EQ(instance->libHandle_, nullptr);
524 //not legal so
525 std::string notLegalLibName = "leg.z.so";
526 instance->LoaderLib(rightPath, notLegalLibName);
527 EXPECT_EQ(instance->libHandle_, nullptr);
528 //empty path
529 instance->LoaderLib("", rightSoName);
530 EXPECT_NE(instance->libHandle_, nullptr);
531 //clear
532 instance->CloseLib();
533 }
534
535 /**
536 * @tc.name: DomainAccountManagerInnerServiceTest026
537 * @tc.desc: AddServerConfig.
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest026, TestSize.Level0)
542 {
543 InnerDomainAccountManager *instance = new (std::nothrow) InnerDomainAccountManager();
544 DomainServerConfig config;
545 std::string identifier;
546 //libHandle_ is null
547 EXPECT_EQ(instance->AddServerConfig(identifier, config), ERR_JS_CAPABILITY_NOT_SUPPORTED);
548 DomainAccountInfo info;
549 EXPECT_EQ(instance->GetAccountServerConfig(info, config), ERR_JS_CAPABILITY_NOT_SUPPORTED);
550 std::string configId = STRING_TEST_NAME;
551 EXPECT_EQ(instance->RemoveServerConfig(configId), ERR_JS_CAPABILITY_NOT_SUPPORTED);
552 std::vector<uint8_t> password;
553 DomainAuthResult resultParcel;
554 EXPECT_EQ(instance->PluginAuth(info, password, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
555 EXPECT_EQ(instance->PluginBindAccount(info, 100, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
556 EXPECT_EQ(instance->PluginUnBindAccount(info, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
557 int32_t isVaild;
558 EXPECT_EQ(instance->PluginIsAccountTokenValid(info, password, isVaild), ERR_JS_CAPABILITY_NOT_SUPPORTED);
559 GetAccessTokenOptions option;
560 EXPECT_EQ(instance->PluginGetAccessToken(option, password, info, resultParcel),
561 ERR_JS_CAPABILITY_NOT_SUPPORTED);
562 EXPECT_EQ(instance->PluginAuthWithPopup(info, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
563 EXPECT_EQ(instance->PluginAuthToken(info, password, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
564 AuthStatusInfo authInfo;
565 EXPECT_EQ(instance->PluginGetAuthStatusInfo(info, authInfo), ERR_JS_CAPABILITY_NOT_SUPPORTED);
566 GetDomainAccountInfoOptions options;
567 EXPECT_EQ(instance->PluginGetDomainAccountInfo(options, info), ERR_JS_CAPABILITY_NOT_SUPPORTED);
568 }
569
570 /**
571 * @tc.name: DomainAccountManagerInnerServiceTest027
572 * @tc.desc: AddServerConfig.
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest027, TestSize.Level0)
577 {
578 InnerDomainAccountManager *instance = new (std::nothrow) InnerDomainAccountManager();
579 DomainServerConfig config;
580 std::string identifier;
581 DomainAccountInfo info;
582 std::string configId = STRING_TEST_NAME;
583 std::vector<uint8_t> password;
584 DomainAuthResult resultParcel;
585 int32_t isVaild;
586 GetAccessTokenOptions option;
587 AuthStatusInfo authInfo;
588 GetDomainAccountInfoOptions options;
589 std::string rightPath = "/rightPath/";
590 std::string rightSoName = "right.z.so";
591 //LoadLib success
592 instance->LoaderLib(rightPath, rightSoName);
593 info.accountId_ = STRING_TEST_NAME;
594 info.domain_ = STRING_TEST_NAME;
595 info.accountName_ = STRING_TEST_NAME;
596 info.serverConfigId_ = STRING_TEST_NAME;
597 info.isAuthenticated = 0;
598 EXPECT_EQ(instance->AddServerConfig(identifier, config), ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR);
599 EXPECT_EQ(instance->GetAccountServerConfig(info, config), ERR_DOMAIN_ACCOUNT_SERVICE_NOT_DOMAIN_ACCOUNT);
600 EXPECT_EQ(instance->RemoveServerConfig(configId), ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR);
601 EXPECT_EQ(instance->PluginAuth(info, password, resultParcel), ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR);
602 EXPECT_EQ(instance->PluginBindAccount(info, 100, resultParcel), ERR_OK);
603 EXPECT_EQ(instance->PluginUnBindAccount(info, resultParcel), ERR_OK);
604 password.push_back(0);
605 EXPECT_EQ(instance->PluginIsAccountTokenValid(info, password, isVaild), ERR_OK);
606 EXPECT_EQ(instance->PluginGetAccessToken(option, password, info, resultParcel), ERR_OK);
607 option.callingUid_ = 1;
608 EXPECT_EQ(instance->PluginGetAccessToken(option, password, info, resultParcel), ERR_OK);
609 EXPECT_EQ(instance->PluginAuthWithPopup(info, resultParcel), ERR_OK);
610 EXPECT_EQ(instance->PluginAuthToken(info, password, resultParcel), ERR_OK);
611 EXPECT_EQ(instance->PluginGetAuthStatusInfo(info, authInfo), ERR_OK);
612 EXPECT_EQ(instance->PluginGetDomainAccountInfo(options, info), ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR);
613 }
614
615 /**
616 * @tc.name: DomainAccountManagerInnerServiceTest028
617 * @tc.desc: AddServerConfig.
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(DomainAccountManagerInnerServiceTest, DomainAccountManagerInnerServiceTest028, TestSize.Level0)
622 {
623 InnerDomainAccountManager *instance = new (std::nothrow) InnerDomainAccountManager();
624 DomainServerConfig config;
625 std::string identifier;
626 DomainAccountInfo info;
627 std::string configId = STRING_TEST_NAME;
628 std::vector<uint8_t> password;
629 DomainAuthResult resultParcel;
630 int32_t isVaild;
631 GetAccessTokenOptions option;
632 AuthStatusInfo authInfo;
633 GetDomainAccountInfoOptions options;
634 std::string rightPath = "/rightPath/";
635 std::string rightSoName = "right.z.so";
636 //LoadLib success
637 instance->LoaderLib(rightPath, rightSoName);
638 info.accountId_ = STRING_TEST_NAME;
639 info.domain_ = STRING_TEST_NAME;
640 info.accountName_ = STRING_TEST_NAME;
641 info.serverConfigId_ = STRING_TEST_NAME;
642 info.isAuthenticated = 0;
643 password.push_back(0);
644 option.callingUid_ = 1;
645 instance->methodMap_.clear();
646 EXPECT_EQ(instance->AddServerConfig(identifier, config), ERR_JS_CAPABILITY_NOT_SUPPORTED);
647 EXPECT_EQ(instance->GetAccountServerConfig(info, config), ERR_JS_CAPABILITY_NOT_SUPPORTED);
648 EXPECT_EQ(instance->RemoveServerConfig(configId), ERR_JS_CAPABILITY_NOT_SUPPORTED);
649 EXPECT_EQ(instance->PluginAuth(info, password, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
650 EXPECT_EQ(instance->PluginBindAccount(info, 100, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
651 EXPECT_EQ(instance->PluginUnBindAccount(info, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
652 EXPECT_EQ(instance->PluginIsAccountTokenValid(info, password, isVaild),
653 ERR_JS_CAPABILITY_NOT_SUPPORTED);
654 EXPECT_EQ(instance->PluginGetAccessToken(option, password, info, resultParcel),
655 ERR_JS_CAPABILITY_NOT_SUPPORTED);
656 EXPECT_EQ(instance->PluginAuthWithPopup(info, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
657 EXPECT_EQ(instance->PluginAuthToken(info, password, resultParcel), ERR_JS_CAPABILITY_NOT_SUPPORTED);
658 EXPECT_EQ(instance->PluginGetAuthStatusInfo(info, authInfo), ERR_JS_CAPABILITY_NOT_SUPPORTED);
659 EXPECT_EQ(instance->PluginGetDomainAccountInfo(options, info), ERR_JS_CAPABILITY_NOT_SUPPORTED);
660 }
661 } // namespace AccountSA
662 } // namespace OHOS