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 "asset_recv_callback_proxy.h"
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "asset_obj.h"
21 #include "asset_recv_callback_mock.h"
22 #include "dfs_error.h"
23 #include "message_parcel_mock.h"
24
25 namespace OHOS::Storage::DistributedFile::Test {
26 using namespace OHOS::FileManagement;
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace std;
30
31 class AssetRecvCallbackProxyTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 public:
38 static inline shared_ptr<AssetRecvCallbackProxy> proxy_ = nullptr;
39 static inline sptr<IAssetRecvCallbackMock> mock_ = nullptr;
40 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
41 };
42
SetUpTestCase(void)43 void AssetRecvCallbackProxyTest::SetUpTestCase(void)
44 {
45 GTEST_LOG_(INFO) << "SetUpTestCase";
46 mock_ = sptr(new IAssetRecvCallbackMock());
47 proxy_ = make_shared<AssetRecvCallbackProxy>(mock_);
48 messageParcelMock_ = make_shared<MessageParcelMock>();
49 MessageParcelMock::messageParcel = messageParcelMock_;
50 }
51
TearDownTestCase(void)52 void AssetRecvCallbackProxyTest::TearDownTestCase(void)
53 {
54 GTEST_LOG_(INFO) << "TearDownTestCase";
55 mock_ = nullptr;
56 proxy_ = nullptr;
57 MessageParcelMock::messageParcel = nullptr;
58 messageParcelMock_ = nullptr;
59 }
60
SetUp(void)61 void AssetRecvCallbackProxyTest::SetUp(void)
62 {
63 GTEST_LOG_(INFO) << "SetUp";
64 }
65
TearDown(void)66 void AssetRecvCallbackProxyTest::TearDown(void)
67 {
68 GTEST_LOG_(INFO) << "TearDown";
69 }
70
71 /**
72 * @tc.name: AssetRecvCallbackProxy_OnStart_0100
73 * @tc.desc: The execution of the OnStart failed.
74 * @tc.type: FUNC
75 * @tc.require: I7TDJK
76 */
77 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0100, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0100 Start";
80 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
81 ASSERT_NE(proxy_, nullptr);
82 auto ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
83 EXPECT_EQ(ret, E_BROKEN_IPC);
84
85 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
86 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
87 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
88 EXPECT_EQ(ret, E_INVAL_ARG);
89
90 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
91 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
92 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
93 EXPECT_EQ(ret, E_INVAL_ARG);
94
95 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
96 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
97 .WillOnce(Return(false));
98 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
99 EXPECT_EQ(ret, E_INVAL_ARG);
100
101 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
102 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
103 .WillOnce(Return(true)).WillOnce(Return(false));
104 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
105 EXPECT_EQ(ret, E_INVAL_ARG);
106 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0100 End";
107 }
108
109 /**
110 * @tc.name: AssetRecvCallbackProxy_OnStart_0200
111 * @tc.desc: The execution of the OnStart failed.
112 * @tc.type: FUNC
113 * @tc.require: I7TDJK
114 */
115 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0200, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0200 Start";
118 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
119 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
120 .WillOnce(Return(true)).WillOnce(Return(true));
121 auto testProxy = make_shared<AssetRecvCallbackProxy>(nullptr);
122 ASSERT_NE(testProxy, nullptr);
123 auto ret = testProxy->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
124 EXPECT_EQ(ret, E_BROKEN_IPC);
125
126 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
127 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
128 .WillOnce(Return(true)).WillOnce(Return(true));
129 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
130 ASSERT_NE(proxy_, nullptr);
131 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
132 EXPECT_EQ(ret, E_BROKEN_IPC);
133 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0200 End";
134 }
135
136 /**
137 * @tc.name: AssetRecvCallbackProxy_OnStart_0300
138 * @tc.desc: The execution of the OnStart success.
139 * @tc.type: FUNC
140 * @tc.require: I7TDJK
141 */
142 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0300, TestSize.Level1)
143 {
144 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0300 Start";
145 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
146 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
147 .WillOnce(Return(true)).WillOnce(Return(true));
148 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
149 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
150 ASSERT_NE(proxy_, nullptr);
151 auto ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
152 EXPECT_EQ(ret, E_OK);
153 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0300 End";
154 }
155
156 /**
157 * @tc.name: AssetRecvCallbackProxy_OnRecvProgress_0100
158 * @tc.desc: The execution of the OnRecvProgress failed.
159 * @tc.type: FUNC
160 * @tc.require: I7TDJK
161 */
162 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnRecvProgress_0100, TestSize.Level1)
163 {
164 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0100 Start";
165
166 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
167 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
168 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
169 ASSERT_NE(proxy_, nullptr);
170 auto ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
171 EXPECT_EQ(ret, E_BROKEN_IPC);
172
173 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
174 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
175 ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
176 EXPECT_EQ(ret, E_INVAL_ARG);
177
178 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
179 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
180 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(false));
181 ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
182 EXPECT_EQ(ret, E_INVAL_ARG);
183
184 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
185 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
186 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
187 EXPECT_CALL(*messageParcelMock_, WriteUint64(_)).WillOnce(Return(false));
188 ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
189 EXPECT_EQ(ret, E_INVAL_ARG);
190
191 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
192 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
193 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
194 EXPECT_CALL(*messageParcelMock_, WriteUint64(_)).Times(2)
195 .WillOnce(Return(true))
196 .WillOnce(Return(false));
197 ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
198 EXPECT_EQ(ret, E_INVAL_ARG);
199
200 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0100 End";
201 }
202
203 /**
204 * @tc.name: AssetRecvCallbackProxy_OnRecvProgress_0200
205 * @tc.desc: The execution of the OnRecvProgress failed.
206 * @tc.type: FUNC
207 * @tc.require: I7TDJK
208 */
209 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnRecvProgress_0200, TestSize.Level1)
210 {
211 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0200 Start";
212
213 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
214 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
215 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
216 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
217 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
218 EXPECT_CALL(*messageParcelMock_, WriteUint64(_)).Times(2)
219 .WillRepeatedly(Return(true));
220 auto testProxy = make_shared<AssetRecvCallbackProxy>(nullptr);
221 ASSERT_NE(testProxy, nullptr);
222 auto ret = testProxy->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
223 EXPECT_EQ(ret, E_BROKEN_IPC);
224
225 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
226 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
227 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
228 EXPECT_CALL(*messageParcelMock_, WriteUint64(_)).Times(2)
229 .WillRepeatedly(Return(true));
230 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
231 ASSERT_NE(proxy_, nullptr);
232 ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
233 EXPECT_EQ(ret, E_BROKEN_IPC);
234
235 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0200 End";
236 }
237
238 /**
239 * @tc.name: AssetRecvCallbackProxy_OnRecvProgress_0300
240 * @tc.desc: The execution of the OnRecvProgress success.
241 * @tc.type: FUNC
242 * @tc.require: I7TDJK
243 */
244 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnRecvProgress_0300, TestSize.Level1)
245 {
246 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0300 Start";
247 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
248 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
249 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
250 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
251 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
252 EXPECT_CALL(*messageParcelMock_, WriteUint64(_)).Times(2)
253 .WillRepeatedly(Return(true));
254 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
255 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
256 ASSERT_NE(proxy_, nullptr);
257 auto ret = proxy_->OnRecvProgress("srcNetworkId", assetObj, 1024, 256);
258 EXPECT_EQ(ret, E_OK);
259 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnRecvProgress_0300 End";
260 }
261
262 /**
263 * @tc.name: AssetRecvCallbackProxy_OnFinished_0100
264 * @tc.desc: The execution of the OnFinished failed.
265 * @tc.type: FUNC
266 * @tc.require: I7TDJK
267 */
268 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0100, TestSize.Level1)
269 {
270 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0100 Start";
271 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
272 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
273 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
274 ASSERT_NE(proxy_, nullptr);
275 auto ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
276 EXPECT_EQ(ret, E_BROKEN_IPC);
277
278 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
279 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
280 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
281 EXPECT_EQ(ret, E_INVAL_ARG);
282
283 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
284 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
285 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(false));
286 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
287 EXPECT_EQ(ret, E_INVAL_ARG);
288
289 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
290 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
291 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
292 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
293 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
294 EXPECT_EQ(ret, E_INVAL_ARG);
295 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0100 End";
296 }
297
298 /**
299 * @tc.name: AssetRecvCallbackProxy_OnFinished_0200
300 * @tc.desc: The execution of the OnFinished failed.
301 * @tc.type: FUNC
302 * @tc.require: I7TDJK
303 */
304 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0200, TestSize.Level1)
305 {
306 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0200 Start";
307 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
308 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
309 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
310 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
311 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
312 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
313 auto testProxy = make_shared<AssetRecvCallbackProxy>(nullptr);
314 ASSERT_NE(testProxy, nullptr);
315 auto ret = testProxy->OnFinished("srcNetworkId", assetObj, 0);
316 EXPECT_EQ(ret, E_BROKEN_IPC);
317
318 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
319 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
320 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
321 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
322 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
323 ASSERT_NE(proxy_, nullptr);
324 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
325 EXPECT_EQ(ret, E_BROKEN_IPC);
326 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0200 End";
327 }
328
329 /**
330 * @tc.name: AssetRecvCallbackProxy_OnFinished_0300
331 * @tc.desc: The execution of the OnFinished success.
332 * @tc.type: FUNC
333 * @tc.require: I7TDJK
334 */
335 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0300, TestSize.Level1)
336 {
337 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0300 Start";
338 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
339 ASSERT_TRUE(assetObj != nullptr) << "assetObj assert failed!";
340 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
341 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
342 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
343 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
344 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
345 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
346 ASSERT_NE(proxy_, nullptr);
347 auto ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
348 EXPECT_EQ(ret, E_OK);
349 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0300 End";
350 }
351 }