1 /*
2 * Copyright (c) 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_hichain.c"
22 #include "auth_hichain_deps_mock.h"
23 #include "softbus_error_code.h"
24
25 namespace OHOS {
26 using namespace testing;
27 using namespace testing::ext;
28
29 constexpr int64_t TEST_AUTH_SEQ = 1;
30 constexpr uint32_t TMP_DATA_LEN = 10;
31 constexpr uint8_t TMP_DATA[TMP_DATA_LEN] = "tmpInData";
32 static constexpr int32_t DEFALUT_USERID = 100;
33
34 class AuthHichainMockTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase()42 void AuthHichainMockTest::SetUpTestCase() {}
43
TearDownTestCase()44 void AuthHichainMockTest::TearDownTestCase() {}
45
SetUp()46 void AuthHichainMockTest::SetUp() {}
47
TearDown()48 void AuthHichainMockTest::TearDown() {}
49
50 /*
51 * @tc.name: GEN_DEVICE_LEVEL_PARAM_TEST_001
52 * @tc.desc: GenDeviceLevelParam test
53 * @tc.type: FUNC
54 * @tc.require:
55 */
56 HWTEST_F(AuthHichainMockTest, GEN_DEVICE_LEVEL_PARAM_TEST_001, TestSize.Level1)
57 {
58 AuthHichainInterfaceMock hichainMock;
59 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
60 if (msg == nullptr) {
61 return;
62 }
63 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg));
64 const char *udid = "123456";
65 const char *uid = "123";
66 static char *ptr = GenDeviceLevelParam(udid, uid, true, DEFALUT_USERID);
67 EXPECT_EQ(ptr, nullptr);
68 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
69 ptr = GenDeviceLevelParam(udid, uid, true, DEFALUT_USERID);
70 EXPECT_EQ(ptr, nullptr);
71 cJSON *msg1 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
72 if (msg1 == nullptr) {
73 return;
74 }
75 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(msg1));
76 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillRepeatedly(Return(true));
77 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
78 EXPECT_CALL(hichainMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr));
79 ptr = GenDeviceLevelParam(udid, uid, true, DEFALUT_USERID);
80 EXPECT_EQ(ptr, nullptr);
81 }
82
83 /*
84 * @tc.name: ON_TRANSMIT_TEST_001
85 * @tc.desc: OnTransmit test
86 * @tc.type: FUNC
87 * @tc.require:
88 */
89 HWTEST_F(AuthHichainMockTest, ON_TRANSMIT_TEST_001, TestSize.Level1)
90 {
91 AuthHichainInterfaceMock hichainMock;
92 EXPECT_CALL(hichainMock, AuthSessionPostAuthData).WillOnce(Return(SOFTBUS_INVALID_PARAM))
93 .WillRepeatedly(Return(SOFTBUS_OK));
94 int64_t authSeq = TEST_AUTH_SEQ;
95 const uint8_t *data = reinterpret_cast<const unsigned char *>(TMP_DATA);
96 uint32_t len = TMP_DATA_LEN;
97 bool ret = OnTransmit(authSeq, data, len);
98 EXPECT_EQ(ret, false);
99 ret = OnTransmit(authSeq, data, len);
100 EXPECT_EQ(ret, true);
101 }
102
103 /*
104 * @tc.name: GET_DEVICE_SIDE_FLAG_TEST_001
105 * @tc.desc: GetDeviceSideFlag test
106 * @tc.type: FUNC
107 * @tc.require:
108 */
109 HWTEST_F(AuthHichainMockTest, GET_DEVICE_SIDE_FLAG_TEST_001, TestSize.Level1)
110 {
111 AuthHichainInterfaceMock hichainMock;
112 void *para = reinterpret_cast<void *>(SoftBusCalloc(sizeof(ProofInfo)));
113 if (para == nullptr) {
114 return;
115 }
116 EXPECT_CALL(hichainMock, AuthFailNotifyProofInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
117 .WillRepeatedly(Return(SOFTBUS_OK));
118 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(nullptr));
119 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(para));
120 void *para1 = reinterpret_cast<void *>(SoftBusCalloc(sizeof(ProofInfo)));
121 if (para1 == nullptr) {
122 return;
123 }
124 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(para1));
125 AuthFsm authFsm;
126 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
127 EXPECT_CALL(hichainMock, GetAuthFsmByAuthSeq).WillOnce(Return(nullptr))
128 .WillRepeatedly(Return(&authFsm));
129 const char *side = "server";
130 EXPECT_CALL(hichainMock, GetAuthSideStr).WillRepeatedly(Return(side));
131 EXPECT_CALL(hichainMock, RequireAuthLock).WillOnce(Return(false))
132 .WillRepeatedly(Return(true));
133 EXPECT_CALL(hichainMock, ReleaseAuthLock).WillRepeatedly(Return());
134 int64_t authSeq = TEST_AUTH_SEQ;
135 bool flag;
136 int32_t ret = GetDeviceSideFlag(authSeq, &flag);
137 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
138 ret = GetDeviceSideFlag(authSeq, &flag);
139 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_FOUND);
140 ret = GetDeviceSideFlag(authSeq, &flag);
141 EXPECT_EQ(ret, SOFTBUS_OK);
142 }
143
144 /*
145 * @tc.name: CHECK_ERR_RETURN_VALIDITY_TEST_001
146 * @tc.desc: CheckErrReturnValidity test
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(AuthHichainMockTest, CHECK_ERR_RETURN_VALIDITY_TEST_001, TestSize.Level1)
151 {
152 AuthHichainInterfaceMock hichainMock;
153 EXPECT_CALL(hichainMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
154 EXPECT_CALL(hichainMock, RequireAuthLock).WillRepeatedly(Return(true));
155 EXPECT_CALL(hichainMock, ReleaseAuthLock).WillRepeatedly(Return());
156 const char *errorReturn = "errorReturnTest";
157 int32_t ret = CheckErrReturnValidity(errorReturn);
158 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
159 ret = CheckErrReturnValidity(errorReturn);
160 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
161 int errCode = PC_AUTH_ERRCODE;
162 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, nullptr));
163 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
164 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
165 errCode = PC_PROOF_NON_CONSISTENT_ERRCODE;
166 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
167 }
168
169 /*
170 * @tc.name: ON_REQUEST_TEST_001
171 * @tc.desc: OnRequest test
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(AuthHichainMockTest, ON_REQUEST_TEST_001, TestSize.Level1)
176 {
177 int64_t authSeq = TEST_AUTH_SEQ;
178 const char *reqParams = "reqParams";
179 int operationCode = 100;
180 AuthHichainInterfaceMock hichainMock;
181 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
182 if (msg == nullptr) {
183 return;
184 }
185 cJSON *msg1 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
186 if (msg1 == nullptr) {
187 SoftBusFree(msg);
188 return;
189 }
190 cJSON *msg2 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
191 if (msg2 == nullptr) {
192 SoftBusFree(msg);
193 SoftBusFree(msg1);
194 return;
195 }
196 EXPECT_CALL(hichainMock, AuthSessionGetUdid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
197 .WillRepeatedly(Return(SOFTBUS_OK));
198 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
199 char *ptr = OnRequest(authSeq, operationCode, reqParams);
200 EXPECT_EQ(ptr, nullptr);
201 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg))
202 .WillOnce(Return(msg1)).WillOnce(Return(msg2));
203 ptr = OnRequest(authSeq, operationCode, reqParams);
204 EXPECT_EQ(ptr, nullptr);
205 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
206 ptr = OnRequest(authSeq, operationCode, reqParams);
207 EXPECT_EQ(ptr, nullptr);
208 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
209 ptr = OnRequest(authSeq, operationCode, reqParams);
210 EXPECT_EQ(ptr, nullptr);
211 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
212 ptr = OnRequest(authSeq, operationCode, reqParams);
213 EXPECT_EQ(ptr, nullptr);
214 }
215
216 /*
217 * @tc.name: ON_REQUEST_TEST_002
218 * @tc.desc: OnRequest test
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(AuthHichainMockTest, ON_REQUEST_TEST_002, TestSize.Level1)
223 {
224 int64_t authSeq = TEST_AUTH_SEQ;
225 const char *reqParams = "reqParams";
226 int operationCode = 100;
227 AuthHichainInterfaceMock hichainMock;
228 cJSON *msg3 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
229 if (msg3 == nullptr) {
230 return;
231 }
232 cJSON *msg4 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
233 if (msg4 == nullptr) {
234 SoftBusFree(msg3);
235 return;
236 }
237 EXPECT_CALL(hichainMock, AuthSessionGetUdid).WillRepeatedly(Return(SOFTBUS_OK));
238 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
239 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(msg3)).WillOnce(Return(msg4));
240 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
241 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillRepeatedly(Return(true));
242 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillRepeatedly(Return(true));
243 char msgStr[10] = {0};
244 const char *val = "returnStr";
245 EXPECT_EQ(strcpy_s(msgStr, sizeof(msgStr), val), EOK);
246 EXPECT_CALL(hichainMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr)).WillRepeatedly(Return(msgStr));
247 char *ptr = OnRequest(authSeq, operationCode, reqParams);
248 EXPECT_EQ(ptr, nullptr);
249 ptr = OnRequest(authSeq, operationCode, reqParams);
250 EXPECT_NE(ptr, nullptr);
251 }
252
253 /*
254 * @tc.name: GET_UDID_HASH_TEST_001
255 * @tc.desc: GetUdidHash test
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(AuthHichainMockTest, GET_UDID_HASH_TEST_001, TestSize.Level1)
260 {
261 AuthHichainInterfaceMock hichainMock;
262 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
263 .WillRepeatedly(Return(SOFTBUS_OK));
264 EXPECT_CALL(hichainMock, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
265 .WillRepeatedly(Return(SOFTBUS_OK));
266 const char *udid = "udidTest";
267 char udidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
268
269 int32_t ret = GetUdidHash(nullptr, udidHash);
270 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
271 ret = GetUdidHash(udid, nullptr);
272 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
273 ret = GetUdidHash(udid, udidHash);
274 EXPECT_NE(ret, SOFTBUS_OK);
275 ret = GetUdidHash(udid, udidHash);
276 EXPECT_NE(ret, SOFTBUS_OK);
277 ret = GetUdidHash(udid, udidHash);
278 EXPECT_EQ(ret, SOFTBUS_OK);
279 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(nullptr));
280 EXPECT_CALL(hichainMock, GetNodeFromPcRestrictMap).WillOnce(Return(SOFTBUS_INVALID_PARAM))
281 .WillRepeatedly(Return(SOFTBUS_OK));
282 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(udid));
283 EXPECT_CALL(hichainMock, DeleteNodeFromPcRestrictMap).WillRepeatedly(Return());
284 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(udid));
285 }
286
287 /*
288 * @tc.name: HICHAIN_START_AUTH_TEST_001
289 * @tc.desc: HichainStartAuth test
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AuthHichainMockTest, HICHAIN_START_AUTH_TEST_001, TestSize.Level1)
294 {
295 AuthHichainInterfaceMock hichainMock;
296 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr));
297 int64_t authSeq = TEST_AUTH_SEQ;
298 const char *udid = "udidTest";
299 const char *uid = "uidTest";
300 const char *groupInfo = "groupInfoTest";
301 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, nullptr));
302 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(nullptr, groupInfo));
303 int32_t ret = HichainStartAuth(authSeq, udid, uid, DEFALUT_USERID);
304 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
305 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
306 if (msg == nullptr) {
307 return;
308 }
309 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
310 EXPECT_CALL(hichainMock, GetJsonObjectStringItem).WillRepeatedly(Return(true));
311 EXPECT_CALL(hichainMock, GetJsonObjectNumberItem)
312 .WillRepeatedly(DoAll(SetArgPointee<2>(AUTH_IDENTICAL_ACCOUNT_GROUP), Return(true)));
313 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
314 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
315 }
316 } // namespace OHOS
317