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 <gtest/gtest.h>
17
18 #include "context_callback_impl.h"
19 #include "iam_ptr.h"
20 #include "nlohmann/json.hpp"
21 #include "mock_user_auth_callback.h"
22 #include "mock_user_idm_callback.h"
23
24 namespace OHOS {
25 namespace UserIam {
26 namespace UserAuth {
27 using namespace std;
28 using namespace testing;
29 using namespace testing::ext;
30
31 class ContextCallbackImplTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34
35 static void TearDownTestCase();
36
37 void SetUp() override;
38
39 void TearDown() override;
40 };
41
SetUpTestCase()42 void ContextCallbackImplTest::SetUpTestCase()
43 {
44 }
45
TearDownTestCase()46 void ContextCallbackImplTest::TearDownTestCase()
47 {
48 }
49
SetUp()50 void ContextCallbackImplTest::SetUp()
51 {
52 }
53
TearDown()54 void ContextCallbackImplTest::TearDown()
55 {
56 }
57
58 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthNull, TestSize.Level0)
59 {
60 sptr<UserAuthCallbackInterface> callback(nullptr);
61 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
62 ASSERT_EQ(contextCallback, nullptr);
63 }
64
65 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmNull, TestSize.Level0)
66 {
67 sptr<IdmCallbackInterface> callback(nullptr);
68 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
69 ASSERT_EQ(contextCallback, nullptr);
70 }
71
72 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuth, TestSize.Level0)
73 {
74 int32_t testResult = 66;
75 auto testAttr = Common::MakeShared<Attributes>();
76 ASSERT_TRUE(testAttr != nullptr);
77
78 sptr<MockUserAuthCallback> mockCallback(new (nothrow) MockUserAuthCallback());
79 ASSERT_TRUE(mockCallback != nullptr);
80 EXPECT_CALL(*mockCallback, OnResult(_, _))
81 .Times(Exactly(1))
__anonfd3f94de0102(int32_t result, const Attributes &reqRet) 82 .WillOnce([&testResult, &testAttr](int32_t result, const Attributes &reqRet) {
83 EXPECT_TRUE(testResult == result);
84 EXPECT_TRUE(&reqRet == testAttr.get());
85 });
86 sptr<UserAuthCallbackInterface> callback = mockCallback;
87 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
88 ASSERT_NE(contextCallback, nullptr);
89 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
90 contextCallback->OnResult(testResult, *testAttr);
91 }
92
93 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.Level0)
94 {
95 int32_t testResult = 66;
96 int32_t acquire = 20;
97 auto testAttr = Common::MakeShared<Attributes>();
98 ASSERT_TRUE(testAttr != nullptr);
99 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
100 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_REMAIN_TIMES, 2));
101 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_FREEZING_TIME, 40));
102 auto testMsg = testAttr->Serialize();
103
__anonfd3f94de0202(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 104 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
105 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
106 ContextCallbackNotifyListener::GetInstance().AddNotifier(nullptr);
107
108 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
109 ASSERT_TRUE(mockCallback != nullptr);
110 EXPECT_CALL(*mockCallback, OnResult(_, _)).Times(1);
111 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
112 sptr<IdmCallbackInterface> callback = mockCallback;
113 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
114 ASSERT_NE(contextCallback, nullptr);
115 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
116 contextCallback->OnResult(testResult, *testAttr);
117 }
118
119 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_001, TestSize.Level0)
120 {
121 int32_t acquire = 9999;
122 auto jsonExtraInfo = nlohmann::json({
123 {"authResutlt", 0},
124 {"authRemainAttempts", 5},
125 {"lockoutDuration", 0}});
126 std::string stringExtraInfo = jsonExtraInfo.dump();
127 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
128
129 auto testAttr = Common::MakeShared<Attributes>();
130 ASSERT_TRUE(testAttr != nullptr);
131 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
132 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
133 auto testMsg = testAttr->Serialize();
134
__anonfd3f94de0302(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 135 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
136 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
137
138 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
139 ASSERT_TRUE(mockCallback != nullptr);
140 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
141 sptr<IdmCallbackInterface> callback = mockCallback;
142 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_BEHAVIOR);
143 ASSERT_NE(contextCallback, nullptr);
144 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
145 }
146
147 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_002, TestSize.Level0)
148 {
149 int32_t acquire = 9999;
150 auto jsonExtraInfo = nlohmann::json({
151 {"authResutlt", 1},
152 {"authRemainAttempts", 5},
153 {"lockoutDuration", 0}});
154 std::string stringExtraInfo = jsonExtraInfo.dump();
155 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
156
157 auto testAttr = Common::MakeShared<Attributes>();
158 ASSERT_TRUE(testAttr != nullptr);
159 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
160 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
161 auto testMsg = testAttr->Serialize();
162
__anonfd3f94de0402(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 163 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
164 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
165
166 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
167 ASSERT_TRUE(mockCallback != nullptr);
168 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
169 sptr<IdmCallbackInterface> callback = mockCallback;
170 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
171 ASSERT_NE(contextCallback, nullptr);
172 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
173 }
174
175 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_003, TestSize.Level0)
176 {
177 int32_t acquire = 1;
178 auto jsonExtraInfo = nlohmann::json({
179 {"authResutlt", 1},
180 {"authRemainAttempts", 5},
181 {"lockoutDuration", 0}});
182 std::string stringExtraInfo = jsonExtraInfo.dump();
183 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
184
185 auto testAttr = Common::MakeShared<Attributes>();
186 ASSERT_TRUE(testAttr != nullptr);
187 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
188 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
189 auto testMsg = testAttr->Serialize();
190
__anonfd3f94de0502(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 191 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
192 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
193
194 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
195 ASSERT_TRUE(mockCallback != nullptr);
196 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
197 sptr<IdmCallbackInterface> callback = mockCallback;
198 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
199 ASSERT_NE(contextCallback, nullptr);
200 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
201 }
202
203 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_004, TestSize.Level0)
204 {
205 int32_t acquire = 9999;
206 auto jsonExtraInfo = nlohmann::json({});
207 std::string stringExtraInfo = jsonExtraInfo.dump();
208 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
209
210 auto testAttr = Common::MakeShared<Attributes>();
211 ASSERT_TRUE(testAttr != nullptr);
212 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
213 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
214 auto testMsg = testAttr->Serialize();
215
__anonfd3f94de0602(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 216 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
217 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
218
219 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
220 ASSERT_TRUE(mockCallback != nullptr);
221 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
222 sptr<IdmCallbackInterface> callback = mockCallback;
223 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
224 ASSERT_NE(contextCallback, nullptr);
225 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
226 }
227
228 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_005, TestSize.Level0)
229 {
230 int32_t acquire = 9999;
231 auto jsonExtraInfo = nlohmann::json({
232 {"authResult", "1"},
233 {"authRemainAttempts", 5},
234 {"lockoutDuration", 0}});
235 std::string stringExtraInfo = jsonExtraInfo.dump();
236 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
237
238 auto testAttr = Common::MakeShared<Attributes>();
239 ASSERT_TRUE(testAttr != nullptr);
240 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
241 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
242 auto testMsg = testAttr->Serialize();
243
__anonfd3f94de0702(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 244 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
245 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
246
247 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
248 ASSERT_TRUE(mockCallback != nullptr);
249 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
250 sptr<IdmCallbackInterface> callback = mockCallback;
251 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
252 ASSERT_NE(contextCallback, nullptr);
253 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
254 }
255
256 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_006, TestSize.Level0)
257 {
258 int32_t acquire = 9999;
259 auto jsonExtraInfo = nlohmann::json({
260 {"authResult", 0},
261 {"authRemainAttempts", 5},
262 {"lockoutDuration", 0}});
263 std::string stringExtraInfo = jsonExtraInfo.dump();
264 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
265
266 auto testAttr = Common::MakeShared<Attributes>();
267 ASSERT_TRUE(testAttr != nullptr);
268 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
269 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
270 auto testMsg = testAttr->Serialize();
271
__anonfd3f94de0802(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 272 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
273 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
274
275 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
276 ASSERT_TRUE(mockCallback != nullptr);
277 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
278 sptr<IdmCallbackInterface> callback = mockCallback;
279 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
280 ASSERT_NE(contextCallback, nullptr);
281 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
282 }
283
284 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_007, TestSize.Level0)
285 {
286 int32_t acquire = 9999;
287 auto jsonExtraInfo = nlohmann::json({
288 {"authResutt", 1},
289 {"authRemainAttempts", 5},
290 {"lockoutDuration", 0}});
291 std::string stringExtraInfo = jsonExtraInfo.dump();
292 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
293
294 auto testAttr = Common::MakeShared<Attributes>();
295 ASSERT_TRUE(testAttr != nullptr);
296 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
297 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
298 auto testMsg = testAttr->Serialize();
299
__anonfd3f94de0902(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 300 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
301 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
302
303 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
304 ASSERT_TRUE(mockCallback != nullptr);
305 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
306 sptr<IdmCallbackInterface> callback = mockCallback;
307 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
308 ASSERT_NE(contextCallback, nullptr);
309 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
310 }
311 } // namespace UserAuth
312 } // namespace UserIam
313 } // namespace OHOS
314