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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20 
21 #include "auth_hichain.h"
22 #include "auth_hichain.c"
23 #include "auth_hichain_adapter.h"
24 #include "auth_log.h"
25 #include "auth_net_ledger_mock.h"
26 #include "softbus_app_info.h"
27 #include "lnn_hichain_mock.h"
28 #include "softbus_errcode.h"
29 #include "softbus_socket.h"
30 #include "auth_common_mock.h"
31 
32 namespace OHOS {
33 using namespace testing;
34 using namespace testing::ext;
35 
36 class AuthHichainTest : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp();
41     void TearDown();
42 };
43 
SetUpTestCase()44 void AuthHichainTest::SetUpTestCase()
45 {
46 }
47 
TearDownTestCase()48 void AuthHichainTest::TearDownTestCase() {}
49 
SetUp()50 void AuthHichainTest::SetUp()
51 {
52     AUTH_LOGI(AUTH_TEST, "AuthHichainTest start");
53 }
54 
TearDown()55 void AuthHichainTest::TearDown() {}
56 
OnDeviceNotTrustedTest(const char * peerUdid)57 void OnDeviceNotTrustedTest(const char *peerUdid)
58 {
59     (void)peerUdid;
60 }
61 
OnGroupCreatedTest(const char * groupId,int32_t groupType)62 void OnGroupCreatedTest(const char *groupId, int32_t groupType)
63 {
64     (void)groupId;
65     (void)groupType;
66 }
67 
OnGroupDeletedTest(const char * groupId,int32_t groupType)68 void OnGroupDeletedTest(const char *groupId, int32_t groupType)
69 {
70     (void)groupId;
71     (void)groupType;
72 }
73 
OnDeviceBound(const char * udid,const char * groupInfo)74 void OnDeviceBound(const char *udid, const char *groupInfo)
75 {
76     (void)udid;
77     (void)groupInfo;
78 }
79 /*
80  * @tc.name: ON_DEVICE_NOT_TRUSTED_TEST_001
81  * @tc.desc: on device not trusted test
82  * @tc.type: FUNC
83  * @tc.require:
84  */
85 HWTEST_F(AuthHichainTest, ON_DEVICE_NOT_TRUSTED_TEST_001, TestSize.Level1)
86 {
87     const char *groupInfo = "testdata";
88     const char *groupInfoStr = "{\"groupId\":\"1111\", \"groupType\":1}";
89     const char *udid = "000";
90     GroupInfo info;
91     AuthNetLedgertInterfaceMock ledgermock;
92     EXPECT_CALL(ledgermock, GetJsonObjectStringItem)
93         .WillOnce(Return(false))
94         .WillRepeatedly(Return(true));
95     OnGroupCreated(nullptr);
96     OnGroupCreated(groupInfo);
97     g_dataChangeListener.onGroupCreated = nullptr;
98     OnGroupCreated(groupInfoStr);
99     g_dataChangeListener.onGroupCreated = OnGroupCreatedTest;
100     OnGroupCreated(groupInfoStr);
101 
102     OnGroupDeleted(nullptr);
103     OnGroupDeleted(groupInfo);
104     g_dataChangeListener.onGroupDeleted = nullptr;
105     OnGroupDeleted(groupInfoStr);
106     g_dataChangeListener.onGroupDeleted = OnGroupDeletedTest;
107     OnGroupDeleted(groupInfoStr);
108 
109     OnDeviceNotTrusted(nullptr);
110     g_dataChangeListener.onDeviceNotTrusted = nullptr;
111     OnDeviceNotTrusted(udid);
112     g_dataChangeListener.onDeviceNotTrusted = OnDeviceNotTrustedTest;
113     OnDeviceNotTrusted(udid);
114 
115     (void)memset_s(&info, sizeof(GroupInfo), 0, sizeof(GroupInfo));
116     int32_t ret = ParseGroupInfo(nullptr, &info);
117     EXPECT_TRUE(ret != SOFTBUS_OK);
118     ret = ParseGroupInfo(groupInfoStr, &info);
119     EXPECT_TRUE(ret == SOFTBUS_OK);
120     ret = ParseGroupInfo(groupInfoStr, &info);
121     EXPECT_TRUE(ret == SOFTBUS_OK);
122 
123     int64_t authSeq = 0;
124     uint8_t sessionKey[SESSION_KEY_LENGTH] = {0};
125     OnSessionKeyReturned(authSeq, nullptr, SESSION_KEY_LENGTH + 1);
126     OnSessionKeyReturned(authSeq, nullptr, SESSION_KEY_LENGTH);
127     OnSessionKeyReturned(authSeq, sessionKey, SESSION_KEY_LENGTH + 1);
128 
129     uint32_t softbusErrCode = 0;
130     GetSoftbusHichainAuthErrorCode(HICHAIN_DAS_ERRCODE_MIN, &softbusErrCode);
131     GetSoftbusHichainAuthErrorCode(0, &softbusErrCode);
132 }
133 
134 /*
135  * @tc.name: ON_REQUEST_TEST_001
136  * @tc.desc: on request test
137  * @tc.type: FUNC
138  * @tc.require:
139  */
140 HWTEST_F(AuthHichainTest, ON_REQUEST_TEST_001, TestSize.Level1)
141 {
142     int64_t authSeq = 0;
143     int operationCode = 0;
144     const char *reqParams = "testdata";
145 
146     char *msgStr = OnRequest(authSeq, operationCode, reqParams);
147     EXPECT_TRUE(msgStr == nullptr);
148 
149     const char *udid = "111";
150     const char *groupInfo = "{\"groupId\":\"1111\", \"groupType\":1}";
151     OnDeviceBound(udid, nullptr);
152     OnDeviceBound(nullptr, groupInfo);
153     OnDeviceBound(nullptr, nullptr);
154     g_dataChangeListener.onDeviceBound = OnDeviceBound;
155     OnDeviceBound(udid, groupInfo);
156 
157     DfxRecordLnnExchangekeyEnd(authSeq, SOFTBUS_OK);
158     DfxRecordLnnEndHichainEnd(authSeq, SOFTBUS_OK);
159 }
160 
161 /*
162  * @tc.name: IS_POTENTIAL_TRUSTED_DEVICE_TEST_001
163  * @tc.desc: is potential trusted device test
164  * @tc.type: FUNC
165  * @tc.require:
166  */
167 HWTEST_F(AuthHichainTest, IS_POTENTIAL_TRUSTED_DEVICE_TEST_001, TestSize.Level1)
168 {
169     TrustedRelationIdType idType = ID_TYPE_UID;
170     const char *deviceId = "test123456";
171     bool isPrecise = false;
172     DeviceGroupManager grounpManager;
173     LnnHichainInterfaceMock hichainMock;
174     grounpManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
175     grounpManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
176     grounpManager.getRelatedGroups = LnnHichainInterfaceMock::getRelatedGroups;
177     grounpManager.destroyInfo = LnnHichainInterfaceMock::destroyInfo;
178     EXPECT_CALL(hichainMock, GetGmInstance)
179         .WillOnce(Return(NULL))
180         .WillRepeatedly(Return(&grounpManager));
181     AuthNetLedgertInterfaceMock ledgermock;
182     EXPECT_CALL(ledgermock, LnnGetLocalStrInfo)
183         .WillOnce(Return(SOFTBUS_ERR))
184         .WillRepeatedly(Return(SOFTBUS_OK));
185     bool ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
186     EXPECT_TRUE(ret == false);
187     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
188     EXPECT_TRUE(ret == false);
189     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, true);
190     EXPECT_TRUE(ret == false);
191     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, true);
192     EXPECT_TRUE(ret == false);
193     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, true);
194     EXPECT_TRUE(ret == false);
195 }
196 
197 /*
198  * @tc.name: IS_POTENTIAL_TRUSTED_DEVICE_TEST_002
199  * @tc.desc: is potential trusted device test
200  * @tc.type: FUNC
201  * @tc.require:
202  */
203 HWTEST_F(AuthHichainTest, IS_POTENTIAL_TRUSTED_DEVICE_TEST_002, TestSize.Level1)
204 {
205     TrustedRelationIdType idType = ID_TYPE_UID;
206     const char *deviceId = "1122";
207     bool isPrecise = false;
208     DeviceGroupManager grounpManager;
209     NiceMock<LnnHichainInterfaceMock> hichainMock;
210     grounpManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
211     grounpManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
212     grounpManager.getRelatedGroups = LnnHichainInterfaceMock::getRelatedGroups1;
213     grounpManager.destroyInfo = LnnHichainInterfaceMock::destroyInfo;
214     grounpManager.getTrustedDevices = LnnHichainInterfaceMock::getTrustedDevices;
215     EXPECT_CALL(hichainMock, GetGmInstance).WillRepeatedly(Return(&grounpManager));
216     NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
217     EXPECT_CALL(ledgermock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
218     EXPECT_CALL(ledgermock, GetJsonObjectStringItem)
219         .WillOnce(Return(false))
220         .WillRepeatedly(Return(true));
221     bool ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, true);
222     EXPECT_TRUE(ret == false);
223     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, true);
224     EXPECT_TRUE(ret == false);
225     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
226     EXPECT_TRUE(ret == false);
227     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
228     EXPECT_TRUE(ret == false);
229     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
230     EXPECT_TRUE(ret == false);
231     grounpManager.getTrustedDevices = LnnHichainInterfaceMock::getTrustedDevices1;
232     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
233     EXPECT_TRUE(ret == false);
234     ret = IsPotentialTrustedDevice(idType, deviceId, isPrecise, false);
235     EXPECT_TRUE(ret == false);
236 }
237 
238 /*
239  * @tc.name: HI_CHAIN_GET_JOINED_GROUPS_TEST_001
240  * @tc.desc: hichain get joined groups test
241  * @tc.type: FUNC
242  * @tc.require:
243  */
244 HWTEST_F(AuthHichainTest, HI_CHAIN_GET_JOINED_GROUPS_TEST_001, TestSize.Level1)
245 {
246     NiceMock<LnnHichainInterfaceMock> hichainMock;
247     DeviceGroupManager grounpManager;
248     grounpManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
249     grounpManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
250     grounpManager.getJoinedGroups = LnnHichainInterfaceMock::InvokeGetJoinedGroups1;
251     EXPECT_CALL(hichainMock, GetGmInstance).WillRepeatedly(Return(&grounpManager));
252     int32_t groupType = 0;
253     uint32_t ret = HichainGetJoinedGroups(groupType);
254     EXPECT_TRUE(ret == 1);
255     groupType = 99;
256     grounpManager.getJoinedGroups = LnnHichainInterfaceMock::InvokeGetJoinedGroups2;
257     ret = HichainGetJoinedGroups(groupType);
258     EXPECT_TRUE(ret == 0);
259     int64_t authReqId = 32;
260     const char *appId = "111";
261     CancelRequest(authReqId, appId);
262 }
263 
264 /*
265  * @tc.name: IS_SAME_ACCOUNT_GROUP_DEVICE_TEST_001
266  * @tc.desc: is potential trusted device test
267  * @tc.type: FUNC
268  * @tc.require:
269  */
270 HWTEST_F(AuthHichainTest, IS_SAME_ACCOUNT_GROUP_DEVICE_TEST_001, TestSize.Level1)
271 {
272     NiceMock<LnnHichainInterfaceMock> hichainMock;
273     DeviceGroupManager grounpManager;
274     grounpManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
275     grounpManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
276     grounpManager.getJoinedGroups = LnnHichainInterfaceMock::InvokeGetJoinedGroups2;
277     grounpManager.destroyInfo = LnnHichainInterfaceMock::destroyInfo;
278     EXPECT_CALL(hichainMock, GetGmInstance)
279         .WillOnce(Return(NULL))
280         .WillRepeatedly(Return(&grounpManager));
281     bool ret = IsSameAccountGroupDevice();
282     EXPECT_TRUE(ret == false);
283     ret = IsSameAccountGroupDevice();
284     EXPECT_TRUE(ret == false);
285     grounpManager.getJoinedGroups = LnnHichainInterfaceMock::InvokeGetJoinedGroups3;
286     EXPECT_CALL(hichainMock, GetGmInstance).WillRepeatedly(Return(&grounpManager));
287     ret = IsSameAccountGroupDevice();
288     EXPECT_TRUE(ret == false);
289     grounpManager.getJoinedGroups = LnnHichainInterfaceMock::InvokeGetJoinedGroups1;
290     EXPECT_CALL(hichainMock, GetGmInstance).WillRepeatedly(Return(&grounpManager));
291     ret = IsSameAccountGroupDevice();
292     EXPECT_TRUE(ret == true);
293 }
294 } // namespace OHOS
295