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<IIamCallback> 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<IIamCallback> 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))
__anond8430c400102(int32_t result, const std::vector<uint8_t> &reqRet) 82 .WillOnce([&testResult, &testAttr](int32_t result, const std::vector<uint8_t> &reqRet) {
83 EXPECT_TRUE(testResult == result);
84 EXPECT_TRUE(reqRet == testAttr->Serialize());
85 return SUCCESS;
86 });
87 sptr<IIamCallback> callback = mockCallback;
88 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
89 ASSERT_NE(contextCallback, nullptr);
90 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, {});
91 contextCallback->OnResult(testResult, *testAttr);
92 }
93
94 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.Level0)
95 {
96 int32_t testResult = 66;
97 int32_t acquire = 20;
98 auto testAttr = Common::MakeShared<Attributes>();
99 ASSERT_TRUE(testAttr != nullptr);
100 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
101 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_REMAIN_TIMES, 2));
102 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_FREEZING_TIME, 40));
103 auto testMsg = testAttr->Serialize();
104
__anond8430c400202(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 105 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
106 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
107 ContextCallbackNotifyListener::GetInstance().AddNotifier(nullptr);
108
109 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
110 ASSERT_TRUE(mockCallback != nullptr);
111 EXPECT_CALL(*mockCallback, OnResult(_, _)).Times(1);
112 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
113 sptr<IIamCallback> callback = mockCallback;
114 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL);
115 ASSERT_NE(contextCallback, nullptr);
116 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
117 contextCallback->OnResult(testResult, *testAttr);
118 }
119
120 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_001, TestSize.Level0)
121 {
122 int32_t acquire = 9999;
123 auto jsonExtraInfo = nlohmann::json({
124 {"authResutlt", 0},
125 {"authRemainAttempts", 5},
126 {"lockoutDuration", 0}});
127 std::string stringExtraInfo = jsonExtraInfo.dump();
128 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
129
130 auto testAttr = Common::MakeShared<Attributes>();
131 ASSERT_TRUE(testAttr != nullptr);
132 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
133 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
134 auto testMsg = testAttr->Serialize();
135
__anond8430c400302(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 136 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
137 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
138
139 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
140 ASSERT_TRUE(mockCallback != nullptr);
141 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
142 sptr<IIamCallback> callback = mockCallback;
143 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_BEHAVIOR);
144 ASSERT_NE(contextCallback, nullptr);
145 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
146 }
147
148 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_002, TestSize.Level0)
149 {
150 int32_t acquire = 9999;
151 auto jsonExtraInfo = nlohmann::json({
152 {"authResutlt", 1},
153 {"authRemainAttempts", 5},
154 {"lockoutDuration", 0}});
155 std::string stringExtraInfo = jsonExtraInfo.dump();
156 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
157
158 auto testAttr = Common::MakeShared<Attributes>();
159 ASSERT_TRUE(testAttr != nullptr);
160 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
161 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
162 auto testMsg = testAttr->Serialize();
163
__anond8430c400402(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 164 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
165 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
166
167 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
168 ASSERT_TRUE(mockCallback != nullptr);
169 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
170 sptr<IIamCallback> callback = mockCallback;
171 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
172 ASSERT_NE(contextCallback, nullptr);
173 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
174 }
175
176 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_003, TestSize.Level0)
177 {
178 int32_t acquire = 1;
179 auto jsonExtraInfo = nlohmann::json({
180 {"authResutlt", 1},
181 {"authRemainAttempts", 5},
182 {"lockoutDuration", 0}});
183 std::string stringExtraInfo = jsonExtraInfo.dump();
184 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
185
186 auto testAttr = Common::MakeShared<Attributes>();
187 ASSERT_TRUE(testAttr != nullptr);
188 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
189 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
190 auto testMsg = testAttr->Serialize();
191
__anond8430c400502(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 192 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
193 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
194
195 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
196 ASSERT_TRUE(mockCallback != nullptr);
197 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
198 sptr<IIamCallback> callback = mockCallback;
199 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
200 ASSERT_NE(contextCallback, nullptr);
201 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
202 }
203
204 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_004, TestSize.Level0)
205 {
206 int32_t acquire = 9999;
207 auto jsonExtraInfo = nlohmann::json({});
208 std::string stringExtraInfo = jsonExtraInfo.dump();
209 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
210
211 auto testAttr = Common::MakeShared<Attributes>();
212 ASSERT_TRUE(testAttr != nullptr);
213 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
214 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
215 auto testMsg = testAttr->Serialize();
216
__anond8430c400602(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 217 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
218 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
219
220 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
221 ASSERT_TRUE(mockCallback != nullptr);
222 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
223 sptr<IIamCallback> callback = mockCallback;
224 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
225 ASSERT_NE(contextCallback, nullptr);
226 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
227 }
228
229 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_005, TestSize.Level0)
230 {
231 int32_t acquire = 9999;
232 auto jsonExtraInfo = nlohmann::json({
233 {"authResult", "1"},
234 {"authRemainAttempts", 5},
235 {"lockoutDuration", 0}});
236 std::string stringExtraInfo = jsonExtraInfo.dump();
237 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
238
239 auto testAttr = Common::MakeShared<Attributes>();
240 ASSERT_TRUE(testAttr != nullptr);
241 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
242 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
243 auto testMsg = testAttr->Serialize();
244
__anond8430c400702(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 245 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
246 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
247
248 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
249 ASSERT_TRUE(mockCallback != nullptr);
250 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
251 sptr<IIamCallback> callback = mockCallback;
252 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
253 ASSERT_NE(contextCallback, nullptr);
254 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
255 }
256
257 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_006, TestSize.Level0)
258 {
259 int32_t acquire = 9999;
260 auto jsonExtraInfo = nlohmann::json({
261 {"authResult", 0},
262 {"authRemainAttempts", 5},
263 {"lockoutDuration", 0}});
264 std::string stringExtraInfo = jsonExtraInfo.dump();
265 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
266
267 auto testAttr = Common::MakeShared<Attributes>();
268 ASSERT_TRUE(testAttr != nullptr);
269 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
270 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
271 auto testMsg = testAttr->Serialize();
272
__anond8430c400802(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 273 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
274 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
275
276 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
277 ASSERT_TRUE(mockCallback != nullptr);
278 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
279 sptr<IIamCallback> callback = mockCallback;
280 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
281 ASSERT_NE(contextCallback, nullptr);
282 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
283 }
284
285 HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthOnAcquireInfo_007, TestSize.Level0)
286 {
287 int32_t acquire = 9999;
288 auto jsonExtraInfo = nlohmann::json({
289 {"authResutt", 1},
290 {"authRemainAttempts", 5},
291 {"lockoutDuration", 0}});
292 std::string stringExtraInfo = jsonExtraInfo.dump();
293 const std::vector<uint8_t> extraInfo(stringExtraInfo.data(), stringExtraInfo.data() + stringExtraInfo.length());
294
295 auto testAttr = Common::MakeShared<Attributes>();
296 ASSERT_TRUE(testAttr != nullptr);
297 EXPECT_TRUE(testAttr->SetInt32Value(Attributes::ATTR_TIP_INFO, acquire));
298 EXPECT_TRUE(testAttr->SetUint8ArrayValue(Attributes::ATTR_EXTRA_INFO, extraInfo));
299 auto testMsg = testAttr->Serialize();
300
__anond8430c400902(const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) 301 auto notify = [](const ContextCallbackNotifyListener::MetaData &metaData, TraceFlag flag) { return; };
302 ContextCallbackNotifyListener::GetInstance().AddNotifier(notify);
303
304 sptr<MockIdmCallback> mockCallback(new (nothrow) MockIdmCallback());
305 ASSERT_TRUE(mockCallback != nullptr);
306 EXPECT_CALL(*mockCallback, OnAcquireInfo(_, _, _)).Times(1);
307 sptr<IIamCallback> callback = mockCallback;
308 auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER_SECURITY);
309 ASSERT_NE(contextCallback, nullptr);
310 contextCallback->OnAcquireInfo(static_cast<ExecutorRole>(0), 0, testMsg);
311 }
312 } // namespace UserAuth
313 } // namespace UserIam
314 } // namespace OHOS
315