1 /*
2 * Copyright (c) 2024-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 #include "network/softbus/softbus_handler_asset.h"
16
17 #include <fcntl.h>
18 #include <gmock/gmock.h>
19 #include "gtest/gtest.h"
20 #include <memory>
21 #include <string>
22
23 #include "device_manager_impl_mock.h"
24 #include "dfs_error.h"
25 #include "mock_other_method.h"
26 #include "network/softbus/softbus_session_pool.h"
27 #include "socket_mock.h"
28
29 namespace OHOS {
30 namespace Storage {
31 namespace DistributedFile {
32 namespace Test {
33 using namespace OHOS::FileManagement;
34 using namespace std;
35 using namespace testing;
36 using namespace testing::ext;
37
38 DistributedHardware::DmDeviceInfo deviceInfo = {
39 .deviceId = "testdevid",
40 .deviceName = "testdevname",
41 .deviceTypeId = 1,
42 .networkId = "testNetWork",
43 .authForm = DmAuthForm::ACROSS_ACCOUNT,
44 .extraData = "{\"OS_TYPE\":10}",
45 };
46
47 constexpr int32_t INVALID_USER_ID = -1;
48
49 class SoftBusHandlerAssetTest : public testing::Test {
50 public:
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp();
54 void TearDown();
55 void CheckSrcSameAccountPass();
56 void CheckSrcDiffAccountPass();
57 void CheckSrcBothSamePass();
58 void CheckSrcBothDiffPass();
59 static inline shared_ptr<DfsDeviceOtherMethodMock> otherMethodMock_ = nullptr;
60 static inline shared_ptr<SocketMock> socketMock_ = nullptr;
61 static inline shared_ptr<DeviceManagerImplMock> deviceManagerImplMock_ = nullptr;
62 };
63
CheckSrcSameAccountPass()64 void SoftBusHandlerAssetTest::CheckSrcSameAccountPass()
65 {
66 AccountSA::OhosAccountInfo osAccountInfo;
67 osAccountInfo.uid_ = "test";
68 std::vector<int32_t> userIds{100, 101};
69 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
70 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)));
71 EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
72 .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(FileManagement::E_OK)));
73 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0));
74 EXPECT_CALL(*deviceManagerImplMock_, CheckSrcIsSameAccount(_, _)).WillOnce(Return(true));
75 }
76
CheckSrcDiffAccountPass()77 void SoftBusHandlerAssetTest::CheckSrcDiffAccountPass()
78 {
79 std::vector<int32_t> userIds{100, 101};
80 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
81 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)));
82 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0));
83 }
84
CheckSrcBothSamePass()85 void SoftBusHandlerAssetTest::CheckSrcBothSamePass()
86 {
87 AccountSA::OhosAccountInfo osAccountInfo;
88 osAccountInfo.uid_ = "test";
89 std::vector<int32_t> userIds{100, 101};
90 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
91 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)))
92 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)));
93 EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
94 .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(FileManagement::E_OK)))
95 .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(FileManagement::E_OK)));
96 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0)).WillOnce(Return(0));
97 EXPECT_CALL(*deviceManagerImplMock_, CheckSrcIsSameAccount(_, _)).WillOnce(Return(true));
98 EXPECT_CALL(*socketMock_, SetAccessInfo(_, _)).WillOnce(Return(FileManagement::E_OK));
99 }
100
CheckSrcBothDiffPass()101 void SoftBusHandlerAssetTest::CheckSrcBothDiffPass()
102 {
103 std::vector<int32_t> userIds{100, 101};
104 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
105 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)))
106 .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(FileManagement::E_OK)));
107 EXPECT_CALL(*deviceManagerImplMock_, GetLocalDeviceInfo(_, _)).WillOnce(Return(0)).WillOnce(Return(0));
108 }
109
SetUpTestCase(void)110 void SoftBusHandlerAssetTest::SetUpTestCase(void)
111 {
112 GTEST_LOG_(INFO) << "SetUpTestCase";
113 otherMethodMock_ = make_shared<DfsDeviceOtherMethodMock>();
114 DfsDeviceOtherMethodMock::otherMethod = otherMethodMock_;
115 socketMock_ = make_shared<SocketMock>();
116 SocketMock::dfsSocket = socketMock_;
117 deviceManagerImplMock_ = make_shared<DeviceManagerImplMock>();
118 DeviceManagerImplMock::dfsDeviceManagerImpl = deviceManagerImplMock_;
119 }
120
TearDownTestCase(void)121 void SoftBusHandlerAssetTest::TearDownTestCase(void)
122 {
123 GTEST_LOG_(INFO) << "TearDownTestCase";
124 SocketMock::dfsSocket = nullptr;
125 socketMock_ = nullptr;
126 DeviceManagerImplMock::dfsDeviceManagerImpl = nullptr;
127 deviceManagerImplMock_ = nullptr;
128 DfsDeviceOtherMethodMock::otherMethod = nullptr;
129 otherMethodMock_ = nullptr;
130 }
131
SetUp(void)132 void SoftBusHandlerAssetTest::SetUp(void)
133 {
134 GTEST_LOG_(INFO) << "SetUp";
135 }
136
TearDown(void)137 void SoftBusHandlerAssetTest::TearDown(void)
138 {
139 GTEST_LOG_(INFO) << "TearDown";
140 }
141
142 /**
143 * @tc.name: SoftBusHandlerAssetTest_CreateAssetLocalSessionServer_0100
144 * @tc.desc: Verify the CreateAssetLocalSessionServe function.
145 * @tc.type: FUNC
146 * @tc.require: I9JXPR
147 */
148 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_CreateAssetLocalSessionServer_0100, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_CreateAssetLocalSessionServer_0100 start";
151 std::string sessionName = SoftBusHandlerAsset::ASSET_LOCAL_SESSION_NAME;
152 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
153 softBusHandlerAsset.serverIdMap_.clear();
154 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
155 softBusHandlerAsset.CreateAssetLocalSessionServer();
156 EXPECT_EQ(softBusHandlerAsset.serverIdMap_.size(), 0);
157
158 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(0));
159 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(-1));
160 softBusHandlerAsset.CreateAssetLocalSessionServer();
161 EXPECT_EQ(softBusHandlerAsset.serverIdMap_.size(), 0);
162
163 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(0));
164 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(0));
165 softBusHandlerAsset.CreateAssetLocalSessionServer();
166 if (softBusHandlerAsset.serverIdMap_.find(sessionName) != softBusHandlerAsset.serverIdMap_.end()) {
167 EXPECT_TRUE(true);
168 } else {
169 EXPECT_TRUE(false);
170 }
171 SoftBusSessionPool::SessionInfo sessionInfo;
172 bool flag = SoftBusSessionPool::GetInstance().GetSessionInfo(sessionName, sessionInfo);
173 EXPECT_EQ(flag, true);
174 softBusHandlerAsset.CreateAssetLocalSessionServer();
175 EXPECT_EQ(softBusHandlerAsset.serverIdMap_.size(), 1);
176
177 softBusHandlerAsset.serverIdMap_.clear();
178 SoftBusSessionPool::GetInstance().DeleteSessionInfo(sessionName);
179 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_CreateAssetLocalSessionServer_0100 end";
180 }
181
182 /**
183 * @tc.name: SoftBusHandlerAssetTest_DeleteAssetLocalSessionServer_0100
184 * @tc.desc: Verify the DeleteAssetLocalSessionServer function.
185 * @tc.type: FUNC
186 * @tc.require: I9JXPR
187 */
188 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_DeleteAssetLocalSessionServer_0100, TestSize.Level1)
189 {
190 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_DeleteAssetLocalSessionServer_0100 start";
191 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
192 softBusHandlerAsset.DeleteAssetLocalSessionServer();
193 std::string sessionName = SoftBusHandlerAsset::ASSET_LOCAL_SESSION_NAME;
194 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(0));
195 EXPECT_CALL(*socketMock_, Listen(_, _, _, _)).WillOnce(Return(0));
196 softBusHandlerAsset.CreateAssetLocalSessionServer();
197 if (softBusHandlerAsset.serverIdMap_.find(sessionName) != softBusHandlerAsset.serverIdMap_.end()) {
198 EXPECT_TRUE(true);
199 } else {
200 EXPECT_TRUE(false);
201 }
202
203 softBusHandlerAsset.serverIdMap_.insert(make_pair("test", 0));
204 SoftBusSessionPool::SessionInfo sessionInfo;
205 bool flag = SoftBusSessionPool::GetInstance().GetSessionInfo(sessionName, sessionInfo);
206 EXPECT_EQ(flag, true);
207 softBusHandlerAsset.DeleteAssetLocalSessionServer();
208 EXPECT_EQ(softBusHandlerAsset.serverIdMap_.size(), 1);
209 flag = SoftBusSessionPool::GetInstance().GetSessionInfo(sessionName, sessionInfo);
210 EXPECT_EQ(flag, false);
211
212 softBusHandlerAsset.DeleteAssetLocalSessionServer();
213 EXPECT_EQ(softBusHandlerAsset.serverIdMap_.size(), 1);
214 softBusHandlerAsset.serverIdMap_.clear();
215 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_DeleteAssetLocalSessionServer_0100 end";
216 }
217
218 /**
219 * @tc.name: SoftBusHandlerAssetTest_AssetBind_0100
220 * @tc.desc: Verify the AssetBind function.
221 * @tc.type: FUNC
222 * @tc.require: I9JXPR
223 */
224 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_AssetBind_0100, TestSize.Level1)
225 {
226 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetBind_0100 start";
227 #ifndef SUPPORT_SAME_ACCOUNT
228 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
229 int32_t socketId = 0;
230
231 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_)).WillOnce(Return(INVALID_USER_ID));
232 EXPECT_EQ(softBusHandlerAsset.AssetBind("", socketId), E_PERMISSION_DENIED);
233
234 CheckSrcDiffAccountPass();
235 EXPECT_EQ(softBusHandlerAsset.AssetBind("", socketId), E_OPEN_SESSION);
236
237 CheckSrcDiffAccountPass();
238 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
239 EXPECT_EQ(softBusHandlerAsset.AssetBind("test", socketId), E_OPEN_SESSION);
240
241 std::vector<DmDeviceInfo> deviceList;
242 deviceInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
243 deviceList.push_back(deviceInfo);
244 CheckSrcDiffAccountPass();
245 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
246 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
247 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
248 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), E_OPEN_SESSION);
249
250 CheckSrcBothDiffPass();
251 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
252 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
253 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(E_OK));
254 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(-1));
255 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), -1);
256
257 CheckSrcBothDiffPass();
258 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
259 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
260 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(E_OK));
261 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(E_OK));
262 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), E_OK);
263 #endif
264 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetBind_0100 end";
265 }
266
267 /**
268 * @tc.name: SoftBusHandlerAssetTest_AssetBind_0200
269 * @tc.desc: Verify the AssetBind function.
270 * @tc.type: FUNC
271 * @tc.require: I9JXPR
272 */
273 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_AssetBind_0200, TestSize.Level1)
274 {
275 #ifdef SUPPORT_SAME_ACCOUNT
276 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetBind_0200 start";
277 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
278 int32_t socketId = 0;
279
280 EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_)).WillOnce(Return(INVALID_USER_ID));
281 EXPECT_EQ(softBusHandlerAsset.AssetBind("", socketId), E_PERMISSION_DENIED);
282
283 CheckSrcSameAccountPass();
284 EXPECT_EQ(softBusHandlerAsset.AssetBind("", socketId), E_OPEN_SESSION);
285
286 CheckSrcSameAccountPass();
287 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillOnce(Return(0));
288 EXPECT_EQ(softBusHandlerAsset.AssetBind("test", socketId), E_OPEN_SESSION);
289
290 std::vector<DmDeviceInfo> deviceList;
291 deviceInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
292 deviceList.push_back(deviceInfo);
293 CheckSrcSameAccountPass();
294 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
295 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
296 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(-1));
297 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), E_OPEN_SESSION);
298
299 CheckSrcBothSamePass();
300 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
301 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
302 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(E_OK));
303 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(-1));
304 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), -1);
305
306 CheckSrcBothSamePass();
307 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
308 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
309 EXPECT_CALL(*socketMock_, Socket(_)).WillOnce(Return(E_OK));
310 EXPECT_CALL(*socketMock_, Bind(_, _, _, _)).WillOnce(Return(E_OK));
311 EXPECT_EQ(softBusHandlerAsset.AssetBind("testNetWork", socketId), E_OK);
312 #endif
313 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetBind_0200 end";
314 }
315
316 /**
317 * @tc.name: SoftBusHandlerAssetTest_OnAssetRecvBind_0100
318 * @tc.desc: Verify the OnAssetRecvBind function.
319 * @tc.type: FUNC
320 * @tc.require: I9JXPR
321 */
322 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_OnAssetRecvBind_0100, TestSize.Level1)
323 {
324 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_OnAssetRecvBind_0100 start";
325 #ifdef SUPPORT_SAME_ACCOUNT
326 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
327 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillOnce(Return(0));
328 softBusHandlerAsset.OnAssetRecvBind(0, "test");
329 auto iter = softBusHandlerAsset.clientInfoMap_.find(0);
330 if (iter == softBusHandlerAsset.clientInfoMap_.end()) {
331 EXPECT_TRUE(true);
332 } else {
333 EXPECT_TRUE(false);
334 }
335 EXPECT_EQ(softBusHandlerAsset.GetClientInfo(0), "");
336
337 std::vector<DmDeviceInfo> deviceList;
338 deviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
339 deviceList.push_back(deviceInfo);
340 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
341 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
342 softBusHandlerAsset.OnAssetRecvBind(0, deviceInfo.networkId);
343 EXPECT_EQ(softBusHandlerAsset.GetClientInfo(0), "");
344
345 deviceList.clear();
346 deviceInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
347 deviceList.push_back(deviceInfo);
348 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
349 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
350 softBusHandlerAsset.OnAssetRecvBind(0, deviceInfo.networkId);
351 EXPECT_EQ(softBusHandlerAsset.GetClientInfo(0), deviceInfo.networkId);
352
353 softBusHandlerAsset.RemoveClientInfo(0);
354 EXPECT_EQ(softBusHandlerAsset.GetClientInfo(0), "");
355 iter = softBusHandlerAsset.clientInfoMap_.find(0);
356 if (iter == softBusHandlerAsset.clientInfoMap_.end()) {
357 EXPECT_TRUE(true);
358 } else {
359 EXPECT_TRUE(false);
360 }
361 softBusHandlerAsset.RemoveClientInfo(0);
362 #endif
363 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_OnAssetRecvBind_0100 end";
364 }
365
366 /**
367 * @tc.name: SoftBusHandlerAssetTest_AddAssetObj_0100
368 * @tc.desc: Verify the OnAssetRecvBind function.
369 * @tc.type: FUNC
370 * @tc.require: I9JXPR
371 */
372 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_AddAssetObj_0100, TestSize.Level1)
373 {
374 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AddAssetObj_0100 start";
375 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
376 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
377 softBusHandlerAsset.AddAssetObj(0, assetObj);
378 softBusHandlerAsset.AddAssetObj(0, assetObj);
379 auto iter = softBusHandlerAsset.assetObjMap_.find(0);
380 if (iter != softBusHandlerAsset.assetObjMap_.end()) {
381 EXPECT_TRUE(true);
382 } else {
383 EXPECT_TRUE(false);
384 }
385
386 EXPECT_EQ(softBusHandlerAsset.GetAssetObj(0), assetObj);
387
388 softBusHandlerAsset.RemoveAssetObj(0);
389 EXPECT_EQ(softBusHandlerAsset.GetAssetObj(0), nullptr);
390 iter = softBusHandlerAsset.assetObjMap_.find(0);
391 if (iter == softBusHandlerAsset.assetObjMap_.end()) {
392 EXPECT_TRUE(true);
393 } else {
394 EXPECT_TRUE(false);
395 }
396
397 softBusHandlerAsset.RemoveAssetObj(0);
398 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AddAssetObj_0100 end";
399 }
400
401 /**
402 * @tc.name: SoftBusHandlerAssetTest_GetDstFile_0100
403 * @tc.desc: Verify the GetDstFile function.
404 * @tc.type: FUNC
405 * @tc.require: I9JXPR
406 */
407 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_GetDstFile_0100, TestSize.Level1)
408 {
409 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GetDstFile_0100 start";
410 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
411 string file = "test123";
412 auto rlt = softBusHandlerAsset.GetDstFile(file, "demoA", "demoB", "0", true);
413 EXPECT_EQ(rlt, "");
414
415 file = "demoA/test";
416 rlt = softBusHandlerAsset.GetDstFile(file, "demoA", "demoB", "0", true);
417 string execptRlt = "demoB/ASSET_TEMP/test.asset_single?srcBundleName=demoA&sessionId=0";
418 EXPECT_EQ(rlt, execptRlt);
419
420 execptRlt = "demoB/ASSET_TEMP/test.asset_zip?srcBundleName=demoA&sessionId=0";
421 rlt = softBusHandlerAsset.GetDstFile(file, "demoA", "demoB", "0", false);
422 EXPECT_EQ(rlt, execptRlt);
423 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GetDstFile_0100 end";
424 }
425
426 /**
427 * @tc.name: SoftBusHandlerAssetTest_AssetSendFile_0100
428 * @tc.desc: Verify the AssetSendFile function.
429 * @tc.type: FUNC
430 * @tc.require: I9JXPR
431 */
432 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_AssetSendFile_0100, TestSize.Level1)
433 {
434 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetSendFile_0100 start";
435 #ifdef SUPPORT_SAME_ACCOUNT
436 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
437 string file = "test123";
438 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), ERR_BAD_VALUE);
439
440 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
441 softBusHandlerAsset.AddAssetObj(0, assetObj);
442 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _)).WillOnce(Return(0));
443 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), ERR_BAD_VALUE);
444
445 softBusHandlerAsset.RemoveAssetObj(0);
446 assetObj->dstNetworkId_ = "testNetWork";
447 assetObj->srcBundleName_ = "demoA";
448 assetObj->dstBundleName_ = "demoB";
449 assetObj->sessionId_ = "0";
450 softBusHandlerAsset.AddAssetObj(0, assetObj);
451
452 std::vector<DmDeviceInfo> deviceList;
453 deviceList.push_back(deviceInfo);
454 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
455 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
456 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), ERR_BAD_VALUE);
457
458 deviceList.clear();
459 deviceInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
460 deviceList.push_back(deviceInfo);
461 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
462 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
463 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), ERR_BAD_VALUE);
464
465 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
466 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
467 EXPECT_CALL(*socketMock_, SendFile(_, _, _, _)).WillOnce(Return(-1));
468 file = "demoA/test";
469 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), -1);
470
471 EXPECT_CALL(*deviceManagerImplMock_, GetTrustedDeviceList(_, _, _))
472 .WillOnce(DoAll(SetArgReferee<2>(deviceList), Return(0)));
473 EXPECT_CALL(*socketMock_, SendFile(_, _, _, _)).WillOnce(Return(E_OK));
474 EXPECT_EQ(softBusHandlerAsset.AssetSendFile(0, file, true), E_OK);
475 #endif
476 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_AssetSendFile_0100 end";
477 }
478
479 /**
480 * @tc.name: SoftBusHandlerAssetTest_GetLocalNetworkId_0100
481 * @tc.desc: Verify the GetLocalNetworkId function.
482 * @tc.type: FUNC
483 * @tc.require: I9JXPR
484 */
485 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_GetLocalNetworkId_0100, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GetLocalNetworkId_0100 start";
488 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
489 EXPECT_CALL(*deviceManagerImplMock_, GetLocalNodeDeviceInfo(_, _)).WillOnce(Return(-1));
490 string ret = softBusHandlerAsset.GetLocalNetworkId();
491 EXPECT_EQ(ret, "");
492
493 EXPECT_CALL(*deviceManagerImplMock_, GetLocalNodeDeviceInfo(_, _)).WillOnce(Return(0));
494 ret = softBusHandlerAsset.GetLocalNetworkId();
495 EXPECT_EQ(ret, "100");
496 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GetLocalNetworkId_0100 end";
497 }
498
499 /**
500 * @tc.name: SoftBusHandlerAssetTest_GenerateAssetObjInfo_0100
501 * @tc.desc: Verify the GenerateAssetObjInfo function.
502 * @tc.type: FUNC
503 * @tc.require: I9JXPR
504 */
505 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_GenerateAssetObjInfo_0100, TestSize.Level1)
506 {
507 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateAssetObjInfo_0100 start";
508 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
509 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
510 string fileName = "test";
511 auto ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
512 EXPECT_EQ(ret, ERR_BAD_VALUE);
513
514 fileName = "/account/device_view/local/data/test";
515 ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
516 EXPECT_EQ(ret, ERR_BAD_VALUE);
517
518 fileName = "/account/device_view/local/data/test/";
519 ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
520 EXPECT_EQ(ret, ERR_BAD_VALUE);
521
522 fileName = "/account/device_view/local/data/test/sessionId=20";
523 ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
524 EXPECT_EQ(ret, ERR_BAD_VALUE);
525
526 fileName = "/account/device_view/local/data/test/sessionId=20&srcBundleName=demoA";
527 EXPECT_CALL(*deviceManagerImplMock_, GetLocalNodeDeviceInfo(_, _)).WillOnce(Return(-1));
528 ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
529 EXPECT_EQ(ret, ERR_BAD_VALUE);
530
531 fileName = "/account/device_view/local/data/test/sessionId=20&srcBundleName=demoA";
532 EXPECT_CALL(*deviceManagerImplMock_, GetLocalNodeDeviceInfo(_, _)).WillOnce(Return(0));
533 ret = softBusHandlerAsset.GenerateAssetObjInfo(0, fileName, assetObj);
534 EXPECT_EQ(ret, E_OK);
535 EXPECT_EQ(assetObj->dstBundleName_, "test");
536 EXPECT_EQ(assetObj->sessionId_, "20");
537 EXPECT_EQ(assetObj->srcBundleName_, "demoA");
538 EXPECT_EQ(assetObj->dstNetworkId_, "100");
539 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateAssetObjInfo_0100 end";
540 }
541
542 /**
543 * @tc.name: SoftBusHandlerAssetTest_GenerateUris_0100
544 * @tc.desc: Verify the GenerateUris function.
545 * @tc.type: FUNC
546 * @tc.require: I9JXPR
547 */
548 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_GenerateUris_0100, TestSize.Level1)
549 {
550 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateUris_0100 start";
551 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
552 string fileName = "test";
553 vector<string> fileList;
554 fileList.push_back(fileName);
555 auto rlt = softBusHandlerAsset.GenerateUris(fileList, "demoB", true);
556 EXPECT_EQ(rlt.size(), 0);
557
558 fileList[0].clear();
559 fileList[0] = "demoB/ASSET_TEMP";
560 rlt = softBusHandlerAsset.GenerateUris(fileList, "demoB", true);
561 EXPECT_EQ(rlt.size(), 0);
562
563 fileList[0].clear();
564 fileList[0] = "demoB/ASSET_TEMP/test.asset_single?";
565 rlt = softBusHandlerAsset.GenerateUris(fileList, "demoB", true);
566 EXPECT_EQ(rlt.size(), 1);
567 EXPECT_EQ(rlt[0], "file://demoB/data/storage/el2/distributedfiles/test");
568 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateUris_0100 end";
569 }
570
571 /**
572 * @tc.name: SoftBusHandlerAssetTest_GenerateUris_0200
573 * @tc.desc: Verify the GenerateUris function.
574 * @tc.type: FUNC
575 * @tc.require: I9JXPR
576 */
577 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_GenerateUris_0200, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateUris_0200 start";
580 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
581 string fileName = "test";
582 vector<string> fileList;
583 fileList.push_back(fileName);
584 auto rlt = softBusHandlerAsset.GenerateUris(fileList, "demoB", false);
585 EXPECT_EQ(rlt.size(), 0);
586
587 fileList[0].clear();
588 fileList[0] = "demoB/ASSET_TEMP/test1";
589 fileList.push_back("demoB/ASSET_TEMP/test2");
590 rlt = softBusHandlerAsset.GenerateUris(fileList, "demoB", false);
591 EXPECT_EQ(rlt.size(), 2);
592 EXPECT_EQ(rlt[0], "file://demoB/data/storage/el2/distributedfiles/test1");
593 EXPECT_EQ(rlt[1], "file://demoB/data/storage/el2/distributedfiles/test2");
594 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_GenerateUris_0200 end";
595 }
596
597 /**
598 * @tc.name: SoftBusHandlerAssetTest_IsDir_0100
599 * @tc.desc: Verify the IsDir function.
600 * @tc.type: FUNC
601 * @tc.require: I9JXPR
602 */
603 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_IsDir_0100, TestSize.Level1)
604 {
605 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_IsDir_0100 start";
606 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
607 string fileName = "/data/test/";
608 auto rlt = softBusHandlerAsset.IsDir(fileName);
609 EXPECT_EQ(rlt, true);
610
611 fileName.clear();
612 fileName = "/data/test/test.txt";
613 int32_t fd = open(fileName.c_str(), O_RDWR | O_CREAT);
614 ASSERT_TRUE(fd != -1) << "SoftBusHandlerAssetTest_IsDir_0100 Create File Failed!";
615 close(fd);
616 rlt = softBusHandlerAsset.IsDir(fileName);
617 EXPECT_EQ(rlt, false);
618
619 softBusHandlerAsset.RemoveFile(fileName, true);
620 rlt = softBusHandlerAsset.IsDir(fileName);
621 EXPECT_EQ(rlt, false);
622 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_IsDir_0100 end";
623 }
624
625 /**
626 * @tc.name: SoftBusHandlerAssetTest_RemoveFile_0100
627 * @tc.desc: Verify the RemoveFile function.
628 * @tc.type: FUNC
629 * @tc.require: I9JXPR
630 */
631 HWTEST_F(SoftBusHandlerAssetTest, SoftBusHandlerAssetTest_RemoveFile_0100, TestSize.Level1)
632 {
633 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_RemoveFile_0100 start";
634 string fileName = "/data/test/test.txt";
635 int32_t fd = open(fileName.c_str(), O_RDWR | O_CREAT);
636 ASSERT_TRUE(fd != -1) << "SoftBusHandlerAssetTest_RemoveFile_0100 Create File Failed!";
637 close(fd);
638
639 auto &&softBusHandlerAsset = SoftBusHandlerAsset::GetInstance();
640 softBusHandlerAsset.RemoveFile(fileName, false);
641 auto ret = access(fileName.c_str(), F_OK);
642 EXPECT_EQ(ret, 0);
643
644 softBusHandlerAsset.RemoveFile(fileName, true);
645 ret = access(fileName.c_str(), F_OK);
646 EXPECT_NE(ret, 0);
647 softBusHandlerAsset.RemoveFile(fileName, true);
648 GTEST_LOG_(INFO) << "SoftBusHandlerAssetTest_RemoveFile_0100 end";
649 }
650 } // namespace Test
651 } // namespace DistributedFile
652 } // namespace Storage
653 } // namespace OHOS
654