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 <fcntl.h>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <sys/stat.h>
20
21 #include "asset_recv_callback_mock.h"
22 #include "asset_send_callback_mock.h"
23 #include "dfs_error.h"
24 #include "distributed_file_daemon_manager_impl.h"
25 #include "distributed_file_daemon_proxy.h"
26 #include "ipc/hmdfs_info.h"
27 #include "i_daemon_mock.h"
28 #include "file_dfs_listener_mock.h"
29 #include "utils_log.h"
30
31 namespace OHOS::Storage::DistributedFile {
GetInstance()32 sptr<IDaemon> DistributedFileDaemonProxy::GetInstance()
33 {
34 daemonProxy_ = iface_cast<IDaemon>(sptr(new DaemonServiceMock()));
35 return daemonProxy_;
36 }
37 namespace Test {
38 using namespace OHOS::FileManagement;
39 using namespace testing;
40 using namespace testing::ext;
41 using namespace std;
42
43 namespace {
44 DistributedHardware::DmDeviceInfo deviceInfo = {
45 .deviceId = "testdevid",
46 .deviceName = "testdevname",
47 .networkId = "testnetworkid",
48 };
49 }
50
51 class DistributedDaemonManagerImplTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 std::shared_ptr<DistributedFileDaemonManagerImpl> distributedDaemonManagerImpl_;
58 };
59
SetUpTestCase(void)60 void DistributedDaemonManagerImplTest::SetUpTestCase(void)
61 {
62 GTEST_LOG_(INFO) << "SetUpTestCase";
63 }
64
TearDownTestCase(void)65 void DistributedDaemonManagerImplTest::TearDownTestCase(void)
66 {
67 GTEST_LOG_(INFO) << "TearDownTestCase";
68 }
69
SetUp(void)70 void DistributedDaemonManagerImplTest::SetUp(void)
71 {
72 if (distributedDaemonManagerImpl_ == nullptr) {
73 distributedDaemonManagerImpl_ = std::make_shared<DistributedFileDaemonManagerImpl>();
74 ASSERT_TRUE(distributedDaemonManagerImpl_ != nullptr) << "CallbackManager failed";
75 }
76 GTEST_LOG_(INFO) << "SetUp";
77 }
78
TearDown(void)79 void DistributedDaemonManagerImplTest::TearDown(void)
80 {
81 GTEST_LOG_(INFO) << "TearDown";
82 }
83
84 /**
85 * @tc.name: GetInstanceTest
86 * @tc.desc: Verify the GetInstance function
87 * @tc.type: FUNC
88 * @tc.require: I7M6L1
89 */
90 HWTEST_F(DistributedDaemonManagerImplTest, GetInstanceTest, TestSize.Level1)
91 {
92 GTEST_LOG_(INFO) << "GetInstanceTest Start";
93 try {
94 DistributedFileDaemonManagerImpl::GetInstance();
95 EXPECT_TRUE(true);
96 } catch (...) {
97 EXPECT_TRUE(false);
98 GTEST_LOG_(INFO) << "GetInstanceTest ERROR";
99 }
100 GTEST_LOG_(INFO) << "GetInstanceTest End";
101 }
102
103 /**
104 * @tc.name: OpenP2PConnectionTest
105 * @tc.desc: Verify the OpenP2PConnection function
106 * @tc.type: FUNC
107 * @tc.require: I7M6L1
108 */
109 HWTEST_F(DistributedDaemonManagerImplTest, OpenP2PConnectionTest, TestSize.Level1)
110 {
111 GTEST_LOG_(INFO) << "OpenP2PConnectionTest Start";
112 try {
113 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
114 EXPECT_NE(distributedFileDaemonProxy, nullptr);
115 auto res = distributedDaemonManagerImpl_->OpenP2PConnection(deviceInfo);
116 EXPECT_NE(res, E_SA_LOAD_FAILED);
117 } catch (...) {
118 EXPECT_TRUE(false);
119 GTEST_LOG_(INFO) << "OpenP2PConnectionTest ERROR";
120 }
121 GTEST_LOG_(INFO) << "OpenP2PConnectionTest End";
122 }
123
124 /**
125 * @tc.name: CloseP2PConnectionTest
126 * @tc.desc: Verify the CloseP2PConnection function
127 * @tc.type: FUNC
128 * @tc.require: I7M6L1
129 */
130 HWTEST_F(DistributedDaemonManagerImplTest, CloseP2PConnectionTest, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "CloseP2PConnectionTest Start";
133 try {
134 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
135 EXPECT_NE(distributedFileDaemonProxy, nullptr);
136 auto res = distributedDaemonManagerImpl_->CloseP2PConnection(deviceInfo);
137 EXPECT_NE(res, E_SA_LOAD_FAILED);
138 } catch (...) {
139 EXPECT_TRUE(false);
140 GTEST_LOG_(INFO) << "CloseP2PConnectionTest ERROR";
141 }
142 GTEST_LOG_(INFO) << "CloseP2PConnectionTest End";
143 }
144
145 /**
146 * @tc.name: OpenP2PConnectionExTest
147 * @tc.desc: Verify the OpenP2PConnectionEx function
148 * @tc.type: FUNC
149 * @tc.require: I7M6L1
150 */
151 HWTEST_F(DistributedDaemonManagerImplTest, OpenP2PConnectionExTest, TestSize.Level1)
152 {
153 auto remoteReverseObj = sptr(new FileDfsListenerMock());
154 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest Start";
155 try {
156 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
157 EXPECT_NE(distributedFileDaemonProxy, nullptr);
158 auto res = distributedDaemonManagerImpl_->OpenP2PConnectionEx("test", remoteReverseObj);
159 EXPECT_NE(res, E_SA_LOAD_FAILED);
160 } catch (...) {
161 EXPECT_TRUE(false);
162 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest ERROR";
163 }
164 GTEST_LOG_(INFO) << "OpenP2PConnectionExTest End";
165 }
166
167 /**
168 * @tc.name: CloseP2PConnectionEx
169 * @tc.desc: Verify the CloseP2PConnectionEx function
170 * @tc.type: FUNC
171 * @tc.require: I7M6L1
172 */
173 HWTEST_F(DistributedDaemonManagerImplTest, CloseP2PConnectionExTest, TestSize.Level1)
174 {
175 GTEST_LOG_(INFO) << "CloseP2PConnectionEx Start";
176 try {
177 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
178 EXPECT_NE(distributedFileDaemonProxy, nullptr);
179 auto res = distributedDaemonManagerImpl_->CloseP2PConnectionEx("test");
180 EXPECT_NE(res, E_SA_LOAD_FAILED);
181 } catch (...) {
182 EXPECT_TRUE(false);
183 GTEST_LOG_(INFO) << "CloseP2PConnectionEx ERROR";
184 }
185 GTEST_LOG_(INFO) << "CloseP2PConnectionEx End";
186 }
187
188 /**
189 * @tc.name: PrepareSessionTest
190 * @tc.desc: Verify the PrepareSession function
191 * @tc.type: FUNC
192 * @tc.require: I7M6L1
193 */
194 HWTEST_F(DistributedDaemonManagerImplTest, PrepareSessionTest, TestSize.Level1)
195 {
196 const std::string srcUri = "file://docs/storage/Users/currentUser/Documents?networkId=xxxxx";
197 const std::string dstUri = "file://docs/storage/Users/currentUser/Documents";
198 const std::string srcDeviceId = "testSrcDeviceId";
199 const sptr<IRemoteObject> listener = sptr(new DaemonServiceMock());
200 const std::string copyPath = "tmpDir";
201 const std::string sessionName = "DistributedDevice0";
202 HmdfsInfo fileInfo = {
203 .copyPath = copyPath,
204 .dirExistFlag = false,
205 .sessionName = sessionName,
206 };
207 GTEST_LOG_(INFO) << "PrepareSessionTest Start";
208 try {
209 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
210 EXPECT_NE(distributedFileDaemonProxy, nullptr);
211 auto res = distributedDaemonManagerImpl_->PrepareSession(srcUri, dstUri, srcDeviceId, listener, fileInfo);
212 EXPECT_NE(res, E_SA_LOAD_FAILED);
213 } catch (...) {
214 EXPECT_TRUE(false);
215 GTEST_LOG_(INFO) << "PrepareSessionTest ERROR";
216 }
217 GTEST_LOG_(INFO) << "PrepareSessionTest End";
218 }
219
220 /**
221 * @tc.name: RequestSendFileTest
222 * @tc.desc: Verify the RequestSendFile function
223 * @tc.type: FUNC
224 * @tc.require: I7M6L1
225 */
226 HWTEST_F(DistributedDaemonManagerImplTest, RequestSendFileTest, TestSize.Level1)
227 {
228 GTEST_LOG_(INFO) << "RequestSendFileTest Start";
229 try {
230 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
231 EXPECT_NE(distributedFileDaemonProxy, nullptr);
232 auto res = distributedDaemonManagerImpl_->RequestSendFile("uri", "path", "deviceId", "test");
233 EXPECT_NE(res, E_SA_LOAD_FAILED);
234 } catch (...) {
235 EXPECT_TRUE(false);
236 GTEST_LOG_(INFO) << "RequestSendFileTest ERROR";
237 }
238 GTEST_LOG_(INFO) << "RequestSendFileTest End";
239 }
240
241 /**
242 * @tc.name: GetRemoteCopyInfoTest
243 * @tc.desc: Verify the GetRemoteCopyInfo function
244 * @tc.type: FUNC
245 * @tc.require: I7M6L1
246 */
247 HWTEST_F(DistributedDaemonManagerImplTest, GetRemoteCopyInfoTest, TestSize.Level1)
248 {
249 bool isFile = false;
250 bool isDir = false;
251 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest Start";
252 try {
253 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
254 EXPECT_NE(distributedFileDaemonProxy, nullptr);
255 auto res = distributedDaemonManagerImpl_->GetRemoteCopyInfo("test", isFile, isDir);
256 EXPECT_NE(res, E_SA_LOAD_FAILED);
257 } catch (...) {
258 EXPECT_TRUE(false);
259 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest ERROR";
260 }
261 GTEST_LOG_(INFO) << "GetRemoteCopyInfoTest End";
262 }
263
264 /**
265 * @tc.name: PushAssetTest
266 * @tc.desc: Verify the PushAsset function
267 * @tc.type: FUNC
268 * @tc.require: I7M6L1
269 */
270 HWTEST_F(DistributedDaemonManagerImplTest, PushAssetTest, TestSize.Level1)
271 {
272 sptr<AssetObj> assetObj = nullptr;
273 int32_t userId = 800;
274 GTEST_LOG_(INFO) << "PushAssetTest Start";
275 try {
276 sptr<IAssetSendCallbackMock> errPtr = nullptr;
277 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
278 EXPECT_NE(distributedFileDaemonProxy, nullptr);
279 auto res = distributedDaemonManagerImpl_->PushAsset(userId, assetObj, nullptr);
280 EXPECT_NE(res, E_SA_LOAD_FAILED);
281 } catch (...) {
282 EXPECT_TRUE(false);
283 GTEST_LOG_(INFO) << "PushAssetTest ERROR";
284 }
285 GTEST_LOG_(INFO) << "PushAssetTest End";
286 }
287
288 /**
289 * @tc.name: RegisterAssetCallbackTest
290 * @tc.desc: Verify the RegisterAssetCallback function
291 * @tc.type: FUNC
292 * @tc.require: I7M6L1
293 */
294 HWTEST_F(DistributedDaemonManagerImplTest, RegisterAssetCallbackTest, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest Start";
297 try {
298 sptr<IAssetRecvCallbackMock> errPtr = nullptr;
299 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
300 EXPECT_NE(distributedFileDaemonProxy, nullptr);
301 auto res = distributedDaemonManagerImpl_->RegisterAssetCallback(errPtr);
302 EXPECT_EQ(res, E_NULLPTR);
303 auto callbackMock = sptr(new IAssetRecvCallbackMock());
304 res = distributedDaemonManagerImpl_->RegisterAssetCallback(callbackMock);
305 EXPECT_NE(res, E_SA_LOAD_FAILED);
306 } catch (...) {
307 EXPECT_TRUE(false);
308 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest ERROR";
309 }
310 GTEST_LOG_(INFO) << "RegisterAssetCallbackTest End";
311 }
312
313 /**
314 * @tc.name: UnRegisterAssetCallbackTest
315 * @tc.desc: Verify the UnRegisterAssetCallback function
316 * @tc.type: FUNC
317 * @tc.require: I7M6L1
318 */
319 HWTEST_F(DistributedDaemonManagerImplTest, UnRegisterAssetCallbackTest, TestSize.Level1)
320 {
321 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest Start";
322 try {
323 sptr<IAssetRecvCallbackMock> errPtr = nullptr;
324 auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
325 EXPECT_NE(distributedFileDaemonProxy, nullptr);
326 auto res = distributedDaemonManagerImpl_->UnRegisterAssetCallback(errPtr);
327 EXPECT_EQ(res, E_NULLPTR);
328
329 auto callbackMock = sptr(new IAssetRecvCallbackMock());
330 res = distributedDaemonManagerImpl_->UnRegisterAssetCallback(callbackMock);
331 EXPECT_NE(res, E_SA_LOAD_FAILED);
332 } catch (...) {
333 EXPECT_TRUE(false);
334 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest ERROR";
335 }
336 GTEST_LOG_(INFO) << "UnRegisterAssetCallbackTest End";
337 }
338 } // namespace Test
339 } // namespace OHOS::Storage::DistributedFile
340