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/asset_recv_callback_stub.h>
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "dfs_error.h"
21 #include "asset/asset_callback_interface_code.h"
22
23 namespace OHOS::Storage::DistributedFile::Test {
24 using namespace OHOS::FileManagement;
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace std;
28
29 class MockAssetRecvCallbackStubStub final : public AssetRecvCallbackStub {
30 public:
31 MOCK_METHOD4(OnStart, int32_t(const std::string &srcNetworkId,
32 const std::string &dstNetworkId,
33 const std::string &sessionId,
34 const std::string &dstBundleName));
35 MOCK_METHOD4(OnRecvProgress, int32_t(const std::string &srcNetworkId,
36 const sptr<AssetObj> &assetObj,
37 uint64_t totalBytes,
38 uint64_t processBytes));
39 MOCK_METHOD3(OnFinished, int32_t(const std::string &srcNetworkId,
40 const sptr<AssetObj> &assetObj,
41 int32_t result));
42 };
43
44 class AssetRecvCallbackStubTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 public:
51 static inline shared_ptr<MockAssetRecvCallbackStubStub> mockStub_ = nullptr;
52 };
53
SetUpTestCase(void)54 void AssetRecvCallbackStubTest::SetUpTestCase(void)
55 {
56 GTEST_LOG_(INFO) << "SetUpTestCase";
57 mockStub_ = make_shared<MockAssetRecvCallbackStubStub>();
58 }
59
TearDownTestCase(void)60 void AssetRecvCallbackStubTest::TearDownTestCase(void)
61 {
62 GTEST_LOG_(INFO) << "TearDownTestCase";
63 mockStub_ = nullptr;
64 }
65
SetUp(void)66 void AssetRecvCallbackStubTest::SetUp(void)
67 {
68 GTEST_LOG_(INFO) << "SetUp";
69 }
70
TearDown(void)71 void AssetRecvCallbackStubTest::TearDown(void)
72 {
73 GTEST_LOG_(INFO) << "TearDown";
74 }
75
76 /**
77 * @tc.name: AssetRecvCallbackStub_OnRemoteRequest_0100
78 * @tc.desc: The execution of the OnRemoteRequest failed.
79 * @tc.type: FUNC
80 * @tc.require: I7TDJK
81 */
82 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_OnRemoteRequest_0100, TestSize.Level0)
83 {
84 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_OnRemoteRequest_0100 Start";
85 uint32_t code = static_cast<uint32_t>(AssetCallbackInterfaceCode::ASSET_CALLBACK_ON_START);
86 MessageParcel data;
87 MessageParcel reply;
88 MessageOption option;
89 auto ret = mockStub_->OnRemoteRequest(code, data, reply, option);
90 EXPECT_EQ(ret, AssetRecvCallbackStub::ASSET_RECV_CALLBACK_DESCRIPTOR_IS_EMPTY);
91
92 data.WriteInterfaceToken(IAssetRecvCallback::GetDescriptor());
93 uint32_t errCode = 65535;
94 ret = mockStub_->OnRemoteRequest(errCode, data, reply, option);
95 EXPECT_EQ(ret, 305);
96
97 mockStub_->opToInterfaceMap_.insert(make_pair(errCode, nullptr));
98 data.WriteInterfaceToken(IAssetRecvCallback::GetDescriptor());
99 ret = mockStub_->OnRemoteRequest(errCode, data, reply, option);
100 EXPECT_EQ(ret, 305);
101 mockStub_->opToInterfaceMap_.erase(errCode);
102 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_OnRemoteRequest_0100 End";
103 }
104
105 /**
106 * @tc.name: AssetRecvCallbackStub_OnRemoteRequest_0200
107 * @tc.desc: The execution of the OnRemoteRequest success.
108 * @tc.type: FUNC
109 * @tc.require: I7TDJK
110 */
111 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_OnRemoteRequest_0200, TestSize.Level0)
112 {
113 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_OnRemoteRequest_0200 Start";
114 uint32_t code = static_cast<uint32_t>(AssetCallbackInterfaceCode::ASSET_CALLBACK_ON_START);
115 MessageParcel data;
116 MessageParcel reply;
117 MessageOption option;
118 data.WriteInterfaceToken(IAssetRecvCallback::GetDescriptor());
119 data.WriteString("srcNetworkId");
120 data.WriteString("destNetworkId");
121 data.WriteString("sessionId");
122 data.WriteString("dstBundleName");
123
124 EXPECT_CALL(*mockStub_, OnStart(_, _, _, _)).WillOnce(Return(E_OK));
125 auto ret = mockStub_->OnRemoteRequest(code, data, reply, option);
126 EXPECT_EQ(ret, E_OK);
127 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_OnRemoteRequest_0200 End";
128 }
129
130 /**
131 * @tc.name: AssetRecvCallbackStub_HandleOnStart_0100
132 * @tc.desc: verify HandleOnStart.
133 * @tc.type: FUNC
134 * @tc.require: I7TDJK
135 */
136 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_HandleOnStart_0100, TestSize.Level0)
137 {
138 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnStart_0100 Start";
139 MessageParcel data;
140 MessageParcel reply;
141 auto ret = mockStub_->HandleOnStart(data, reply);
142 EXPECT_EQ(ret, E_INVAL_ARG);
143
144 data.WriteString("srcNetworkId");
145 ret = mockStub_->HandleOnStart(data, reply);
146 EXPECT_EQ(ret, E_INVAL_ARG);
147
148 data.WriteString("srcNetworkId");
149 data.WriteString("destNetworkId");
150 ret = mockStub_->HandleOnStart(data, reply);
151 EXPECT_EQ(ret, E_INVAL_ARG);
152
153 data.WriteString("srcNetworkId");
154 data.WriteString("destNetworkId");
155 data.WriteString("sessionId");
156 ret = mockStub_->HandleOnStart(data, reply);
157 EXPECT_EQ(ret, E_INVAL_ARG);
158
159 data.WriteString("srcNetworkId");
160 data.WriteString("destNetworkId");
161 data.WriteString("sessionId");
162 data.WriteString("dstBundleName");
163 EXPECT_CALL(*mockStub_, OnStart(_, _, _, _)).WillOnce(Return(E_PERMISSION_DENIED));
164 ret = mockStub_->HandleOnStart(data, reply);
165 EXPECT_EQ(ret, E_BROKEN_IPC);
166 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnStart_0100 End";
167 }
168
169 /**
170 * @tc.name: AssetRecvCallbackStub_HandleOnRecvProgress_0100
171 * @tc.desc: verify HandleOnRecvProgress.
172 * @tc.type: FUNC
173 * @tc.require: I7TDJK
174 */
175 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_HandleOnRecvProgress_0100, TestSize.Level0)
176 {
177 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnRecvProgress_0100 Start";
178 MessageParcel data;
179 MessageParcel reply;
180 auto ret = mockStub_->HandleOnRecvProgress(data, reply);
181 EXPECT_EQ(ret, E_INVAL_ARG);
182
183 data.WriteString("srcNetworkId");
184 ret = mockStub_->HandleOnRecvProgress(data, reply);
185 EXPECT_EQ(ret, E_INVAL_ARG);
186
187 data.WriteString("srcNetworkId");
188 sptr<AssetObj> assetObj(new (std::nothrow) AssetObj());
189 data.WriteParcelable(assetObj);
190 ret = mockStub_->HandleOnRecvProgress(data, reply);
191 EXPECT_EQ(ret, E_INVAL_ARG);
192
193 data.WriteString("srcNetworkId");
194 data.WriteParcelable(assetObj);
195 data.WriteUint64(1024);
196 ret = mockStub_->HandleOnRecvProgress(data, reply);
197 EXPECT_EQ(ret, E_INVAL_ARG);
198
199 data.WriteString("srcNetworkId");
200 data.WriteParcelable(assetObj);
201 data.WriteUint64(1024);
202 data.WriteUint64(256);
203 EXPECT_CALL(*mockStub_, OnRecvProgress(_, _, _, _)).WillOnce(Return(E_PERMISSION_DENIED));
204 ret = mockStub_->HandleOnRecvProgress(data, reply);
205 EXPECT_EQ(ret, E_BROKEN_IPC);
206
207 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnRecvProgress_0100 End";
208 }
209
210 /**
211 * @tc.name: AssetRecvCallbackStub_HandleOnFinished_0100
212 * @tc.desc: verify HandleOnFinished.
213 * @tc.type: FUNC
214 * @tc.require: I7TDJK
215 */
216 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_HandleOnFinished_0100, TestSize.Level0)
217 {
218 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnFinished_0100 Start";
219 MessageParcel data;
220 MessageParcel reply;
221 auto ret = mockStub_->HandleOnFinished(data, reply);
222 EXPECT_EQ(ret, E_INVAL_ARG);
223
224 data.WriteString("srcNetworkId");
225 ret = mockStub_->HandleOnFinished(data, reply);
226 EXPECT_EQ(ret, E_INVAL_ARG);
227
228 data.WriteString("srcNetworkId");
229 sptr<AssetObj> assetObj(new (std::nothrow) AssetObj());
230 data.WriteParcelable(assetObj);
231 ret = mockStub_->HandleOnFinished(data, reply);
232 EXPECT_EQ(ret, E_INVAL_ARG);
233
234 data.WriteString("srcNetworkId");
235 data.WriteParcelable(assetObj);
236 data.WriteInt32(0);
237 EXPECT_CALL(*mockStub_, OnFinished(_, _, _)).WillOnce(Return(E_PERMISSION_DENIED));
238 ret = mockStub_->HandleOnFinished(data, reply);
239 EXPECT_EQ(ret, E_BROKEN_IPC);
240 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnFinished_0100 End";
241 }
242
243 /**
244 * @tc.name: AssetRecvCallbackStub_HandleOnFinished_0200
245 * @tc.desc: verify HandleOnFinished.
246 * @tc.type: FUNC
247 * @tc.require: I7TDJK
248 */
249 HWTEST_F(AssetRecvCallbackStubTest, AssetRecvCallbackStub_HandleOnFinished_0200, TestSize.Level0)
250 {
251 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnFinished_0200 Start";
252 MessageParcel data;
253 MessageParcel reply;
254
255 data.WriteString("srcNetworkId");
256 sptr<AssetObj> assetObj(new (std::nothrow) AssetObj());
257 data.WriteParcelable(assetObj);
258 data.WriteInt32(0);
259 EXPECT_CALL(*mockStub_, OnFinished(_, _, _)).WillOnce(Return(E_OK));
260 auto ret = mockStub_->HandleOnFinished(data, reply);
261 EXPECT_EQ(ret, E_OK);
262 GTEST_LOG_(INFO) << "AssetRecvCallbackStub_HandleOnFinished_0200 End";
263 }
264 }