1 /*
2 * Copyright (c) 2025 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 "UTTest_dp_inited_callback.h"
17 #include "deviceprofile_connector_mock.h"
18 #include "dm_softbus_cache_mock.h"
19 #include "dm_constants.h"
20 #include "dm_anonymous.h"
21 #include "nlohmann/json.hpp"
22 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
23 #include "ffrt.h"
24 #endif
25
26 using ::testing::_;
27 using ::testing::Return;
28 using ::testing::DoAll;
29 using ::testing::SetArgReferee;
30
31 namespace OHOS {
32 namespace DistributedHardware {
CreateDmDeviceInfo(const char * networkId,const std::string & extraData,DmDeviceInfo & deviceInfo)33 bool CreateDmDeviceInfo(const char* networkId, const std::string& extraData, DmDeviceInfo& deviceInfo)
34 {
35 if (memset_s(&deviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)) != 0) {
36 return false;
37 }
38 if (memcpy_s(deviceInfo.networkId, sizeof(deviceInfo.networkId), networkId, strlen(networkId)) != 0) {
39 return false;
40 }
41 if (!extraData.empty()) {
42 deviceInfo.extraData = extraData;
43 }
44 return true;
45 }
46
SetUp()47 void DpInitedCallbackTest::SetUp()
48 {
49 DmSoftbusCache::dmSoftbusCache = std::make_shared<SoftbusCacheMock>();
50 DmDeviceProfileConnector::dmDeviceProfileConnector = std::make_shared<DeviceProfileConnectorMock>();
51 }
52
TearDown()53 void DpInitedCallbackTest::TearDown()
54 {
55 DmSoftbusCache::dmSoftbusCache = nullptr;
56 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
57 }
58
SetUpTestCase()59 void DpInitedCallbackTest::SetUpTestCase()
60 {}
61
TearDownTestCase()62 void DpInitedCallbackTest::TearDownTestCase()
63 {}
64
65 /**
66 * @tc.name: PutAllTrustedDevices_001
67 * @tc.type: FUNC
68 */
69 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_001, testing::ext::TestSize.Level0)
70 {
71 DmDeviceInfo deviceInfo;
72 char networkId[] = "255.255.255.0";
73 JsonObject jsonObject;
74 jsonObject[PARAM_KEY_OS_VERSION] = "5.0.3";
75 jsonObject[PARAM_KEY_OS_TYPE] = 1;
76 std::string extraData = SafetyDump(jsonObject);
77 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
78 ASSERT_TRUE(ret);
79
80 std::string udid = "mate-60";
81 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
82 std::unordered_map<std::string, DmAuthForm> authFormMap = { {udid, PEER_TO_PEER} };
83
84 DpInitedCallback dpInitedCallback;
85 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
86 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
87 DmDeviceProfileConnector::dmDeviceProfileConnector);
88
89 ASSERT_TRUE(softbusCacheMock != nullptr);
90 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
91
92 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
93 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
94 EXPECT_CALL(*softbusCacheMock, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>(udid), Return(DM_OK)));
95 EXPECT_CALL(*softbusCacheMock, GetUuidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>("lmMock"), Return(DM_OK)));
96 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _)).WillOnce(Return(authFormMap));
97
98 // @tc.expect: put all trusted devices.
99 dpInitedCallback.PutAllTrustedDevices();
100 }
101
102 /**
103 * @tc.name: PutAllTrustedDevices_002
104 * @tc.type: FUNC
105 */
106 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_002, testing::ext::TestSize.Level2)
107 {
108 DpInitedCallback dpInitedCallback;
109 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
110 ASSERT_TRUE(softbusCacheMock != nullptr);
111 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_)).WillOnce(Return(ERR_DM_FAILED));
112
113 // @tc.expect: GetDeviceInfoFromCache is error
114 dpInitedCallback.PutAllTrustedDevices();
115 }
116
117 /**
118 * @tc.name: PutAllTrustedDevices_003
119 * @tc.type: FUNC
120 */
121 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_003, testing::ext::TestSize.Level2)
122 {
123 DpInitedCallback dpInitedCallback;
124 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
125 ASSERT_TRUE(softbusCacheMock != nullptr);
126 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_)).WillOnce(Return(DM_OK));
127
128 // @tc.expect: dmDeviceInfos is empty.
129 dpInitedCallback.PutAllTrustedDevices();
130 }
131
132 /**
133 * @tc.name: PutAllTrustedDevices_004
134 * @tc.type: FUNC
135 */
136 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_004, testing::ext::TestSize.Level2)
137 {
138 DpInitedCallback dpInitedCallback;
139 DmDeviceInfo deviceInfo;
140 char networkId[] = "255.255.255.0";
141 std::string extraData;
142 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
143 ASSERT_TRUE(ret);
144
145 std::string udid = "mate-60";
146 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
147 std::unordered_map<std::string, DmAuthForm> authFormMap = { {udid, PEER_TO_PEER} };
148
149 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
150 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
151 DmDeviceProfileConnector::dmDeviceProfileConnector);
152 ASSERT_TRUE(softbusCacheMock != nullptr);
153 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
154
155 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
156 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
157 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _)).WillOnce(Return(authFormMap));
158
159 // @tc.expect: extraData is empty.
160 dpInitedCallback.PutAllTrustedDevices();
161 }
162
163 /**
164 * @tc.name: PutAllTrustedDevices_005
165 * @tc.type: FUNC
166 */
167 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_005, testing::ext::TestSize.Level2)
168 {
169 DpInitedCallback dpInitedCallback;
170 DmDeviceInfo deviceInfo;
171 char networkId[] = "255.255.255.0";
172
173 JsonObject jsonObject;
174 jsonObject[PARAM_KEY_OS_VERSION] = 1;
175 std::string extraData = SafetyDump(jsonObject);
176 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
177 ASSERT_TRUE(ret);
178
179 std::string udid = "mate-60";
180 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
181 std::unordered_map<std::string, DmAuthForm> authFormMap = { {udid, PEER_TO_PEER} };
182
183 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
184 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
185 DmDeviceProfileConnector::dmDeviceProfileConnector);
186 ASSERT_TRUE(softbusCacheMock != nullptr);
187 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
188
189 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
190 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
191 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _)).WillOnce(Return(authFormMap));
192
193 // @tc.expect: PARAM_KEY_OS_VERSION value type is not string.
194 dpInitedCallback.PutAllTrustedDevices();
195 }
196
197 /**
198 * @tc.name: PutAllTrustedDevices_006
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_006, testing::ext::TestSize.Level2)
202 {
203 DpInitedCallback dpInitedCallback;
204 DmDeviceInfo deviceInfo;
205 char networkId[] = "255.255.255.0";
206 JsonObject jsonObject;
207 jsonObject[PARAM_KEY_OS_VERSION] = "5.0.3";
208 jsonObject[PARAM_KEY_OS_TYPE] = "1";
209 std::string extraData = SafetyDump(jsonObject);
210 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
211 ASSERT_TRUE(ret);
212
213 std::string udid = "mate-60";
214 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
215
216 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
217 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
218 DmDeviceProfileConnector::dmDeviceProfileConnector);
219 ASSERT_TRUE(softbusCacheMock != nullptr);
220 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
221
222 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
223 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
224 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _))
225 .WillOnce(Return(std::unordered_map<std::string, DmAuthForm>()));
226
227 // @tc.expect: PARAM_KEY_OS_TYPE value type is not int.
228 dpInitedCallback.PutAllTrustedDevices();
229 }
230
231 /**
232 * @tc.name: PutAllTrustedDevices_007
233 * @tc.type: FUNC
234 */
235 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_007, testing::ext::TestSize.Level2)
236 {
237 DmDeviceInfo deviceInfo;
238 char networkId[] = "255.255.255.0";
239 JsonObject jsonObject;
240 jsonObject[PARAM_KEY_OS_VERSION] = "5.0.3";
241 jsonObject[PARAM_KEY_OS_TYPE] = 1;
242 std::string extraData = SafetyDump(jsonObject);
243 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
244 ASSERT_TRUE(ret);
245
246 std::string udid = "mate-60";
247 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
248 std::unordered_map<std::string, DmAuthForm> authFormMap = { {udid, PEER_TO_PEER} };
249
250 DpInitedCallback dpInitedCallback;
251 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
252 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
253 DmDeviceProfileConnector::dmDeviceProfileConnector);
254
255 ASSERT_TRUE(softbusCacheMock != nullptr);
256 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
257
258 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
259 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
260 EXPECT_CALL(*softbusCacheMock, GetUdidFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED));
261 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _)).WillOnce(Return(authFormMap));
262
263 // @tc.expect: GetUdidFromCache return error.
264 dpInitedCallback.PutAllTrustedDevices();
265 }
266
267 /**
268 * @tc.name: PutAllTrustedDevices_008
269 * @tc.type: FUNC
270 */
271 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_008, testing::ext::TestSize.Level2)
272 {
273 DmDeviceInfo deviceInfo;
274 char networkId[] = "255.255.255.0";
275 JsonObject jsonObject;
276 jsonObject[PARAM_KEY_OS_VERSION] = "5.0.3";
277 jsonObject[PARAM_KEY_OS_TYPE] = 1;
278 std::string extraData = SafetyDump(jsonObject);
279 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
280 ASSERT_TRUE(ret);
281 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
282
283 DpInitedCallback dpInitedCallback;
284 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
285 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
286 DmDeviceProfileConnector::dmDeviceProfileConnector);
287
288 ASSERT_TRUE(softbusCacheMock != nullptr);
289 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
290
291 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
292 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
293 EXPECT_CALL(*softbusCacheMock, GetUdidFromCache(_, _)).WillOnce(Return(DM_OK));
294 EXPECT_CALL(*softbusCacheMock, GetUuidFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED));
295 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _))
296 .WillOnce(Return(std::unordered_map<std::string, DmAuthForm>()));
297
298 // @tc.expect: GetUuidFromCache return error.
299 dpInitedCallback.PutAllTrustedDevices();
300 }
301
302 /**
303 * @tc.name: PutAllTrustedDevices_009
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DpInitedCallbackTest, PutAllTrustedDevices_009, testing::ext::TestSize.Level2)
307 {
308 DmDeviceInfo deviceInfo;
309 char networkId[] = "255.255.255.0";
310 JsonObject jsonObject;
311 jsonObject[PARAM_KEY_OS_VERSION] = "5.0.3";
312 jsonObject[PARAM_KEY_OS_TYPE] = 1;
313 std::string extraData = SafetyDump(jsonObject);
314 auto ret = CreateDmDeviceInfo(networkId, extraData, deviceInfo);
315 ASSERT_TRUE(ret);
316
317 std::string udid = "mate-60";
318 std::vector<DmDeviceInfo> deviceInfos = { deviceInfo };
319 std::unordered_map<std::string, DmAuthForm> authFormMap = { {udid, PEER_TO_PEER} };
320
321 DpInitedCallback dpInitedCallback;
322 auto softbusCacheMock = std::static_pointer_cast<SoftbusCacheMock>(DmSoftbusCache::dmSoftbusCache);
323 auto dmDeviceProfileConnectorMock = std::static_pointer_cast<DeviceProfileConnectorMock>(
324 DmDeviceProfileConnector::dmDeviceProfileConnector);
325
326 ASSERT_TRUE(softbusCacheMock != nullptr);
327 ASSERT_TRUE(dmDeviceProfileConnectorMock != nullptr);
328
329 EXPECT_CALL(*softbusCacheMock, GetDeviceInfoFromCache(_))
330 .WillOnce(DoAll(SetArgReferee<0>(deviceInfos), Return(DM_OK)));
331 EXPECT_CALL(*softbusCacheMock, GetUdidFromCache(_, _)).WillOnce(Return(DM_OK));
332 EXPECT_CALL(*softbusCacheMock, GetUuidFromCache(_, _)).WillOnce(Return(DM_OK));
333 EXPECT_CALL(*dmDeviceProfileConnectorMock, GetAppTrustDeviceList(_, _)).WillOnce(Return(authFormMap));
334
335 // @tc.expect: authFormMap find udid failed.
336 dpInitedCallback.PutAllTrustedDevices();
337 }
338 } // DistributedHardware
339 } // OHOS