1 /*
2  * Copyright (c) 2023 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_METHOD3(GetRemoteCopyInfo, int32_t(const std::string &srcUri, bool &isFile, bool &isDir));
86 
87     MOCK_METHOD3(PushAsset,
88                  int32_t(int32_t userId,
89                          const sptr<AssetObj> &assetObj,
90                          const sptr<IAssetSendCallback> &sendCallback));
91     MOCK_METHOD1(RegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
92     MOCK_METHOD1(UnRegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
93 };
94 
95 class DaemonStubTest : public testing::Test {
96 public:
97     static void SetUpTestCase(void);
98     static void TearDownTestCase(void);
99     void SetUp();
100     void TearDown();
101     static inline std::shared_ptr<MockDaemonStub> daemonStub_;
102 };
103 
SetUpTestCase(void)104 void DaemonStubTest::SetUpTestCase(void)
105 {
106     GTEST_LOG_(INFO) << "SetUpTestCase";
107     daemonStub_ = std::make_shared<MockDaemonStub>();
108 }
109 
TearDownTestCase(void)110 void DaemonStubTest::TearDownTestCase(void)
111 {
112     GTEST_LOG_(INFO) << "TearDownTestCase";
113     daemonStub_ = nullptr;
114 }
115 
SetUp(void)116 void DaemonStubTest::SetUp(void)
117 {
118     GTEST_LOG_(INFO) << "SetUp";
119 }
120 
TearDown(void)121 void DaemonStubTest::TearDown(void)
122 {
123     GTEST_LOG_(INFO) << "TearDown";
124 }
125 
126 /**
127  * @tc.name: DaemonStubOnRemoteRequestTest001
128  * @tc.desc: Verify the OnRemoteRequest function
129  * @tc.type: FUNC
130  * @tc.require: I7M6L1
131  */
132 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest001, TestSize.Level1)
133 {
134     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 Start";
135     try {
136         MessageParcel data;
137         MessageParcel reply;
138         MessageOption option;
139         int ret = daemonStub_->OnRemoteRequest(
140             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION), data,
141             reply, option);
142         EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
143     } catch (...) {
144         EXPECT_TRUE(false);
145         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 ERROR";
146     }
147     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest001 End";
148 }
149 
150 /**
151  * @tc.name: DaemonStubOnRemoteRequestTest002
152  * @tc.desc: Verify the OnRemoteRequest function
153  * @tc.type: FUNC
154  * @tc.require: I7M6L1
155  */
156 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest002, TestSize.Level1)
157 {
158     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 Start";
159     try {
160         MessageParcel data;
161         MessageParcel reply;
162         MessageOption option;
163         int ret = daemonStub_->OnRemoteRequest(
164             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION), data,
165             reply, option);
166         EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
167     } catch (...) {
168         EXPECT_TRUE(false);
169         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 ERROR";
170     }
171     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest002 End";
172 }
173 
174 /**
175  * @tc.name: DaemonStubOnRemoteRequestTest003
176  * @tc.desc: Verify the OnRemoteRequest function
177  * @tc.type: FUNC
178  * @tc.require: I7M6L1
179  */
180 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest003, TestSize.Level1)
181 {
182     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 Start";
183     try {
184         int32_t code = 1000;
185         MessageParcel data;
186         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
187         MessageParcel reply;
188         MessageOption option;
189         int ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
190         EXPECT_NE(ret, 0);
191     } catch (...) {
192         EXPECT_TRUE(false);
193         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 ERROR";
194     }
195     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest003 End";
196 }
197 
198 /**
199  * @tc.name: DaemonStubOnRemoteRequestTest004
200  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
201  * @tc.type: FUNC
202  * @tc.require: I7M6L1
203  */
204 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest004, TestSize.Level1)
205 {
206     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 Start";
207     try {
208         MessageParcel data;
209         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
210         MessageParcel reply;
211         MessageOption option;
212 
213         EXPECT_TRUE(data.WriteCString(deviceInfo.deviceId));
214         EXPECT_TRUE(data.WriteCString(deviceInfo.deviceName));
215         EXPECT_TRUE(data.WriteCString(deviceInfo.networkId));
216         g_checkCallerPermissionTrue = true;
217         EXPECT_CALL(*daemonStub_, OpenP2PConnection(_)).WillOnce(Return(0));
218         int ret = daemonStub_->OnRemoteRequest(
219             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION), data,
220             reply, option);
221         EXPECT_EQ(ret, 0);
222     } catch (...) {
223         EXPECT_TRUE(false);
224         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 ERROR";
225     }
226     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest004 End";
227 }
228 
229 /**
230  * @tc.name: DaemonStubOnRemoteRequestTest005
231  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
232  * @tc.type: FUNC
233  * @tc.require: I7M6L1
234  */
235 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest005, TestSize.Level1)
236 {
237     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 Start";
238     try {
239         MessageParcel data;
240         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
241         MessageParcel reply;
242         MessageOption option;
243 
244         EXPECT_TRUE(data.WriteCString(deviceInfo.deviceId));
245         EXPECT_TRUE(data.WriteCString(deviceInfo.deviceName));
246         EXPECT_TRUE(data.WriteCString(deviceInfo.networkId));
247         g_checkCallerPermissionTrue = true;
248         EXPECT_CALL(*daemonStub_, CloseP2PConnection(_)).WillOnce(Return(0));
249         int ret = daemonStub_->OnRemoteRequest(
250             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION), data,
251             reply, option);
252         EXPECT_EQ(ret, 0);
253     } catch (...) {
254         EXPECT_TRUE(false);
255         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 ERROR";
256     }
257     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest005 End";
258 }
259 
260 /**
261  * @tc.name: DaemonStubOnRemoteRequestTest006
262  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
263  * @tc.type: FUNC
264  * @tc.require: I7M6L1
265  */
266 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest006, TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 Start";
269     try {
270         MessageParcel data;
271         MessageParcel reply;
272         MessageOption option;
273 
274         EXPECT_TRUE(data.WriteString(SRC_URI));
275         EXPECT_TRUE(data.WriteString(DST_URI));
276         EXPECT_TRUE(data.WriteString(SRC_DEVICE_ID));
277         EXPECT_TRUE(data.WriteRemoteObject(LISTENER));
278         EXPECT_TRUE(data.WriteString(COPY_PATH));
279         int ret = daemonStub_->OnRemoteRequest(
280             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_PREPARE_SESSION), data,
281             reply, option);
282         EXPECT_EQ(ret, IDaemon::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
283     } catch (...) {
284         EXPECT_TRUE(false);
285         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 ERROR";
286     }
287     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest006 End";
288 }
289 
290 /**
291  * @tc.name: DaemonStubOnRemoteRequestTest007
292  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
293  * @tc.type: FUNC
294  * @tc.require: I7M6L1
295  */
296 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest007, TestSize.Level1)
297 {
298     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 Start";
299     try {
300         MessageParcel data;
301         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
302         MessageParcel reply;
303         MessageOption option;
304 
305         int ret = daemonStub_->OnRemoteRequest(
306             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REQUEST_SEND_FILE), data,
307             reply, option);
308         EXPECT_EQ(ret, E_PERMISSION_DENIED);
309     } catch (...) {
310         EXPECT_TRUE(false);
311         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 ERROR";
312     }
313     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest007 End";
314 }
315 
316 /**
317  * @tc.name: DaemonStubOnRemoteRequestTest008
318  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
319  * @tc.type: FUNC
320  * @tc.require: I7M6L1
321  */
322 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest008, TestSize.Level1)
323 {
324     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 Start";
325     try {
326         MessageParcel data;
327         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
328         MessageParcel reply;
329         MessageOption option;
330 
331         int ret = daemonStub_->OnRemoteRequest(
332             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_REMOTE_COPY_INFO), data,
333             reply, option);
334         EXPECT_EQ(ret, E_PERMISSION_DENIED);
335     } catch (...) {
336         EXPECT_TRUE(false);
337         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 ERROR";
338     }
339     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest008 End";
340 }
341 
342 /**
343  * @tc.name: DaemonStubOnRemoteRequestTest009
344  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
345  * @tc.type: FUNC
346  * @tc.require: I7M6L1
347  */
348 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest009, TestSize.Level1)
349 {
350     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 Start";
351     try {
352         MessageParcel data;
353         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
354         MessageParcel reply;
355         MessageOption option;
356 
357         int ret = daemonStub_->OnRemoteRequest(
358             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CANCEL_COPY_TASK), data,
359             reply, option);
360         EXPECT_EQ(ret, E_IPC_READ_FAILED);
361     } catch (...) {
362         EXPECT_TRUE(false);
363         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 ERROR";
364     }
365     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest009 End";
366 }
367 
368 /**
369  * @tc.name: DaemonStubOnRemoteRequestTest010
370  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
371  * @tc.type: FUNC
372  * @tc.require: I7M6L1
373  */
374 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest010, TestSize.Level1)
375 {
376     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 Start";
377     try {
378         MessageParcel data;
379         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
380         MessageParcel reply;
381         MessageOption option;
382 
383         int ret = daemonStub_->OnRemoteRequest(
384             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION_EX), data,
385             reply, option);
386         EXPECT_EQ(ret, E_IPC_READ_FAILED);
387     } catch (...) {
388         EXPECT_TRUE(false);
389         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 ERROR";
390     }
391     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest010 End";
392 }
393 
394 /**
395  * @tc.name: DaemonStubOnRemoteRequestTest011
396  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
397  * @tc.type: FUNC
398  * @tc.require: I7M6L1
399  */
400 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest011, TestSize.Level1)
401 {
402     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 Start";
403     try {
404         MessageParcel data;
405         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
406         MessageParcel reply;
407         MessageOption option;
408 
409         int ret = daemonStub_->OnRemoteRequest(
410             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_CLOSE_P2P_CONNECTION_EX), data,
411             reply, option);
412         EXPECT_EQ(ret, E_IPC_READ_FAILED);
413     } catch (...) {
414         EXPECT_TRUE(false);
415         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 ERROR";
416     }
417     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest011 End";
418 }
419 
420 /**
421  * @tc.name: DaemonStubOnRemoteRequestTest012
422  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
423  * @tc.type: FUNC
424  * @tc.require: I7M6L1
425  */
426 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest012, TestSize.Level1)
427 {
428     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 Start";
429     try {
430         MessageParcel data;
431         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
432         MessageParcel reply;
433         MessageOption option;
434 
435         int ret = daemonStub_->OnRemoteRequest(
436             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REGISTER_ASSET_CALLBACK), data,
437             reply, option);
438         EXPECT_EQ(ret, E_PERMISSION_DENIED);
439     } catch (...) {
440         EXPECT_TRUE(false);
441         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 ERROR";
442     }
443     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest012 End";
444 }
445 
446 /**
447  * @tc.name: DaemonStubOnRemoteRequestTest013
448  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
449  * @tc.type: FUNC
450  * @tc.require: I7M6L1
451  */
452 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest013, TestSize.Level1)
453 {
454     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 Start";
455     try {
456         MessageParcel data;
457         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
458         MessageParcel reply;
459         MessageOption option;
460 
461         int ret = daemonStub_->OnRemoteRequest(
462             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UN_REGISTER_ASSET_CALLBACK),
463             data, reply, option);
464         EXPECT_EQ(ret, E_PERMISSION_DENIED);
465     } catch (...) {
466         EXPECT_TRUE(false);
467         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 ERROR";
468     }
469     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest013 End";
470 }
471 
472 /**
473  * @tc.name: DaemonStubOnRemoteRequestTest011
474  * @tc.desc: Verify the DaemonStubOnRemoteRequest function
475  * @tc.type: FUNC
476  * @tc.require: I7M6L1
477  */
478 HWTEST_F(DaemonStubTest, DaemonStubOnRemoteRequestTest014, TestSize.Level1)
479 {
480     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 Start";
481     try {
482         MessageParcel data;
483         EXPECT_TRUE(data.WriteInterfaceToken(IDaemon::GetDescriptor()));
484         MessageParcel reply;
485         MessageOption option;
486 
487         int ret = daemonStub_->OnRemoteRequest(
488             static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_PUSH_ASSET), data,
489             reply, option);
490         EXPECT_EQ(ret, E_PERMISSION_DENIED);
491     } catch (...) {
492         EXPECT_TRUE(false);
493         GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 ERROR";
494     }
495     GTEST_LOG_(INFO) << "DaemonStubOnRemoteRequestTest014 End";
496 }
497 } // namespace OHOS::Storage::DistributedFile::Test