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 "cloud_file_sync_service_interface_code.h"
20 #include "cloud_sync_service_stub.h"
21 #include "i_cloud_sync_service.h"
22 #include "service_callback_mock.h"
23
24 namespace OHOS {
25 namespace FileManagement::CloudSync {
26 namespace Test {
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace std;
30
31 class MockService final : public CloudSyncServiceStub {
32 public:
33 MOCK_METHOD1(RegisterCallbackInner, int32_t(const sptr<IRemoteObject> &remoteObject));
34 MOCK_METHOD0(UnRegisterCallbackInner, int32_t());
35 MOCK_METHOD1(StartSyncInner, int32_t(bool forceFlag));
36 MOCK_METHOD0(StopSyncInner, int32_t());
37 MOCK_METHOD3(ChangeAppSwitch, int32_t(const std::string &accoutId, const std::string &bundleName, bool status));
38 MOCK_METHOD2(Clean, int32_t(const std::string &accountId, const CleanOptions &cleanOptions));
39 MOCK_METHOD2(NotifyDataChange, int32_t(const std::string &accoutId, const std::string &bundleName));
40 MOCK_METHOD2(EnableCloud, int32_t(const std::string &accoutId, const SwitchDataObj &switchData));
41 MOCK_METHOD1(DisableCloud, int32_t(const std::string &accoutId));
42 MOCK_METHOD1(StartDownloadFile, int32_t(const std::string &path));
43 MOCK_METHOD1(StopDownloadFile, int32_t(const std::string &path));
44 MOCK_METHOD1(RegisterDownloadFileCallback, int32_t(const sptr<IRemoteObject> &downloadCallback));
45 MOCK_METHOD0(UnregisterDownloadFileCallback, int32_t());
46 MOCK_METHOD3(UploadAsset, int32_t(const int32_t userId, const std::string &request, std::string &result));
47 MOCK_METHOD3(DownloadFile,
48 int32_t(const int32_t userId, const std::string &bundleName, AssetInfoObj &assetInfoObj));
49 };
50
51 class CloudSyncServiceStubTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase(void)59 void CloudSyncServiceStubTest::SetUpTestCase(void)
60 {
61 std::cout << "SetUpTestCase" << std::endl;
62 }
63
TearDownTestCase(void)64 void CloudSyncServiceStubTest::TearDownTestCase(void)
65 {
66 std::cout << "TearDownTestCase" << std::endl;
67 }
68
SetUp(void)69 void CloudSyncServiceStubTest::SetUp(void)
70 {
71 std::cout << "SetUp" << std::endl;
72 }
73
TearDown(void)74 void CloudSyncServiceStubTest::TearDown(void)
75 {
76 std::cout << "TearDown" << std::endl;
77 }
78
79 /**
80 * @tc.name: HandleUnRegisterCallbackInnerTest
81 * @tc.desc: Verify the HandleUnRegisterCallbackInner function.
82 * @tc.type: FUNC
83 * @tc.require: I6H5MH
84 */
85 HWTEST_F(CloudSyncServiceStubTest, HandleUnRegisterCallbackInnerTest, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner Start";
88 try {
89 MockService service;
90 EXPECT_CALL(service, UnRegisterCallbackInner()).WillOnce(Return(E_OK));
91 MessageParcel data;
92 MessageParcel reply;
93 MessageOption option;
94 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
95
96 sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
97 EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
98
99 EXPECT_EQ(E_OK, service.OnRemoteRequest(
100 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK),
101 data, reply, option));
102 remote = nullptr;
103 } catch (...) {
104 EXPECT_TRUE(false);
105 GTEST_LOG_(INFO) << " HandleUnRegisterCallbackInner ERROR";
106 }
107 GTEST_LOG_(INFO) << "HandleUnRegisterCallbackInner End";
108 }
109
110 /**
111 * @tc.name: HandleRegisterCallbackInnerTest
112 * @tc.desc: Verify the HandleRegisterCallbackInner function.
113 * @tc.type: FUNC
114 * @tc.require: I6H5MH
115 */
116 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterCallbackInnerTest, TestSize.Level1)
117 {
118 GTEST_LOG_(INFO) << "HandleRegisterCallbackInner Start";
119 try {
120 MockService service;
121 EXPECT_CALL(service, RegisterCallbackInner(_)).WillOnce(Return(E_OK));
122 MessageParcel data;
123 MessageParcel reply;
124 MessageOption option;
125 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
126
127 sptr<CloudSyncCallbackMock> remote = sptr(new CloudSyncCallbackMock());
128 EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr()));
129
130 EXPECT_EQ(E_OK, service.OnRemoteRequest(
131 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK),
132 data, reply, option));
133 remote = nullptr;
134 } catch (...) {
135 EXPECT_TRUE(false);
136 GTEST_LOG_(INFO) << " HandleRegisterCallbackInner ERROR";
137 }
138 GTEST_LOG_(INFO) << "HandleRegisterCallbackInner End";
139 }
140
141 /**
142 * @tc.name: HandleStartSyncInnerTest
143 * @tc.desc: Verify the HandleStartSyncInner function.
144 * @tc.type: FUNC
145 * @tc.require: I6H5MH
146 */
147 HWTEST_F(CloudSyncServiceStubTest, HandleStartSyncInnerTest, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "HandleStartSyncInner Start";
150 try {
151 MockService service;
152 EXPECT_CALL(service, StartSyncInner(_)).WillOnce(Return(E_OK));
153 MessageParcel data;
154 MessageParcel reply;
155 MessageOption option;
156 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
157
158 bool forceFlag = true;
159 EXPECT_TRUE(data.WriteBool(forceFlag));
160
161 EXPECT_EQ(E_OK, service.OnRemoteRequest(
162 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC), data,
163 reply, option));
164 } catch (...) {
165 EXPECT_TRUE(false);
166 GTEST_LOG_(INFO) << " HandleStartSyncInner ERROR";
167 }
168 GTEST_LOG_(INFO) << "HandleStartSyncInner End";
169 }
170
171 /**
172 * @tc.name: HandleStopSyncInnerTest
173 * @tc.desc: Verify the HandleStopSyncInner function.
174 * @tc.type: FUNC
175 * @tc.require: I6H5MH
176 */
177 HWTEST_F(CloudSyncServiceStubTest, HandleStopSyncInnerTest, TestSize.Level1)
178 {
179 GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
180 try {
181 MockService service;
182 EXPECT_CALL(service, StopSyncInner()).WillOnce(Return(E_OK));
183 MessageParcel data;
184 MessageParcel reply;
185 MessageOption option;
186 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
187
188 EXPECT_EQ(E_OK, service.OnRemoteRequest(
189 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC), data,
190 reply, option));
191 } catch (...) {
192 EXPECT_TRUE(false);
193 GTEST_LOG_(INFO) << " HandleStopSyncInner ERROR";
194 }
195 GTEST_LOG_(INFO) << "HandleStopSyncInner End";
196 }
197
198 /**
199 * @tc.name: HandleChangeAppSwitchTest
200 * @tc.desc: Verify the HandleChangeAppSwitch function.
201 * @tc.type: FUNC
202 * @tc.require: I6H5MH
203 */
204 HWTEST_F(CloudSyncServiceStubTest, HandleChangeAppSwitchTest, TestSize.Level1)
205 {
206 GTEST_LOG_(INFO) << "HandleChangeAppSwitch Start";
207 try {
208 MockService service;
209 EXPECT_CALL(service, ChangeAppSwitch(_, _, _)).WillOnce(Return(E_OK));
210 MessageParcel data;
211 MessageParcel reply;
212 MessageOption option;
213 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
214
215 EXPECT_EQ(E_OK, service.OnRemoteRequest(
216 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH),
217 data, reply, option));
218 } catch (...) {
219 EXPECT_TRUE(false);
220 GTEST_LOG_(INFO) << " HandleChangeAppSwitch ERROR";
221 }
222 GTEST_LOG_(INFO) << "HandleChangeAppSwitch End";
223 }
224
225 /**
226 * @tc.name: HandleNotifyDataChangeTest
227 * @tc.desc: Verify the HandleNotifyDataChange function.
228 * @tc.type: FUNC
229 * @tc.require: I6H5MH
230 */
231 HWTEST_F(CloudSyncServiceStubTest, HandleNotifyDataChangeTest, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "HandleNotifyDataChange Start";
234 try {
235 MockService service;
236 EXPECT_CALL(service, NotifyDataChange(_, _)).WillOnce(Return(E_OK));
237 MessageParcel data;
238 MessageParcel reply;
239 MessageOption option;
240 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
241
242 EXPECT_EQ(E_OK, service.OnRemoteRequest(
243 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE),
244 data, reply, option));
245 } catch (...) {
246 EXPECT_TRUE(false);
247 GTEST_LOG_(INFO) << " HandleNotifyDataChange ERROR";
248 }
249 GTEST_LOG_(INFO) << "HandleNotifyDataChange End";
250 }
251
252 /**
253 * @tc.name: HandleDisableCloudTest
254 * @tc.desc: Verify the HandleDisableCloud function.
255 * @tc.type: FUNC
256 * @tc.require: I6H5MH
257 */
258 HWTEST_F(CloudSyncServiceStubTest, HandleDisableCloudTest, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "HandleStopSyncInner Start";
261 try {
262 MockService service;
263 EXPECT_CALL(service, DisableCloud(_)).WillOnce(Return(E_OK));
264 MessageParcel data;
265 MessageParcel reply;
266 MessageOption option;
267 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
268
269 EXPECT_EQ(E_OK, service.OnRemoteRequest(
270 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD), data,
271 reply, option));
272 } catch (...) {
273 EXPECT_TRUE(false);
274 GTEST_LOG_(INFO) << " HandleDisableCloud ERROR";
275 }
276 GTEST_LOG_(INFO) << "HandleDisableCloud End";
277 }
278
279 /**
280 * @tc.name: HandleStartDownloadFileTest
281 * @tc.desc: Verify the HandleStartDownloadFile function.
282 * @tc.type: FUNC
283 * @tc.require: I6H5MH
284 */
285 HWTEST_F(CloudSyncServiceStubTest, HandleStartDownloadFileTest, TestSize.Level1)
286 {
287 GTEST_LOG_(INFO) << "HandleStartDownloadFile Start";
288 try {
289 MockService service;
290 EXPECT_CALL(service, StartDownloadFile(_)).WillOnce(Return(E_OK));
291 MessageParcel data;
292 MessageParcel reply;
293 MessageOption option;
294 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
295
296 EXPECT_EQ(E_OK, service.OnRemoteRequest(
297 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE),
298 data, reply, option));
299 } catch (...) {
300 EXPECT_TRUE(false);
301 GTEST_LOG_(INFO) << " HandleStartDownloadFile ERROR";
302 }
303 GTEST_LOG_(INFO) << "HandleStartDownloadFile End";
304 }
305
306 /**
307 * @tc.name: HandleStopDownloadFileTest
308 * @tc.desc: Verify the HandleStopDownloadFile function.
309 * @tc.type: FUNC
310 * @tc.require: I6H5MH
311 */
312 HWTEST_F(CloudSyncServiceStubTest, HandleStopDownloadFileTest, TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "HandleStopDownloadFile Start";
315 try {
316 MockService service;
317 EXPECT_CALL(service, StopDownloadFile(_)).WillOnce(Return(E_OK));
318 MessageParcel data;
319 MessageParcel reply;
320 MessageOption option;
321 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
322
323 EXPECT_EQ(E_OK, service.OnRemoteRequest(
324 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE),
325 data, reply, option));
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << " HandleStopDownloadFile ERROR";
329 }
330 GTEST_LOG_(INFO) << "HandleStopDownloadFile End";
331 }
332
333 /**
334 * @tc.name: HandleRegisterDownloadFileCallbackTest
335 * @tc.desc: Verify the HandleRegisterDownloadFileCallback function.
336 * @tc.type: FUNC
337 * @tc.require: I6H5MH
338 */
339 HWTEST_F(CloudSyncServiceStubTest, HandleRegisterDownloadFileCallbackTest, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback Start";
342 try {
343 MockService service;
344 EXPECT_CALL(service, RegisterDownloadFileCallback(_)).WillOnce(Return(E_OK));
345 MessageParcel data;
346 MessageParcel reply;
347 MessageOption option;
348 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
349
350 EXPECT_EQ(E_OK, service.OnRemoteRequest(
351 static_cast<uint32_t>(
352 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK),
353 data, reply, option));
354 } catch (...) {
355 EXPECT_TRUE(false);
356 GTEST_LOG_(INFO) << " HandleRegisterDownloadFileCallback ERROR";
357 }
358 GTEST_LOG_(INFO) << "HandleRegisterDownloadFileCallback End";
359 }
360
361 /**
362 * @tc.name: HandleUnregisterDownloadFileCallbackTest
363 * @tc.desc: Verify the HandleUnregisterDownloadFileCallback function.
364 * @tc.type: FUNC
365 * @tc.require: I6H5MH
366 */
367 HWTEST_F(CloudSyncServiceStubTest, HandleUnregisterDownloadFileCallbackTest, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback Start";
370 try {
371 MockService service;
372 EXPECT_CALL(service, UnregisterDownloadFileCallback()).WillOnce(Return(E_OK));
373 MessageParcel data;
374 MessageParcel reply;
375 MessageOption option;
376 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
377
378 EXPECT_EQ(E_OK, service.OnRemoteRequest(
379 static_cast<uint32_t>(
380 CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK),
381 data, reply, option));
382 } catch (...) {
383 EXPECT_TRUE(false);
384 GTEST_LOG_(INFO) << " HandleUnregisterDownloadFileCallback ERROR";
385 }
386 GTEST_LOG_(INFO) << "HandleUnregisterDownloadFileCallback End";
387 }
388
389 /**
390 * @tc.name: HandleUploadAssetTest
391 * @tc.desc: Verify the HandleUploadAsset function.
392 * @tc.type: FUNC
393 * @tc.require: I6H5MH
394 */
395 HWTEST_F(CloudSyncServiceStubTest, HandleUploadAssetTest, TestSize.Level1)
396 {
397 GTEST_LOG_(INFO) << "HandleUploadAsset Start";
398 try {
399 MockService service;
400 EXPECT_CALL(service, UploadAsset(_, _, _)).WillOnce(Return(E_OK));
401 MessageParcel data;
402 MessageParcel reply;
403 MessageOption option;
404 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
405
406 EXPECT_EQ(E_OK, service.OnRemoteRequest(
407 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET), data,
408 reply, option));
409 } catch (...) {
410 EXPECT_TRUE(false);
411 GTEST_LOG_(INFO) << " HandleUploadAsset ERROR";
412 }
413 GTEST_LOG_(INFO) << "HandleUploadAsset End";
414 }
415
416 /**
417 * @tc.name: HandleDownloadFileTest
418 * @tc.desc: Verify the HandleDownloadFile function.
419 * @tc.type: FUNC
420 * @tc.require: I6H5MH
421 */
422 HWTEST_F(CloudSyncServiceStubTest, HandleDownloadFileTest, TestSize.Level1)
423 {
424 GTEST_LOG_(INFO) << "HandleDownloadFile Start";
425 try {
426 MockService service;
427 MessageParcel data;
428 MessageParcel reply;
429 MessageOption option;
430 EXPECT_TRUE(data.WriteInterfaceToken(ICloudSyncService::GetDescriptor()));
431
432 EXPECT_EQ(E_INVAL_ARG, service.OnRemoteRequest(
433 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE), data,
434 reply, option));
435 } catch (...) {
436 EXPECT_TRUE(false);
437 GTEST_LOG_(INFO) << " HandleDownloadFile ERROR";
438 }
439 GTEST_LOG_(INFO) << "HandleDownloadFile End";
440 }
441
442 } // namespace Test
443 } // namespace FileManagement::CloudSync
444 } // namespace OHOS