1 /*
2 * Copyright (c) 2023-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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "dfs_error.h"
20 #include "dfsu_access_token_helper.h"
21 #include "ipc/daemon_stub.h"
22 #include "ipc/hmdfs_info.h"
23 #include "ipc/distributed_file_daemon_ipc_interface_code.h"
24 #include "i_daemon_mock.h"
25 #include "utils_log.h"
26
27 namespace {
28 bool g_checkCallerPermissionTrue = true;
29 }
30 namespace OHOS::FileManagement {
CheckCallerPermission(const std::string & permissionName)31 bool DfsuAccessTokenHelper::CheckCallerPermission(const std::string &permissionName)
32 {
33 if (g_checkCallerPermissionTrue) {
34 return true;
35 }
36
37 return false;
38 }
39 }
40 namespace OHOS::Storage::DistributedFile::Test {
41 using namespace testing;
42 using namespace testing::ext;
43 using namespace std;
44 using namespace OHOS::FileManagement;
45
46 namespace {
47 DistributedHardware::DmDeviceInfo deviceInfo = {
48 .deviceId = "testdevid",
49 .deviceName = "testdevname",
50 .networkId = "testnetworkid",
51 };
52 }
53
54 const std::string SRC_URI = "file://docs/storage/Users/currentUser/""Documents?networkid=xxxxx";
55 const std::string DST_URI = "file://docs/storage/Users/currentUser/Documents";
56 const std::string SRC_DEVICE_ID = "testSrcDeviceId";
57 const sptr<IRemoteObject> LISTENER = sptr(new DaemonServiceMock());
58 const std::string COPY_PATH = "tmpDir";
59 const std::string sessionName = "DistributedDevice0";
60
61 HmdfsInfo fileInfo = {
62 .copyPath = COPY_PATH,
63 .dirExistFlag = false,
64 .sessionName = sessionName,
65 };
66
67 class MockDaemonStub : public DaemonStub {
68 public:
69 MOCK_METHOD1(OpenP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
70 MOCK_METHOD1(CloseP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
71 MOCK_METHOD2(OpenP2PConnectionEx, int32_t(const std::string &networkId, sptr<IFileDfsListener> remoteReverseObj));
72 MOCK_METHOD1(CloseP2PConnectionEx, int32_t(const std::string &networkId));
73 MOCK_METHOD4(RequestSendFile,
74 int32_t(const std::string &srcUri,
75 const std::string &dstPath,
76 const std::string &remoteDeviceId,
77 const std::string &sessionName));
78 MOCK_METHOD5(PrepareSession,
79 int32_t(const std::string &srcUri,
80 const std::string &dstUri,
81 const std::string &srcDeviceId,
82 const sptr<IRemoteObject> &listener,
83 HmdfsInfo &fileInfo));
84 MOCK_METHOD1(CancelCopyTask, int32_t(const std::string &sessionName));
85 MOCK_METHOD2(CancelCopyTask, int32_t(const std::string &srcUri, const std::string &dstUri));
86 MOCK_METHOD3(GetRemoteCopyInfo, int32_t(const std::string &srcUri, bool &isFile, bool &isDir));
87
88 MOCK_METHOD3(PushAsset,
89 int32_t(int32_t userId,
90 const sptr<AssetObj> &assetObj,
91 const sptr<IAssetSendCallback> &sendCallback));
92 MOCK_METHOD1(RegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
93 MOCK_METHOD1(UnRegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
94 MOCK_METHOD3(GetDfsUrisDirFromLocal, int32_t(const std::vector<std::string> &uriList,
95 const int32_t userId,
96 std::unordered_map<std::string,
97 AppFileService::ModuleRemoteFileShare::HmdfsUriInfo>
98 &uriToDfsUriMaps));
99 MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
100 MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
101 MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
102 };
103
104 class DaemonStubTest : public testing::Test {
105 public:
106 static void SetUpTestCase(void);
107 static void TearDownTestCase(void);
108 void SetUp();
109 void TearDown();
110 static inline std::shared_ptr<MockDaemonStub> daemonStub_;
111 };
112
SetUpTestCase(void)113 void DaemonStubTest::SetUpTestCase(void)
114 {
115 GTEST_LOG_(INFO) << "SetUpTestCase";
116 daemonStub_ = std::make_shared<MockDaemonStub>();
117 }
118
TearDownTestCase(void)119 void DaemonStubTest::TearDownTestCase(void)
120 {
121 GTEST_LOG_(INFO) << "TearDownTestCase";
122 daemonStub_ = nullptr;
123 }
124
SetUp(void)125 void DaemonStubTest::SetUp(void)
126 {
127 GTEST_LOG_(INFO) << "SetUp";
128 }
129
TearDown(void)130 void DaemonStubTest::TearDown(void)
131 {
132 GTEST_LOG_(INFO) << "TearDown";
133 }
134
135 /**
136 * @tc.name: DaemonStubOnRemoteRequestTest001
137 * @tc.desc: Verify the OnRemoteRequest function
138 * @tc.type: FUNC
139 * @tc.require: I7M6L1
140 */
141 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest001, TestSize.Level0)
142 {
143 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 Start";
144 try {
145 MessageParcel data;
146 MessageParcel reply;
147 MessageOption option;
148 int ret = daemonStub_->OnRemoteRequest(
149 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION), data,
150 reply, option);
151 EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
152 } catch (...) {
153 EXPECT_TRUE(false);
154 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 ERROR";
155 }
156 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 End";
157 }
158
159 /**
160 * @tc.name: DaemonStubOnRemoteRequestTest002
161 * @tc.desc: Verify the OnRemoteRequest function
162 * @tc.type: FUNC
163 * @tc.require: I7M6L1
164 */
165 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest002, TestSize.Level0)
166 {
167 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 Start";
168 try {
169 MessageParcel data;
170 MessageParcel reply;
171 MessageOption option;
172 int ret = daemonStub_->OnRemoteRequest(
173 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION), data,
174 reply, option);
175 EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
176 } catch (...) {
177 EXPECT_TRUE(false);
178 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 ERROR";
179 }
180 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 End";
181 }
182
183 /**
184 * @tc.name: DaemonStubOnRemoteRequestTest003
185 * @tc.desc: Verify the OnRemoteRequest function
186 * @tc.type: FUNC
187 * @tc.require: I7M6L1
188 */
189 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest003, TestSize.Level0)
190 {
191 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 Start";
192 try {
193 int32_t code = 1000;
194 MessageParcel data;
195 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
196 MessageParcel reply;
197 MessageOption option;
198 int ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
199 EXPECT_NE(ret, 0);
200 } catch (...) {
201 EXPECT_TRUE(false);
202 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 ERROR";
203 }
204 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 End";
205 }
206
207 /**
208 * @tc.name: DaemonStubOnRemoteRequestTest004
209 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
210 * @tc.type: FUNC
211 * @tc.require: I7M6L1
212 */
213 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest004, TestSize.Level0)
214 {
215 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 Start";
216 try {
217 MessageParcel data;
218 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
219 MessageParcel reply;
220 MessageOption option;
221
222 EXPECT_TRUE(data.WriteCString(deviceInfo.deviceId));
223 EXPECT_TRUE(data.WriteCString(deviceInfo.deviceName));
224 EXPECT_TRUE(data.WriteCString(deviceInfo.networkId));
225 g_checkCallerPermissionTrue = true;
226 EXPECT_CALL(*daemonStub_, OpenP2PConnection(_)).WillOnce(Return(0));
227 int ret = daemonStub_->OnRemoteRequest(
228 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION), data,
229 reply, option);
230 EXPECT_EQ(ret, 0);
231 } catch (...) {
232 EXPECT_TRUE(false);
233 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 ERROR";
234 }
235 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 End";
236 }
237
238 /**
239 * @tc.name: DaemonStubOnRemoteRequestTest005
240 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
241 * @tc.type: FUNC
242 * @tc.require: I7M6L1
243 */
244 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest005, TestSize.Level0)
245 {
246 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 Start";
247 try {
248 MessageParcel data;
249 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
250 MessageParcel reply;
251 MessageOption option;
252
253 EXPECT_TRUE(data.WriteCString(deviceInfo.deviceId));
254 EXPECT_TRUE(data.WriteCString(deviceInfo.deviceName));
255 EXPECT_TRUE(data.WriteCString(deviceInfo.networkId));
256 g_checkCallerPermissionTrue = true;
257 EXPECT_CALL(*daemonStub_, CloseP2PConnection(_)).WillOnce(Return(0));
258 int ret = daemonStub_->OnRemoteRequest(
259 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION), data,
260 reply, option);
261 EXPECT_EQ(ret, 0);
262 } catch (...) {
263 EXPECT_TRUE(false);
264 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 ERROR";
265 }
266 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 End";
267 }
268
269 /**
270 * @tc.name: DaemonStubOnRemoteRequestTest006
271 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
272 * @tc.type: FUNC
273 * @tc.require: I7M6L1
274 */
275 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest006, TestSize.Level0)
276 {
277 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 Start";
278 try {
279 MessageParcel data;
280 MessageParcel reply;
281 MessageOption option;
282
283 EXPECT_TRUE(data.WriteString(SRC_URI));
284 EXPECT_TRUE(data.WriteString(DST_URI));
285 EXPECT_TRUE(data.WriteString(SRC_DEVICE_ID));
286 EXPECT_TRUE(data.WriteRemoteObject(LISTENER));
287 EXPECT_TRUE(data.WriteString(COPY_PATH));
288 int ret = daemonStub_->OnRemoteRequest(
289 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_PREPARE_SESSION), data,
290 reply, option);
291 EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
292 } catch (...) {
293 EXPECT_TRUE(false);
294 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 ERROR";
295 }
296 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 End";
297 }
298
299 /**
300 * @tc.name: DaemonStubOnRemoteRequestTest007
301 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
302 * @tc.type: FUNC
303 * @tc.require: I7M6L1
304 */
305 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest007, TestSize.Level0)
306 {
307 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 Start";
308 try {
309 MessageParcel data;
310 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
311 MessageParcel reply;
312 MessageOption option;
313
314 int ret = daemonStub_->OnRemoteRequest(
315 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REQUEST_SEND_FILE), data,
316 reply, option);
317 EXPECT_EQ(ret, E_IPC_READ_FAILED);
318 } catch (...) {
319 EXPECT_TRUE(false);
320 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 ERROR";
321 }
322 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 End";
323 }
324
325 /**
326 * @tc.name: DaemonStubOnRemoteRequestTest008
327 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
328 * @tc.type: FUNC
329 * @tc.require: I7M6L1
330 */
331 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest008, TestSize.Level0)
332 {
333 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 Start";
334 try {
335 MessageParcel data;
336 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
337 MessageParcel reply;
338 MessageOption option;
339
340 int ret = daemonStub_->OnRemoteRequest(
341 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_REMOTE_COPY_INFO), data,
342 reply, option);
343 EXPECT_EQ(ret, E_IPC_READ_FAILED);
344 } catch (...) {
345 EXPECT_TRUE(false);
346 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 ERROR";
347 }
348 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 End";
349 }
350
351 /**
352 * @tc.name: DaemonStubOnRemoteRequestTest009
353 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
354 * @tc.type: FUNC
355 * @tc.require: I7M6L1
356 */
357 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest009, TestSize.Level0)
358 {
359 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 Start";
360 try {
361 MessageParcel data;
362 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
363 MessageParcel reply;
364 MessageOption option;
365
366 int ret = daemonStub_->OnRemoteRequest(
367 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CANCEL_COPY_TASK), data,
368 reply, option);
369 EXPECT_EQ(ret, E_IPC_READ_FAILED);
370 } catch (...) {
371 EXPECT_TRUE(false);
372 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 ERROR";
373 }
374 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 End";
375 }
376
377 /**
378 * @tc.name: DaemonStubOnRemoteRequestTest010
379 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
380 * @tc.type: FUNC
381 * @tc.require: I7M6L1
382 */
383 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest010, TestSize.Level0)
384 {
385 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 Start";
386 try {
387 MessageParcel data;
388 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
389 MessageParcel reply;
390 MessageOption option;
391
392 int ret = daemonStub_->OnRemoteRequest(
393 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION_EX), data,
394 reply, option);
395 EXPECT_EQ(ret, E_IPC_READ_FAILED);
396 } catch (...) {
397 EXPECT_TRUE(false);
398 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 ERROR";
399 }
400 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 End";
401 }
402
403 /**
404 * @tc.name: DaemonStubOnRemoteRequestTest011
405 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
406 * @tc.type: FUNC
407 * @tc.require: I7M6L1
408 */
409 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest011, TestSize.Level0)
410 {
411 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 Start";
412 try {
413 MessageParcel data;
414 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
415 MessageParcel reply;
416 MessageOption option;
417
418 int ret = daemonStub_->OnRemoteRequest(
419 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION_EX), data,
420 reply, option);
421 EXPECT_EQ(ret, E_IPC_READ_FAILED);
422 } catch (...) {
423 EXPECT_TRUE(false);
424 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 ERROR";
425 }
426 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 End";
427 }
428
429 /**
430 * @tc.name: DaemonStubOnRemoteRequestTest012
431 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
432 * @tc.type: FUNC
433 * @tc.require: I7M6L1
434 */
435 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest012, TestSize.Level0)
436 {
437 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 Start";
438 try {
439 MessageParcel data;
440 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
441 MessageParcel reply;
442 MessageOption option;
443
444 int ret = daemonStub_->OnRemoteRequest(
445 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REGISTER_ASSET_CALLBACK), data,
446 reply, option);
447 EXPECT_EQ(ret, E_PERMISSION_DENIED);
448 } catch (...) {
449 EXPECT_TRUE(false);
450 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 ERROR";
451 }
452 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 End";
453 }
454
455 /**
456 * @tc.name: DaemonStubOnRemoteRequestTest013
457 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
458 * @tc.type: FUNC
459 * @tc.require: I7M6L1
460 */
461 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest013, TestSize.Level0)
462 {
463 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 Start";
464 try {
465 MessageParcel data;
466 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
467 MessageParcel reply;
468 MessageOption option;
469
470 int ret = daemonStub_->OnRemoteRequest(
471 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UN_REGISTER_ASSET_CALLBACK),
472 data, reply, option);
473 EXPECT_EQ(ret, E_PERMISSION_DENIED);
474 } catch (...) {
475 EXPECT_TRUE(false);
476 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 ERROR";
477 }
478 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 End";
479 }
480
481 /**
482 * @tc.name: DaemonStubOnRemoteRequestTest011
483 * @tc.desc: Verify the DaemonStubOnRemoteRequest function
484 * @tc.type: FUNC
485 * @tc.require: I7M6L1
486 */
487 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest014, TestSize.Level0)
488 {
489 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 Start";
490 try {
491 MessageParcel data;
492 EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
493 MessageParcel reply;
494 MessageOption option;
495
496 int ret = daemonStub_->OnRemoteRequest(
497 static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_PUSH_ASSET), data,
498 reply, option);
499 EXPECT_EQ(ret, E_PERMISSION_DENIED);
500 } catch (...) {
501 EXPECT_TRUE(false);
502 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 ERROR";
503 }
504 GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 End";
505 }
506 } // namespace OHOS::Storage::DistributedFile::Test