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
16 #include <filesystem>
17 #include <fstream>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include "all_connect_manager_mock.h"
22 #include "daemon_execute.h"
23 #include "daemon_mock.h"
24 #include "device_manager_impl.h"
25 #include "dfs_error.h"
26 #include "network/devsl_dispatcher.h"
27 #include "sandbox_helper.h"
28 #include "softbus_handler_asset_mock.h"
29 #include "softbus_handler_mock.h"
30
31 namespace {
32 std::string g_physicalPath;
33 int32_t g_getPhysicalPath = 0;
34 bool g_checkValidPath = false;
35 bool g_isFolder;
36 int32_t g_dmResult = 0;
37
38 const int32_t E_INVAL_ARG_NAPI = 401;
39 const std::string FILE_MANAGER_AUTHORITY = "docs";
40 const std::string MEDIA_AUTHORITY = "media";
41 } // namespace
42
43 namespace OHOS::AppFileService {
GetPhysicalPath(const std::string & fileUri,const std::string & userId,std::string & physicalPath)44 int32_t SandboxHelper::GetPhysicalPath(const std::string &fileUri, const std::string &userId, std::string &physicalPath)
45 {
46 physicalPath = g_physicalPath;
47 return g_getPhysicalPath;
48 }
49
CheckValidPath(const std::string & filePath)50 bool SandboxHelper::CheckValidPath(const std::string &filePath)
51 {
52 return g_checkValidPath;
53 }
54 } // namespace OHOS::AppFileService
55
56 namespace OHOS::DistributedHardware {
57
GetLocalDeviceInfo(const std::string & pkgName,DmDeviceInfo & info)58 int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info)
59 {
60 return g_dmResult;
61 }
62
63 } // namespace OHOS::DistributedHardware
64
65 namespace OHOS::Storage::DistributedFile::Utils {
IsFolder(const std::string & name)66 bool IsFolder(const std::string &name)
67 {
68 return g_isFolder;
69 }
70 } // namespace OHOS::Storage::DistributedFile::Utils
71
72 namespace OHOS::Storage::DistributedFile::Test {
73 using namespace OHOS::FileManagement;
74 using namespace testing;
75 using namespace testing::ext;
76 using namespace std;
77 constexpr int32_t BLOCK_INTERVAL_SEND_FILE = 8 * 1000;
78 class DaemonExecuteTest : public testing::Test {
79 public:
80 static void SetUpTestCase(void);
81 static void TearDownTestCase(void);
82 void SetUp();
83 void TearDown();
84 std::shared_ptr<DaemonExecute> daemonExecute_;
85
86 public:
87 static inline std::shared_ptr<SoftBusHandlerAssetMock> softBusHandlerAssetMock_ = nullptr;
88 static inline std::shared_ptr<SoftBusHandlerMock> softBusHandlerMock_ = nullptr;
89 static inline std::shared_ptr<AllConnectManagerMock> allConnectManagerMock_ = nullptr;
90 };
91
SetUpTestCase(void)92 void DaemonExecuteTest::SetUpTestCase(void)
93 {
94 GTEST_LOG_(INFO) << "SetUpTestCase";
95 softBusHandlerAssetMock_ = std::make_shared<SoftBusHandlerAssetMock>();
96 ISoftBusHandlerAssetMock::iSoftBusHandlerAssetMock_ = softBusHandlerAssetMock_;
97 allConnectManagerMock_ = std::make_shared<AllConnectManagerMock>();
98 IAllConnectManagerMock::iAllConnectManagerMock_ = allConnectManagerMock_;
99 softBusHandlerMock_ = std::make_shared<SoftBusHandlerMock>();
100 ISoftBusHandlerMock::iSoftBusHandlerMock_ = softBusHandlerMock_;
101
102 std::string path = "/mnt/hmdfs/100/account/device_view/local/data/com.example.app";
103 if (!std::filesystem::exists(path)) {
104 std::filesystem::create_directory(path);
105 std::filesystem::create_directory(path + "/docs");
106 }
107 std::ofstream file1(path + "/1.txt");
108 std::ofstream file2(path + "/2.txt");
109 }
110
TearDownTestCase(void)111 void DaemonExecuteTest::TearDownTestCase(void)
112 {
113 GTEST_LOG_(INFO) << "TearDownTestCase";
114 ISoftBusHandlerAssetMock::iSoftBusHandlerAssetMock_ = nullptr;
115 softBusHandlerAssetMock_ = nullptr;
116 IAllConnectManagerMock::iAllConnectManagerMock_ = nullptr;
117 allConnectManagerMock_ = nullptr;
118 ISoftBusHandlerMock::iSoftBusHandlerMock_ = nullptr;
119 softBusHandlerMock_ = nullptr;
120
121 std::string path = "/mnt/hmdfs/100/account/device_view/local/data/com.example.app";
122 if (std::filesystem::exists(path)) {
123 std::filesystem::remove_all(path);
124 }
125 }
126
SetUp(void)127 void DaemonExecuteTest::SetUp(void)
128 {
129 GTEST_LOG_(INFO) << "SetUp";
130 daemonExecute_ = std::make_shared<DaemonExecute>();
131 }
132
TearDown(void)133 void DaemonExecuteTest::TearDown(void)
134 {
135 GTEST_LOG_(INFO) << "TearDown";
136 daemonExecute_ = nullptr;
137 }
138
139 /**
140 * @tc.name: DaemonExecute_ExecutePushAsset_001
141 * @tc.desc: verify ExecutePushAsset.
142 * @tc.type: FUNC
143 * @tc.require: I7TDJK
144 */
145 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePushAsset_001, TestSize.Level1)
146 {
147 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePushAsset_001 begin";
148 std::shared_ptr<PushAssetData> pushData1 = nullptr;
149 auto eventptr = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData1, 0);
150 eventptr.reset(nullptr);
151 ASSERT_NE(daemonExecute_, nullptr);
152 daemonExecute_->ExecutePushAsset(eventptr);
153
154 std::shared_ptr<PushAssetData> pushData = nullptr;
155 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
156 daemonExecute_->ExecutePushAsset(event);
157
158 int32_t userId = 100;
159 sptr<AssetObj> assetObj = nullptr;
160 pushData = std::make_shared<PushAssetData>(userId, assetObj);
161 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
162 daemonExecute_->ExecutePushAsset(event);
163
164 assetObj = new (std::nothrow) AssetObj();
165 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
166 assetObj->dstNetworkId_ = "test";
167 DevslDispatcher::devslMap_.clear();
168 DevslDispatcher::devslMap_.insert(make_pair("test", static_cast<int32_t>(SecurityLabel::S4)));
169 pushData = std::make_shared<PushAssetData>(userId, assetObj);
170 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
171 EXPECT_CALL(*softBusHandlerAssetMock_, AssetBind(_, _)).WillOnce(Return(-1));
172 daemonExecute_->ExecutePushAsset(event);
173
174 assetObj->uris_.push_back("test");
175 assetObj->srcBundleName_ = "srcBundleName_";
176 pushData = std::make_shared<PushAssetData>(userId, assetObj);
177 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
178 EXPECT_CALL(*softBusHandlerAssetMock_, AssetBind(_, _)).WillOnce(Return(E_OK));
179 daemonExecute_->ExecutePushAsset(event);
180
181 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePushAsset_001 end";
182 }
183
184 /**
185 * @tc.name: DaemonExecute_ExecutePushAsset_002
186 * @tc.desc: verify ExecutePushAsset.
187 * @tc.type: FUNC
188 * @tc.require: I7TDJK
189 */
190 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePushAsset_002, TestSize.Level1)
191 {
192 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePushAsset_002 begin";
193 int32_t userId = 100;
194 ASSERT_NE(daemonExecute_, nullptr);
195 sptr<AssetObj> assetObj = new (std::nothrow) AssetObj();
196 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
197 assetObj->dstNetworkId_ = "test";
198 DevslDispatcher::devslMap_.clear();
199 DevslDispatcher::devslMap_.insert(make_pair("test", static_cast<int32_t>(SecurityLabel::S4)));
200 assetObj->uris_.push_back("file://com.example.app/data/storage/el2/distributedfiles/docs/1.txt");
201 assetObj->srcBundleName_ = "com.example.app";
202 g_getPhysicalPath = E_OK;
203 g_checkValidPath = true;
204 g_isFolder = false;
205 g_physicalPath = "/mnt/hmdfs/100/account/device_view/local/data/com.example.app/docs/1.txt";
206 std::shared_ptr<PushAssetData> pushData = std::make_shared<PushAssetData>(userId, assetObj);
207 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
208 EXPECT_CALL(*softBusHandlerAssetMock_, AssetBind(_, _)).WillOnce(Return(E_OK));
209 EXPECT_CALL(*softBusHandlerAssetMock_, AssetSendFile(_, _, _)).WillOnce(Return(-1));
210 daemonExecute_->ExecutePushAsset(event);
211
212 EXPECT_CALL(*softBusHandlerAssetMock_, AssetBind(_, _)).WillOnce(Return(E_OK));
213 EXPECT_CALL(*softBusHandlerAssetMock_, AssetSendFile(_, _, _)).WillOnce(Return(E_OK));
214 daemonExecute_->ExecutePushAsset(event);
215
216 assetObj->uris_.push_back("file://com.example.app/data/storage/el2/distributedfiles/docs/2.txt");
217 pushData = std::make_shared<PushAssetData>(userId, assetObj);
218 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PUSH_ASSET, pushData, 0);
219 EXPECT_CALL(*softBusHandlerAssetMock_, AssetBind(_, _)).WillOnce(Return(E_OK));
220 EXPECT_CALL(*softBusHandlerAssetMock_, CompressFile(_, _, _)).WillOnce(Return(-1));
221 daemonExecute_->ExecutePushAsset(event);
222 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePushAsset_002 end";
223 }
224
225 /**
226 * @tc.name: DaemonExecute_ExecuteRequestSendFile_001
227 * @tc.desc: verify ExecuteRequestSendFile.
228 * @tc.type: FUNC
229 * @tc.require: I7TDJK
230 */
231 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecuteRequestSendFile_001, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "DaemonExecute_ExecuteRequestSendFile_001 begin";
234 std::shared_ptr<RequestSendFileData> requestSendFileData1 = nullptr;
235 auto eventptr = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData1, 0);
236 eventptr.reset(nullptr);
237 ASSERT_NE(daemonExecute_, nullptr);
238 daemonExecute_->ExecuteRequestSendFile(eventptr);
239
240 std::shared_ptr<RequestSendFileData> requestSendFileData = nullptr;
241 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
242 daemonExecute_->ExecuteRequestSendFile(event);
243
244 requestSendFileData = std::make_shared<RequestSendFileData>("", "", "", "", nullptr);
245 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
246 daemonExecute_->ExecuteRequestSendFile(event);
247
248 auto requestSendFileBlock = std::make_shared<BlockObject<int32_t>>(BLOCK_INTERVAL_SEND_FILE, ERR_BAD_VALUE);
249 requestSendFileData = std::make_shared<RequestSendFileData>("", "", "", "", requestSendFileBlock);
250 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
251 daemonExecute_->ExecuteRequestSendFile(event);
252 EXPECT_EQ(requestSendFileBlock->GetValue(), ERR_BAD_VALUE);
253
254 requestSendFileData = std::make_shared<RequestSendFileData>("test", "", "", "", requestSendFileBlock);
255 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
256 daemonExecute_->ExecuteRequestSendFile(event);
257 EXPECT_EQ(requestSendFileBlock->GetValue(), ERR_BAD_VALUE);
258
259 requestSendFileData = std::make_shared<RequestSendFileData>("test", "", "test", "", requestSendFileBlock);
260 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
261 daemonExecute_->ExecuteRequestSendFile(event);
262 EXPECT_EQ(requestSendFileBlock->GetValue(), ERR_BAD_VALUE);
263
264 requestSendFileData = std::make_shared<RequestSendFileData>("test", "", "test", "test", requestSendFileBlock);
265 event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_REQUEST_SEND_FILE, requestSendFileData, 0);
266 EXPECT_CALL(*allConnectManagerMock_, ApplyAdvancedResource(_, _)).WillOnce(Return(-1));
267 daemonExecute_->ExecuteRequestSendFile(event);
268 EXPECT_EQ(requestSendFileBlock->GetValue(), ERR_APPLY_RESULT);
269 GTEST_LOG_(INFO) << "DaemonExecute_ExecuteRequestSendFile_001 end";
270 }
271
272 /**
273 * @tc.name: DaemonExecute_RequestSendFileInner_001
274 * @tc.desc: verify RequestSendFileInner.
275 * @tc.type: FUNC
276 * @tc.require: I7TDJK
277 */
278 HWTEST_F(DaemonExecuteTest, DaemonExecute_RequestSendFileInner_001, TestSize.Level1)
279 {
280 GTEST_LOG_(INFO) << "DaemonExecute_RequestSendFileInner_001 begin";
281 std::string srcUri;
282 std::string dstPath;
283 std::string dstDeviceId;
284 std::string sessionName;
285 ASSERT_NE(daemonExecute_, nullptr);
286 EXPECT_CALL(*allConnectManagerMock_, ApplyAdvancedResource(_, _)).WillOnce(Return(-1));
287 EXPECT_EQ(daemonExecute_->RequestSendFileInner(srcUri, dstPath, dstDeviceId, sessionName), ERR_APPLY_RESULT);
288
289 EXPECT_CALL(*allConnectManagerMock_, ApplyAdvancedResource(_, _)).WillOnce(Return(E_OK));
290 EXPECT_CALL(*softBusHandlerMock_, OpenSession(_, _, _, _)).WillOnce(Return(-1));
291 EXPECT_EQ(daemonExecute_->RequestSendFileInner(srcUri, dstPath, dstDeviceId, sessionName), -1);
292
293 EXPECT_CALL(*allConnectManagerMock_, ApplyAdvancedResource(_, _)).WillOnce(Return(E_OK));
294 EXPECT_CALL(*softBusHandlerMock_, OpenSession(_, _, _, _)).WillOnce(Return(E_OK));
295 EXPECT_CALL(*softBusHandlerMock_, CopySendFile(_, _, _, _)).WillOnce(Return(-1));
296 EXPECT_EQ(daemonExecute_->RequestSendFileInner(srcUri, dstPath, dstDeviceId, sessionName), -1);
297
298 EXPECT_CALL(*allConnectManagerMock_, ApplyAdvancedResource(_, _)).WillOnce(Return(E_OK));
299 EXPECT_CALL(*softBusHandlerMock_, OpenSession(_, _, _, _)).WillOnce(Return(E_OK));
300 EXPECT_CALL(*softBusHandlerMock_, CopySendFile(_, _, _, _)).WillOnce(Return(E_OK));
301 EXPECT_EQ(daemonExecute_->RequestSendFileInner(srcUri, dstPath, dstDeviceId, sessionName), E_OK);
302 GTEST_LOG_(INFO) << "DaemonExecute_RequestSendFileInner_001 end";
303 }
304
305 /**
306 * @tc.name: DaemonExecute_GetFileList_001
307 * @tc.desc: verify GetFileList.
308 * @tc.type: FUNC
309 * @tc.require: I7TDJK
310 */
311 HWTEST_F(DaemonExecuteTest, DaemonExecute_GetFileList_001, TestSize.Level1)
312 {
313 GTEST_LOG_(INFO) << "DaemonExecute_GetFileList_001 begin";
314 ASSERT_NE(daemonExecute_, nullptr);
315 std::vector<std::string> uris;
316 int32_t userId = 100;
317 std::string srcBundleName;
318
319 uris.push_back("test");
320 srcBundleName = "com.example.app";
321 auto ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
322 EXPECT_TRUE(ret.empty());
323
324 uris.clear();
325 uris.push_back("file://com.example.app/data/storage/el2/distributedfiles/docs/1.txt");
326 g_getPhysicalPath = -1;
327 ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
328 EXPECT_TRUE(ret.empty());
329
330 ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
331 g_getPhysicalPath = E_OK;
332 g_checkValidPath = false;
333 EXPECT_TRUE(ret.empty());
334
335 g_checkValidPath = true;
336 g_isFolder = true;
337 ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
338 EXPECT_TRUE(ret.empty());
339
340 g_isFolder = false;
341 g_physicalPath = "test";
342 ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
343 EXPECT_TRUE(!ret.empty());
344
345 g_physicalPath = "/mnt/hmdfs/100/account/device_view/local/data/com.example.app/docs/1.txt";
346 ret = daemonExecute_->GetFileList(uris, userId, srcBundleName);
347 EXPECT_TRUE(!ret.empty());
348 GTEST_LOG_(INFO) << "DaemonExecute_GetFileList_001 end";
349 }
350
351 /**
352 * @tc.name: DaemonExecute_HandleZip_001
353 * @tc.desc: verify HandleZip.
354 * @tc.type: FUNC
355 * @tc.require: I7TDJK
356 */
357 HWTEST_F(DaemonExecuteTest, DaemonExecute_HandleZip_001, TestSize.Level1)
358 {
359 GTEST_LOG_(INFO) << "DaemonExecute_HandleZip_001 begin";
360 std::vector<std::string> fileList;
361 sptr<AssetObj> assetObj(new (std::nothrow) AssetObj());
362 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
363 std::string sendFileName;
364 bool isSingleFile;
365 ASSERT_NE(daemonExecute_, nullptr);
366 ASSERT_NE(assetObj, nullptr);
367 fileList.emplace_back("/mnt/hmdfs/100/account/device_view/local/data/com.example.app/docs/1.txt");
368 EXPECT_EQ(daemonExecute_->HandleZip(fileList, assetObj, sendFileName, isSingleFile), E_OK);
369
370 fileList.emplace_back("/mnt/hmdfs/100/account/device_view/local/data/com.example.app/docs/2.txt");
371 assetObj->srcBundleName_ = "com.example.appsa";
372 EXPECT_EQ(daemonExecute_->HandleZip(fileList, assetObj, sendFileName, isSingleFile), E_ZIP);
373
374 assetObj->srcBundleName_ = "com.example.app";
375 EXPECT_CALL(*softBusHandlerAssetMock_, CompressFile(_, _, _)).WillOnce(Return(-1));
376 EXPECT_EQ(daemonExecute_->HandleZip(fileList, assetObj, sendFileName, isSingleFile), E_ZIP);
377
378 EXPECT_CALL(*softBusHandlerAssetMock_, CompressFile(_, _, _)).WillOnce(Return(E_OK));
379 EXPECT_EQ(daemonExecute_->HandleZip(fileList, assetObj, sendFileName, isSingleFile), E_OK);
380 GTEST_LOG_(INFO) << "DaemonExecute_HandleZip_001 end";
381 }
382
383 /**
384 * @tc.name: DaemonExecute_PrepareSessionInner_001
385 * @tc.desc: verify PrepareSessionInner.
386 * @tc.type: FUNC
387 * @tc.require: I7TDJK
388 */
389 HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_001, TestSize.Level1)
390 {
391 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_001 begin";
392
393 std::string srcUri;
394 std::string physicalPath;
395 std::string sessionName;
396 sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
397 ASSERT_TRUE(daemon != nullptr) << "daemon assert failed!";
398 HmdfsInfo info;
399 ASSERT_NE(daemonExecute_, nullptr);
400 // Test case 1: CreateSessionServer fails
401 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(-1));
402 EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info),
403 E_SOFTBUS_SESSION_FAILED);
404
405 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_001 end";
406 }
407
408 /**
409 * @tc.name: DaemonExecute_PrepareSessionInner_002
410 * @tc.desc: verify PrepareSessionInner.
411 * @tc.type: FUNC
412 * @tc.require: I7TDJK
413 */
414 HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_002, TestSize.Level1)
415 {
416 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_002 begin";
417
418 std::string srcUri;
419 std::string physicalPath;
420 std::string sessionName;
421 sptr<DaemonMock> daemon = nullptr;
422 HmdfsInfo info;
423 ASSERT_NE(daemonExecute_, nullptr);
424 // Test case 2: CreateSessionServer success but daemon is nullptr
425 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
426 EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_INVAL_ARG_NAPI);
427
428 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_002 end";
429 }
430
431 /**
432 * @tc.name: DaemonExecute_PrepareSessionInner_003
433 * @tc.desc: verify PrepareSessionInner.
434 * @tc.type: FUNC
435 * @tc.require: I7TDJK
436 */
437 HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_003, TestSize.Level1)
438 {
439 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_003 begin";
440
441 std::string srcUri;
442 std::string physicalPath;
443 std::string sessionName;
444 sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
445 ASSERT_TRUE(daemon != nullptr) << "daemon assert failed!";
446 HmdfsInfo info;
447 ASSERT_NE(daemonExecute_, nullptr);
448 // Test case 3: CreateSessionServer succeeds, but authority is not media or docs
449 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
450 EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_OK);
451
452 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_003 end";
453 }
454
455 /**
456 * @tc.name: DaemonExecute_PrepareSessionInner_004
457 * @tc.desc: verify PrepareSessionInner.
458 * @tc.type: FUNC
459 * @tc.require: I7TDJK
460 */
461 HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_004, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_004 begin";
464 ASSERT_NE(daemonExecute_, nullptr);
465 std::string srcUri;
466 std::string physicalPath;
467 std::string sessionName;
468 sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
469 ASSERT_TRUE(daemon != nullptr) << "daemon assert failed!";
470 HmdfsInfo info;
471 info.authority = FILE_MANAGER_AUTHORITY;
472
473 // Test case 4: CreateSessionServer succeeds, authority is media or docs, but Copy fails
474 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
475
476 EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_OK);
477 GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_004 end";
478 }
479
480 /**
481 * @tc.name: DaemonExecute_ExecutePrepareSession_001
482 * @tc.desc: Verify ExecutePrepareSession with null event does not throw
483 * @tc.type: FUNC
484 * @tc.require: I7TDJK
485 */
486 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_001, TestSize.Level1)
487 {
488 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_001 begin";
489 ASSERT_NE(daemonExecute_, nullptr);
490 // Test case 1: event is nullptr
491 AppExecFwk::InnerEvent::Pointer pointer2 = AppExecFwk::InnerEvent::Get(); // 获取空事件
492 EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(pointer2));
493
494 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_001 end";
495 }
496
497 /**
498 * @tc.name: DaemonExecute_ExecutePrepareSession_002
499 * @tc.desc: Verify ExecutePrepareSession with null prepareSessionData does not throw
500 * @tc.type: FUNC
501 * @tc.require: I7TDJK
502 */
503 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_002, TestSize.Level1)
504 {
505 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_002 begin";
506 ASSERT_NE(daemonExecute_, nullptr);
507 // Test case 2: prepareSessionData is nullptr
508 std::shared_ptr<PrepareSessionData> prepareSessionData = nullptr;
509 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
510 EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
511
512 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_002 end";
513 }
514
515 /**
516 * @tc.name: DaemonExecute_ExecutePrepareSession_003
517 * @tc.desc: Verify ExecutePrepareSession with null prepareSessionBlock does not throw
518 * @tc.type: FUNC
519 * @tc.require: I7TDJK
520 */
521 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_003, TestSize.Level1)
522 {
523 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_003 begin";
524
525 // Test case 3: prepareSessionBlock is nullptr
526 std::string srcUri = "";
527 std::string physicalPath = "";
528 std::string sessionName = "";
529 sptr<IDaemon> daemon = nullptr;
530 HmdfsInfo info;
531 std::shared_ptr<BlockObject<int32_t>> nullBlock = nullptr;
532
533 // // Initialize the PrepareSessionData
534 auto prepareSessionData =
535 std::make_shared<PrepareSessionData>(srcUri, physicalPath, sessionName, daemon, info, nullBlock);
536
537 // Initialize InnerEvent
538 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData);
539
540 ASSERT_NE(daemonExecute_, nullptr);
541 EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
542
543 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_003 end";
544 }
545
546 /**
547 * @tc.name: DaemonExecute_ExecutePrepareSession_004
548 * @tc.desc: Verify ExecutePrepareSession with valid parameters
549 * @tc.type: FUNC
550 * @tc.require: I7TDJK
551 */
552 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_004, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_004 begin";
555
556 // Test case 4: All parameters are valid
557 auto prepareSessionBlock = std::make_shared<BlockObject<int32_t>>(BLOCK_INTERVAL_SEND_FILE, ERR_BAD_VALUE);
558 sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
559 ASSERT_TRUE(daemon != nullptr) << "daemon assert failed!";
560 HmdfsInfo info;
561
562 // Initialize PrepareSessionData
563 auto prepareSessionData = std::make_shared<PrepareSessionData>("test_uri", "test_path", "test_session", daemon,
564 info, prepareSessionBlock);
565
566 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
567
568 // Mock PrepareSessionInner to return success
569 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
570
571 ASSERT_NE(daemonExecute_, nullptr);
572 EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
573 EXPECT_EQ(prepareSessionBlock->GetValue(), E_OK);
574
575 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_004 end";
576 }
577
578 /**
579 * @tc.name: DaemonExecute_ExecutePrepareSession_005
580 * @tc.desc: Verify ExecutePrepareSession with PrepareSessionInner failure
581 * @tc.type: FUNC
582 * @tc.require: I7TDJK
583 */
584 HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_005, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_005 begin";
587
588 // Test case 5: PrepareSessionInner returns failure
589 auto prepareSessionBlock = std::make_shared<BlockObject<int32_t>>(BLOCK_INTERVAL_SEND_FILE, ERR_BAD_VALUE);
590 sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
591 ASSERT_TRUE(daemon != nullptr) << "daemon assert failed!";
592 HmdfsInfo info;
593
594 // Initialize PrepareSessionData
595 auto prepareSessionData = std::make_shared<PrepareSessionData>("test_uri", "test_path", "test_session", daemon,
596 info, prepareSessionBlock);
597
598 auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
599
600 // Mock PrepareSessionInner to return failure
601 EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(-1));
602
603 ASSERT_NE(daemonExecute_, nullptr);
604 EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
605 EXPECT_EQ(prepareSessionBlock->GetValue(), E_SOFTBUS_SESSION_FAILED);
606
607 GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_005 end";
608 }
609 } // namespace OHOS::Storage::DistributedFile::Test