1 /*
2 * Copyright (c) 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 "accesstoken_kit.h"
17 #define private public
18 #include "account_iam_callback_service.h"
19 #undef private
20 #include "account_iam_client.h"
21 #include "account_iam_client_test_callback.h"
22 #include "account_log_wrapper.h"
23 #include "account_test_common.h"
24 #include "ipc_skeleton.h"
25 #include "test_common.h"
26 #include "token_setproc.h"
27
28 namespace OHOS {
29 namespace AccountTest {
30 namespace {
31 const int32_t TEST_USER_ID = 200;
32 const int32_t WAIT_TIME = 20;
33 static uint64_t g_selfTokenID;
34 }
35
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::AccountSA;
39 using namespace OHOS::Security::AccessToken;
40
41 #ifdef HAS_PIN_AUTH_PART
42 class MockIInputer : public OHOS::AccountSA::IInputer {
43 public:
~MockIInputer()44 virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)45 void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
46 std::shared_ptr<IInputerData> inputerData) override
47 {
48 return;
49 }
50 };
51 #endif
52
53 class AccountIAMCallbackServiceTest : public testing::Test {
54 public:
55 static void SetUpTestCase(void);
56 static void TearDownTestCase(void);
57 void SetUp(void) override;
58 void TearDown(void) override;
59 };
60
SetUpTestCase(void)61 void AccountIAMCallbackServiceTest::SetUpTestCase(void)
62 {
63 g_selfTokenID = IPCSkeleton::GetSelfTokenID();
64 ASSERT_EQ(0, SetSelfTokenID(GetTokenIdFromBundleName("com.ohos.settings")));
65 }
66
TearDownTestCase(void)67 void AccountIAMCallbackServiceTest::TearDownTestCase(void)
68 {
69 ASSERT_EQ(0, SetSelfTokenID(g_selfTokenID));
70 }
71
SetUp(void)72 void AccountIAMCallbackServiceTest::SetUp(void) __attribute__((no_sanitize("cfi")))
73 {
74 testing::UnitTest *test = testing::UnitTest::GetInstance();
75 ASSERT_NE(test, nullptr);
76 const testing::TestInfo *testinfo = test->current_test_info();
77 ASSERT_NE(testinfo, nullptr);
78 string testCaseName = string(testinfo->name());
79 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
80 }
81
TearDown(void)82 void AccountIAMCallbackServiceTest::TearDown(void)
83 {}
84
85 /**
86 * @tc.name: IDMCallbackService_OnAcquireInfo_0100
87 * @tc.desc: OnAcquireInfo with nullptr.
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnAcquireInfo_0100, TestSize.Level0)
92 {
93 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
94 EXPECT_TRUE(wrapper->callback_ == nullptr);
95 Attributes extraInfo;
96 wrapper->OnAcquireInfo(0, 0, extraInfo);
97 }
98
99 /**
100 * @tc.name: IDMCallbackService_OnAcquireInfo_0200
101 * @tc.desc: OnAcquireInfo with not nullptr.
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnAcquireInfo_0200, TestSize.Level0)
106 {
107 auto callback = std::make_shared<MockIDMCallback>();
108 EXPECT_NE(callback, nullptr);
109 EXPECT_CALL(*callback, OnAcquireInfo(_, _, _)).Times(Exactly(1));
110 auto testCallback = std::make_shared<TestIDMCallback>(callback);
111 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
112 EXPECT_TRUE(wrapper->callback_ != nullptr);
113 Attributes extraInfo;
114 wrapper->OnAcquireInfo(0, 0, extraInfo);
115 std::unique_lock<std::mutex> lock(testCallback->mutex);
116 testCallback->cv.wait_for(
__anonfed8f4340202() 117 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
118 }
119
120 /**
121 * @tc.name: IDMCallbackService_OnResult_0100
122 * @tc.desc: OnResult test.
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(AccountIAMCallbackServiceTest, IDMCallbackService_OnResult_0100, TestSize.Level0)
127 {
128 auto callback = std::make_shared<MockIDMCallback>();
129 EXPECT_NE(callback, nullptr);
130 EXPECT_CALL(*callback, OnResult(0, _)).Times(Exactly(1));
131 auto testCallback = std::make_shared<TestIDMCallback>(callback);
132 sptr<IDMCallbackService> wrapper = new (std::nothrow) IDMCallbackService(TEST_USER_ID, testCallback);
133 ASSERT_NE(wrapper, nullptr);
134 Attributes extraInfo;
135 wrapper->OnResult(0, extraInfo);
136 {
137 std::unique_lock<std::mutex> lock(testCallback->mutex);
138 testCallback->cv.wait_for(
__anonfed8f4340302() 139 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
140 }
141 EXPECT_CALL(*callback, OnResult(1, _)).Times(Exactly(1));
142 testCallback->isReady = false;
143 wrapper->OnResult(1, extraInfo);
144 {
145 std::unique_lock<std::mutex> lock(testCallback->mutex);
146 testCallback->cv.wait_for(
__anonfed8f4340402() 147 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
148 }
149 wrapper->callback_ = nullptr;
150 wrapper->OnResult(0, extraInfo);
151 }
152
153 /**
154 * @tc.name: GetCredInfoCallbackService_OnCredentialInfo_0100
155 * @tc.desc: OnCredentialInfo with nullptr.
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(AccountIAMCallbackServiceTest, GetCredInfoCallbackService_OnCredentialInfo_0100, TestSize.Level0)
160 {
161 sptr<GetCredInfoCallbackService> wrapper = new (std::nothrow) GetCredInfoCallbackService(nullptr);
162 EXPECT_TRUE(wrapper->callback_ == nullptr);
163 std::vector<CredentialInfo> infoList;
164 wrapper->OnCredentialInfo(infoList);
165 }
166
167 /**
168 * @tc.name: GetSetPropCallbackService_OnResult_0100
169 * @tc.desc: OnResult with nullptr.
170 * @tc.type: FUNC
171 * @tc.require:
172 */
173 HWTEST_F(AccountIAMCallbackServiceTest, GetSetPropCallbackService_OnResult_0100, TestSize.Level0)
174 {
175 sptr<GetSetPropCallbackService> wrapper = new (std::nothrow) GetSetPropCallbackService(nullptr);
176 EXPECT_TRUE(wrapper->callback_ == nullptr);
177 Attributes extraInfo;
178 wrapper->OnResult(0, extraInfo);
179 }
180
181 /**
182 * @tc.name: DomainAuthCallbackAdapter_OnResult_0100
183 * @tc.desc: test OnResult.
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(AccountIAMCallbackServiceTest, DomainAuthCallbackAdapter_OnResult_0100, TestSize.Level0)
188 {
189 std::shared_ptr<DomainAuthCallbackAdapter> domainAuthCallbackAdapter =
190 std::make_shared<DomainAuthCallbackAdapter>(nullptr);
191 Parcel emptyParcel;
192 domainAuthCallbackAdapter->OnResult(0, emptyParcel);
193 std::string cmd = "hilog -x | grep 'AccountIAMFwk'";
194 std::string cmdRes = RunCommand(cmd);
195 ASSERT_TRUE(cmdRes.find("callback is nullptr") != std::string::npos);
196 }
197
198 #ifdef HAS_PIN_AUTH_PART
199 /**
200 * @tc.name: DomainCredentialRecipient_OnSetData_0100
201 * @tc.desc: test OnSetData.
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(AccountIAMCallbackServiceTest, DomainCredentialRecipient_OnSetData_0100, TestSize.Level0)
206 {
207 auto domainCredentialRecipient = new (std::nothrow) DomainCredentialRecipient(100, nullptr);
208 std::vector<uint8_t> data = {1, 2, 3, 4};
209 domainCredentialRecipient->OnSetData(0, data);
210 EXPECT_EQ(domainCredentialRecipient->idmCallback_, nullptr);
211 }
212 #endif
213 } // namespace AccountTest
214 } // namespace OHOS