1 /*
2 * Copyright (c) 2022-2024 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 <cstddef>
17 #include <cstdio>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include "b_file_info.h"
22 #include "i_service_mock.h"
23 #include "iremote_object_mock.h"
24 #include "iservice_registry.h"
25 #include "service_proxy.h"
26 #include "service_reverse_mock.h"
27 #include "unique_fd.h"
28 #include "utils_mock_global_variable.h"
29
30 namespace OHOS::FileManagement::Backup {
31 using namespace std;
32 using namespace testing;
33
34 namespace {
35 const string BUNDLE_NAME = "com.example.app2backup";
36 const string FILE_NAME = "1.tar";
37 constexpr int32_t SERVICE_ID = 5203;
38 } // namespace
39
40 class ServiceProxyTest : public testing::Test {
41 public:
SetUpTestCase(void)42 static void SetUpTestCase(void) {};
TearDownTestCase()43 static void TearDownTestCase() {};
44 void SetUp() override;
45 void TearDown() override;
46
47 shared_ptr<ServiceProxy> proxy_ = nullptr;
48 sptr<IServiceMock> mock_ = nullptr;
49 sptr<ServiceReverseMock> remote_ = nullptr;
50 };
51
SetUp()52 void ServiceProxyTest::SetUp()
53 {
54 mock_ = sptr(new IServiceMock());
55 proxy_ = make_shared<ServiceProxy>(mock_);
56 remote_ = sptr(new ServiceReverseMock());
57 }
58
TearDown()59 void ServiceProxyTest::TearDown()
60 {
61 proxy_ = nullptr;
62 mock_ = nullptr;
63 remote_ = nullptr;
64 }
65
66 /**
67 * @tc.number: SUB_Service_proxy_InitRestoreSession_0100
68 * @tc.name: SUB_Service_proxy_InitRestoreSession_0100
69 * @tc.desc: 测试 InitRestoreSession 注册restore Session接口调用成功和失败
70 * @tc.size: MEDIUM
71 * @tc.type: FUNC
72 * @tc.level Level 1
73 * @tc.require: I6F3GV
74 */
75 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0100, testing::ext::TestSize.Level1)
76 {
77 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitRestoreSession_0100";
78 if (proxy_ == nullptr) {
79 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitRestoreSession_0100 proxy_ == nullptr";
80 return;
81 }
82 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
83 .Times(1)
84 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
85 int32_t result = proxy_->InitRestoreSession(remote_);
86 EXPECT_EQ(result, BError(BError::Codes::OK));
87
88 result = proxy_->InitRestoreSession(nullptr);
89 EXPECT_NE(result, BError(BError::Codes::OK));
90 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitRestoreSession_0100";
91 }
92
93 /**
94 * @tc.number: SUB_Service_proxy_InitRestoreSession_0200
95 * @tc.name: SUB_Service_proxy_InitRestoreSession_0200
96 * @tc.desc: 测试 InitRestoreSession 注册restore Session with errMsg接口调用成功和失败
97 * @tc.size: MEDIUM
98 * @tc.type: FUNC
99 * @tc.level Level 1
100 * @tc.require: I6F3GV
101 */
102 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0200, testing::ext::TestSize.Level1)
103 {
104 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitRestoreSession_0200";
105 std::string errMsg;
106 if (proxy_ == nullptr) {
107 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitRestoreSession_0200 proxy_ == nullptr";
108 return;
109 }
110 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
111 .Times(1)
112 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest));
113 int32_t result = proxy_->InitRestoreSession(remote_, errMsg);
114 EXPECT_EQ(result, BError(BError::Codes::OK));
115
116 result = proxy_->InitRestoreSession(nullptr, errMsg);
117 EXPECT_NE(result, BError(BError::Codes::OK));
118 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitRestoreSession_0200";
119 }
120
121 /**
122 * @tc.number: SUB_Service_proxy_InitBackupSession_0100
123 * @tc.name: SUB_Service_proxy_InitBackupSession_0100
124 * @tc.desc: 测试 InitBackupSession 注册backup Session接口调用成功和失败
125 * @tc.size: MEDIUM
126 * @tc.type: FUNC
127 * @tc.level Level 1
128 * @tc.require: I6F3GV
129 */
130 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0100, testing::ext::TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitBackupSession_0100";
133 if (proxy_ == nullptr) {
134 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitBackupSession_0100 proxy_ == nullptr";
135 return;
136 }
137 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
138 .Times(1)
139 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
140
141 int32_t result = proxy_->InitBackupSession(remote_);
142 EXPECT_EQ(result, BError(BError::Codes::OK));
143
144 result = proxy_->InitBackupSession(nullptr);
145 EXPECT_NE(result, BError(BError::Codes::OK));
146 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitBackupSession_0100";
147 }
148
149 /**
150 * @tc.number: SUB_Service_proxy_InitBackupSession_0200
151 * @tc.name: SUB_Service_proxy_InitBackupSession_0200
152 * @tc.desc: 测试 InitBackupSession 注册backup Session with errMsg接口调用成功和失败
153 * @tc.size: MEDIUM
154 * @tc.type: FUNC
155 * @tc.level Level 1
156 * @tc.require: I6F3GV
157 */
158 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0200, testing::ext::TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitBackupSession_0200";
161 std::string errMsg;
162 if (proxy_ == nullptr) {
163 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitBackupSession_0200 proxy_ == nullptr";
164 return;
165 }
166 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
167 .Times(1)
168 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest));
169
170 int32_t result = proxy_->InitBackupSession(remote_, errMsg);
171 EXPECT_EQ(result, BError(BError::Codes::OK));
172
173 result = proxy_->InitBackupSession(nullptr, errMsg);
174 EXPECT_NE(result, BError(BError::Codes::OK));
175 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitBackupSession_0100";
176 }
177
178 /**
179 * @tc.number: SUB_Service_proxy_Start_0100
180 * @tc.name: SUB_Service_proxy_Start_0100
181 * @tc.desc: 测试 Start 启动备份恢复流程接口调用成功和失败
182 * @tc.size: MEDIUM
183 * @tc.type: FUNC
184 * @tc.level Level 1
185 * @tc.require: I6F3GV
186 */
187 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Start_0100, testing::ext::TestSize.Level1)
188 {
189 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Start_0100";
190 if (proxy_ == nullptr) {
191 GTEST_LOG_(INFO) << "SUB_Service_proxy_Start_0100 proxy_ == nullptr";
192 return;
193 }
194 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
195 .Times(2)
196 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
197 .WillOnce(Return(EPERM));
198 int32_t result = proxy_->Start();
199 EXPECT_EQ(result, BError(BError::Codes::OK));
200
201 result = proxy_->Start();
202 EXPECT_NE(result, BError(BError::Codes::OK));
203 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Start_0100";
204 }
205
206 /**
207 * @tc.number: SUB_Service_proxy_GetLocalCapabilities_0100
208 * @tc.name: SUB_Service_proxy_GetLocalCapabilities_0100
209 * @tc.desc: 测试 GetLocalCapabilities 获取能力文件接口调用成功和失败
210 * @tc.size: MEDIUM
211 * @tc.type: FUNC
212 * @tc.level Level 1
213 * @tc.require: I6F3GV
214 */
215 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilities_0100, testing::ext::TestSize.Level1)
216 {
217 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilities_0100";
218 if (proxy_ == nullptr) {
219 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr";
220 return;
221 }
222 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
223 .Times(2)
224 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest))
225 .WillOnce(Return(EPERM));
226 UniqueFd fd = proxy_->GetLocalCapabilities();
227 EXPECT_GT(fd, BError(BError::Codes::OK));
228 UniqueFd fdErr = proxy_->GetLocalCapabilities();
229 EXPECT_LT(fdErr, BError(BError::Codes::OK));
230 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilities_0100";
231 }
232
233 /**
234 * @tc.number: SUB_Service_proxy_PublishFile_0100
235 * @tc.name: SUB_Service_proxy_PublishFile_0100
236 * @tc.desc: 测试 PublishFile 推送接口调用成功和失败
237 * @tc.size: MEDIUM
238 * @tc.type: FUNC
239 * @tc.level Level 1
240 * @tc.require: I6F3GV
241 */
242 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishFile_0100, testing::ext::TestSize.Level1)
243 {
244 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishFile_0100";
245 if (proxy_ == nullptr) {
246 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr";
247 return;
248 }
249 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
250 .Times(2)
251 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
252 .WillOnce(Return(EPERM));
253 string bundleName = "com.example.app2backup";
254 string fileName = "1.tar";
255 BFileInfo fileInfo(bundleName, fileName, -1);
256 int32_t result = proxy_->PublishFile(fileInfo);
257 EXPECT_EQ(result, BError(BError::Codes::OK));
258
259 result = proxy_->PublishFile(fileInfo);
260 EXPECT_NE(result, BError(BError::Codes::OK));
261 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishFile_0100";
262 }
263
264 /**
265 * @tc.number: SUB_Service_proxy_AppFileReady_0100
266 * @tc.name: SUB_Service_proxy_AppFileReady_0100
267 * @tc.desc: 测试 AppFileReady 文件就绪调用成功和失败
268 * @tc.size: MEDIUM
269 * @tc.type: FUNC
270 * @tc.level Level 1
271 * @tc.require: I6F3GV
272 */
273 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppFileReady_0100, testing::ext::TestSize.Level1)
274 {
275 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppFileReady_0100";
276 if (proxy_ == nullptr) {
277 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppFileReady_0100 proxy_ == nullptr";
278 return;
279 }
280 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
281 .Times(3)
282 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
283 .WillOnce(Return(EPERM))
284 .WillOnce(Return(EPERM));
285
286 string bundleName = "com.example.app2backup";
287 TestManager tm("AppFileReady_GetFd_0100");
288 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
289 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
290
291 int32_t result = proxy_->AppFileReady(bundleName, move(fd), 0);
292 EXPECT_EQ(result, BError(BError::Codes::OK));
293
294 TestManager tmErr("AppFileReady_GetFd_0200");
295 UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
296 result = proxy_->AppFileReady(bundleName, move(fdErr), 0);
297 EXPECT_NE(result, BError(BError::Codes::OK));
298 result = proxy_->AppFileReady(bundleName, UniqueFd(-1), 0);
299 EXPECT_NE(result, BError(BError::Codes::OK));
300 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppFileReady_0100";
301 }
302
303 /**
304 * @tc.number: SUB_Service_proxy_AppDone_0100
305 * @tc.name: SUB_Service_proxy_AppDone_0100
306 * @tc.desc: 测试 AppDone ext备份恢复流程结束调用成功和失败
307 * @tc.size: MEDIUM
308 * @tc.type: FUNC
309 * @tc.level Level 1
310 * @tc.require: I6F3GV
311 */
312 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppDone_0100, testing::ext::TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppDone_0100";
315 if (proxy_ == nullptr) {
316 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppDone_0100 proxy_ == nullptr";
317 return;
318 }
319 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
320 .Times(2)
321 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
322 .WillOnce(Return(EPERM));
323 int32_t result = proxy_->AppDone(BError(BError::Codes::OK));
324 EXPECT_EQ(result, BError(BError::Codes::OK));
325
326 result = proxy_->AppDone(BError(BError::Codes::OK));
327 EXPECT_NE(result, BError(BError::Codes::OK));
328 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppDone_0100";
329 }
330
331 /**
332 * @tc.number: SUB_Service_proxy_ServiceResultReport_0100
333 * @tc.name: SUB_Service_proxy_ServiceResultReport_0100
334 * @tc.desc: 测试 ServiceResultReport
335 * @tc.size: MEDIUM
336 * @tc.type: FUNC
337 * @tc.level Level 1
338 * @tc.require: I6F3GV
339 */
340 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_ServiceResultReport_0100, testing::ext::TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_ServiceResultReport_0100";
343 if (proxy_ == nullptr) {
344 GTEST_LOG_(INFO) << "SUB_Service_proxy_ServiceResultReport_0100 proxy_ == nullptr";
345 return;
346 }
347 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
348 .Times(2)
349 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
350 .WillOnce(Return(EPERM));
351 std::string restoreRetInfo = "test_restoreRetInfo";
352 BackupRestoreScenario scenario = FULL_BACKUP;
353 int32_t result = proxy_->ServiceResultReport(restoreRetInfo, scenario, BError(BError::Codes::OK));
354 EXPECT_EQ(result, BError(BError::Codes::OK));
355
356 result = proxy_->ServiceResultReport(restoreRetInfo, scenario, BError(BError::Codes::OK));
357 EXPECT_NE(result, BError(BError::Codes::OK));
358 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_ServiceResultReport_0100";
359 }
360
361 /**
362 * @tc.number: SUB_Service_proxy_GetFileHandle_0100
363 * @tc.name: SUB_Service_proxy_GetFileHandle_0100
364 * @tc.desc: 测试 GetFileHandle 获取真实文件调用成功和失败
365 * @tc.size: MEDIUM
366 * @tc.type: FUNC
367 * @tc.level Level 1
368 * @tc.require: I6F3GV
369 */
370 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetFileHandle_0100, testing::ext::TestSize.Level1)
371 {
372 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetFileHandle_0100";
373 if (proxy_ == nullptr) {
374 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetFileHandle_0100 proxy_ == nullptr";
375 return;
376 }
377 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
378 .Times(2)
379 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
380 .WillOnce(Return(EPERM));
381 string bundleName = "com.example.app2backup";
382 string fileName = "1.tar";
383 int32_t result = proxy_->GetFileHandle(bundleName, fileName);
384 EXPECT_EQ(result, BError(BError::Codes::OK));
385
386 result = proxy_->GetFileHandle(bundleName, fileName);
387 EXPECT_NE(result, BError(BError::Codes::OK));
388 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetFileHandle_0100";
389 }
390
391 /**
392 * @tc.number: SUB_Service_proxy_AppendBundlesRestoreSession_0100
393 * @tc.name: SUB_Service_proxy_AppendBundlesRestoreSession_0100
394 * @tc.desc: 测试 AppendBundlesRestoreSession 获取真实文件调用成功和失败
395 * @tc.size: MEDIUM
396 * @tc.type: FUNC
397 * @tc.level Level 1
398 * @tc.require: I6URNZ
399 */
400 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level1)
401 {
402 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0100";
403 if (proxy_ == nullptr) {
404 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0100 proxy_ == nullptr";
405 return;
406 }
407 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
408 .Times(1)
409 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
410
411 std::vector<string> bundleNames;
412 TestManager tm("BackupSession_GetFd_0100");
413 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
414 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
415 int32_t result = proxy_->AppendBundlesRestoreSession(move(fd), bundleNames);
416 EXPECT_EQ(result, BError(BError::Codes::OK));
417 result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames);
418 EXPECT_NE(result, BError(BError::Codes::OK));
419 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesRestoreSession_0100";
420 }
421
422 /**
423 * @tc.number: SUB_Service_proxy_AppendBundlesRestoreSession_0101
424 * @tc.name: SUB_Service_proxy_AppendBundlesRestoreSession_0101
425 * @tc.desc: 测试 AppendBundlesRestoreSession 获取真实文件调用成功和失败
426 * @tc.size: MEDIUM
427 * @tc.type: FUNC
428 * @tc.level Level 1
429 * @tc.require: I6URNZ
430 */
431 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level1)
432 {
433 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0101";
434 if (proxy_ == nullptr) {
435 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0101 proxy_ == nullptr";
436 return;
437 }
438 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
439 .Times(1)
440 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
441
442 std::vector<string> bundleNames;
443 TestManager tm("BackupSession_GetFd_0100");
444 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
445 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
446 std::vector<std::string> detailInfos;
447 int32_t result = proxy_->AppendBundlesRestoreSession(move(fd), bundleNames, detailInfos);
448 EXPECT_EQ(result, BError(BError::Codes::OK));
449 result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, detailInfos);
450 EXPECT_NE(result, BError(BError::Codes::OK));
451 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesRestoreSession_0101";
452 }
453
454 /**
455 * @tc.number: SUB_Service_proxy_AppendBundlesRestoreSession_0200
456 * @tc.name: SUB_Service_proxy_AppendBundlesRestoreSession_0200
457 * @tc.desc: 测试 AppendBundlesRestoreSession 获取真实文件调用成功和失败
458 * @tc.size: MEDIUM
459 * @tc.type: FUNC
460 * @tc.level Level 1
461 * @tc.require: I6URNZ
462 */
463 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0200, testing::ext::TestSize.Level1)
464 {
465 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0200";
466 if (proxy_ == nullptr) {
467 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0200 proxy_ == nullptr";
468 return;
469 }
470
471 std::vector<string> bundleNames;
472 int32_t result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames);
473 EXPECT_NE(result, BError(BError::Codes::OK));
474 result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames);
475 EXPECT_NE(result, BError(BError::Codes::OK));
476 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesRestoreSession_0200";
477 }
478
479 /**
480 * @tc.number: SUB_Service_proxy_AppendBundlesBackupSession_0100
481 * @tc.name: SUB_Service_proxy_AppendBundlesBackupSession_0100
482 * @tc.desc: 测试 AppendBundlesBackupSession 获取真实文件调用成功和失败
483 * @tc.size: MEDIUM
484 * @tc.type: FUNC
485 * @tc.level Level 1
486 * @tc.require: I6URNZ
487 */
488 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level1)
489 {
490 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesBackupSession_0100";
491 if (proxy_ == nullptr) {
492 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesBackupSession_0100 proxy_ == nullptr";
493 return;
494 }
495 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
496 .Times(2)
497 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
498 .WillOnce(Return(EPERM));
499
500 std::vector<string> bundleNames;
501
502 int32_t result = proxy_->AppendBundlesBackupSession(bundleNames);
503 EXPECT_EQ(result, BError(BError::Codes::OK));
504 result = proxy_->AppendBundlesBackupSession(bundleNames);
505 EXPECT_NE(result, BError(BError::Codes::OK));
506 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesBackupSession_0100";
507 }
508
509 /**
510 * @tc.number: SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100
511 * @tc.name: SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100
512 * @tc.desc: 测试 AppendBundlesDetailsBackupSession
513 * @tc.size: MEDIUM
514 * @tc.type: FUNC
515 * @tc.level Level 1
516 * @tc.require: I6URNZ
517 */
518 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100, testing::ext::TestSize.Level1)
519 {
520 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100";
521 if (proxy_ == nullptr) {
522 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100 proxy_ == nullptr";
523 return;
524 }
525 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
526 .Times(2)
527 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
528 .WillOnce(Return(EPERM));
529
530 std::vector<std::string> bundleNames;
531 std::vector<std::string> detailInfos;
532
533 int32_t result = proxy_->AppendBundlesDetailsBackupSession(bundleNames, detailInfos);
534 EXPECT_EQ(result, BError(BError::Codes::OK));
535
536 result = proxy_->AppendBundlesDetailsBackupSession(bundleNames, detailInfos);
537 EXPECT_NE(result, BError(BError::Codes::OK));
538 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100";
539 }
540
541 /**
542 * @tc.number: SUB_Service_proxy_Finish_0100
543 * @tc.name: SUB_Service_proxy_Finish_0100
544 * @tc.desc: 测试 Finish 获取真实文件调用成功和失败
545 * @tc.size: MEDIUM
546 * @tc.type: FUNC
547 * @tc.level Level 1
548 * @tc.require: I6URNZ
549 */
550 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Finish_0100, testing::ext::TestSize.Level1)
551 {
552 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Finish_0100";
553 if (proxy_ == nullptr) {
554 GTEST_LOG_(INFO) << "SUB_Service_proxy_Finish_0100 proxy_ == nullptr";
555 return;
556 }
557 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
558 .Times(2)
559 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
560 .WillOnce(Return(EPERM));
561
562 int32_t result = proxy_->Finish();
563 EXPECT_EQ(result, BError(BError::Codes::OK));
564 result = proxy_->Finish();
565 EXPECT_NE(result, BError(BError::Codes::OK));
566 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Finish_0100";
567 }
568
569 /**
570 * @tc.number: SUB_Service_proxy_Release_0100
571 * @tc.name: SUB_Service_proxy_Release_0100
572 * @tc.desc: 测试 Release 调用成功和失败
573 * @tc.size: MEDIUM
574 * @tc.type: FUNC
575 * @tc.level Level 1
576 * @tc.require: I90ZV5
577 */
578 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Release_0100, testing::ext::TestSize.Level1)
579 {
580 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Release_0100";
581 if (proxy_ == nullptr) {
582 GTEST_LOG_(INFO) << "SUB_Service_proxy_Release_0100 proxy_ == nullptr";
583 return;
584 }
585 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
586 .Times(2)
587 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
588 .WillOnce(Return(EPERM));
589
590 int32_t result = proxy_->Release();
591 EXPECT_EQ(result, BError(BError::Codes::OK));
592 result = proxy_->Release();
593 EXPECT_NE(result, BError(BError::Codes::OK));
594 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Release_0100";
595 }
596
597 /**
598 * @tc.number: SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100
599 * @tc.name: SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100
600 * @tc.desc: 测试 GetLocalCapabilitiesIncremental 接口调用成功和失败
601 * @tc.size: MEDIUM
602 * @tc.type: FUNC
603 * @tc.level Level 1
604 * @tc.require: I90ZV5
605 */
606 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100, testing::ext::TestSize.Level1)
607 {
608 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100";
609 if (proxy_ == nullptr) {
610 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100 proxy_ == nullptr";
611 return;
612 }
613 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
614 .Times(2)
615 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest))
616 .WillOnce(Return(EPERM));
617
618 std::vector<BIncrementalData> bundleNames;
619 BIncrementalData data("com.example.app2backup", 0);
620 bundleNames.push_back(data);
621 UniqueFd fd = proxy_->GetLocalCapabilitiesIncremental(bundleNames);
622 EXPECT_GT(fd, BError(BError::Codes::OK));
623
624 UniqueFd fdErr = proxy_->GetLocalCapabilitiesIncremental(bundleNames);
625 EXPECT_LT(fdErr, BError(BError::Codes::OK));
626 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100";
627 }
628
629 /**
630 * @tc.number: SUB_Service_proxy_InitIncrementalBackupSession_0100
631 * @tc.name: SUB_Service_proxy_InitIncrementalBackupSession_0100
632 * @tc.desc: 测试 InitIncrementalBackupSession 接口调用成功和失败
633 * @tc.size: MEDIUM
634 * @tc.type: FUNC
635 * @tc.level Level 1
636 * @tc.require: I90ZV5
637 */
638 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1)
639 {
640 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitIncrementalBackupSession_0100";
641 if (proxy_ == nullptr) {
642 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitIncrementalBackupSession_0100 proxy_ == nullptr";
643 return;
644 }
645 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
646 .Times(1)
647 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
648
649 int32_t result = proxy_->InitIncrementalBackupSession(remote_);
650 EXPECT_EQ(result, BError(BError::Codes::OK));
651
652 result = proxy_->InitIncrementalBackupSession(nullptr);
653 EXPECT_NE(result, BError(BError::Codes::OK));
654 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitIncrementalBackupSession_0100";
655 }
656
657 /**
658 * @tc.number: SUB_Service_proxy_InitIncrementalBackupSession_0200
659 * @tc.name: SUB_Service_proxy_InitIncrementalBackupSession_0200
660 * @tc.desc: 测试 InitIncrementalBackupSession with errMsg接口调用成功和失败
661 * @tc.size: MEDIUM
662 * @tc.type: FUNC
663 * @tc.level Level 1
664 * @tc.require: I90ZV5
665 */
666 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0200, testing::ext::TestSize.Level1)
667 {
668 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitIncrementalBackupSession_0200";
669 std::string errMsg;
670 if (proxy_ == nullptr) {
671 GTEST_LOG_(INFO) << "SUB_Service_proxy_InitIncrementalBackupSession_0200 proxy_ == nullptr";
672 return;
673 }
674 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
675 .Times(1)
676 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest));
677
678 int32_t result = proxy_->InitIncrementalBackupSession(remote_, errMsg);
679 EXPECT_EQ(result, BError(BError::Codes::OK));
680
681 result = proxy_->InitIncrementalBackupSession(nullptr, errMsg);
682 EXPECT_NE(result, BError(BError::Codes::OK));
683 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitIncrementalBackupSession_0200";
684 }
685
686 /**
687 * @tc.number: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100
688 * @tc.name: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100
689 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 接口调用成功和失败
690 * @tc.size: MEDIUM
691 * @tc.type: FUNC
692 * @tc.level Level 1
693 * @tc.require: I90ZV5
694 */
695 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100, testing::ext::TestSize.Level1)
696 {
697 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100";
698 if (proxy_ == nullptr) {
699 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100 proxy_ == nullptr";
700 return;
701 }
702 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
703 .Times(2)
704 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
705 .WillOnce(Return(EPERM));
706
707 std::vector<BIncrementalData> bundleNames;
708 int32_t result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames);
709 EXPECT_EQ(result, BError(BError::Codes::OK));
710
711 result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames);
712 EXPECT_NE(result, BError(BError::Codes::OK));
713 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100";
714 }
715
716 /**
717 * @tc.number: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101
718 * @tc.name: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101
719 * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 接口调用成功和失败
720 * @tc.size: MEDIUM
721 * @tc.type: FUNC
722 * @tc.level Level 1
723 * @tc.require: I90ZV5
724 */
725 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101,
726 testing::ext::TestSize.Level1)
727 {
728 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101";
729 if (proxy_ == nullptr) {
730 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101 proxy_ == nullptr";
731 return;
732 }
733 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
734 .Times(2)
735 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
736 .WillOnce(Return(EPERM));
737
738 std::vector<BIncrementalData> bundleNames;
739 std::vector<std::string> infos;
740 int32_t result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames, infos);
741 EXPECT_EQ(result, BError(BError::Codes::OK));
742
743 result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames, infos);
744 EXPECT_NE(result, BError(BError::Codes::OK));
745 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101";
746 }
747
748 /**
749 * @tc.number: SUB_Service_proxy_PublishIncrementalFile_0100
750 * @tc.name: SUB_Service_proxy_PublishIncrementalFile_0100
751 * @tc.desc: 测试 PublishIncrementalFile 接口调用成功和失败
752 * @tc.size: MEDIUM
753 * @tc.type: FUNC
754 * @tc.level Level 1
755 * @tc.require: I90ZV5
756 */
757 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishIncrementalFile_0100, testing::ext::TestSize.Level1)
758 {
759 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishIncrementalFile_0100";
760 if (proxy_ == nullptr) {
761 GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishIncrementalFile_0100 proxy_ == nullptr";
762 return;
763 }
764 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
765 .Times(2)
766 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
767 .WillOnce(Return(EPERM));
768
769 string bundleName = "com.example.app2backup";
770 string fileName = "";
771 BFileInfo fileInfo(bundleName, fileName, -1);
772 int32_t result = proxy_->PublishIncrementalFile(fileInfo);
773 EXPECT_EQ(result, BError(BError::Codes::OK));
774 fileName = "test";
775 result = proxy_->PublishIncrementalFile(fileInfo);
776 EXPECT_NE(result, BError(BError::Codes::OK));
777 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishIncrementalFile_0100";
778 }
779
780 /**
781 * @tc.number: SUB_Service_proxy_PublishSAIncrementalFile_0100
782 * @tc.name: SUB_Service_proxy_PublishSAIncrementalFile_0100
783 * @tc.desc: 测试 PublishSAIncrementalFile 接口调用成功和失败
784 * @tc.size: MEDIUM
785 * @tc.type: FUNC
786 * @tc.level Level 1
787 * @tc.require: I90ZV5
788 */
789 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishSAIncrementalFile_0100, testing::ext::TestSize.Level1)
790 {
791 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishSAIncrementalFile_0100";
792 if (proxy_ == nullptr) {
793 GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishSAIncrementalFile_0100 proxy_ == nullptr";
794 return;
795 }
796 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
797 .Times(2)
798 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
799 .WillOnce(Return(EPERM));
800
801 string bundleName = "com.example.app2backup";
802 string fileName = "";
803 BFileInfo fileInfo(bundleName, fileName, -1);
804 TestManager tm("AppIncrementalFileReady_GetFd_0100");
805 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
806 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
807 ErrCode ret = proxy_->PublishSAIncrementalFile(fileInfo, move(fd));
808 EXPECT_EQ(ret, BError(BError::Codes::OK));
809
810 TestManager tmErr("AppIncrementalFileReady_GetFd_0200");
811 UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
812 ret = proxy_->PublishSAIncrementalFile(fileInfo, move(fdErr));
813 EXPECT_NE(ret, BError(BError::Codes::OK));
814 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishSAIncrementalFile_0100";
815 }
816
817 /**
818 * @tc.number: SUB_Service_proxy_PublishSAIncrementalFile_0200
819 * @tc.name: SUB_Service_proxy_PublishSAIncrementalFile_0200
820 * @tc.desc: 测试 PublishSAIncrementalFile 接口调用成功和失败
821 * @tc.size: MEDIUM
822 * @tc.type: FUNC
823 * @tc.level Level 1
824 * @tc.require: I90ZV5
825 */
826 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishSAIncrementalFile_0200, testing::ext::TestSize.Level1)
827 {
828 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishSAIncrementalFile_0200";
829 if (proxy_ == nullptr) {
830 GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishSAIncrementalFile_0200 proxy_ == nullptr";
831 return;
832 }
833
834 string bundleName = "com.example.app2backup";
835 string fileName = "";
836 BFileInfo fileInfo(bundleName, fileName, -1);
837 ErrCode ret = proxy_->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
838 EXPECT_NE(ret, BError(BError::Codes::OK));
839
840 ret = proxy_->PublishSAIncrementalFile(fileInfo, UniqueFd(-1));
841 EXPECT_NE(ret, BError(BError::Codes::OK));
842 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishSAIncrementalFile_0200";
843 }
844
845 /**
846 * @tc.number: SUB_Service_proxy_AppIncrementalFileReady_0100
847 * @tc.name: SUB_Service_proxy_AppIncrementalFileReady_0100
848 * @tc.desc: 测试 AppIncrementalFileReady 接口成功和失败
849 * @tc.size: MEDIUM
850 * @tc.type: FUNC
851 * @tc.level Level 1
852 * @tc.require: I90ZV5
853 */
854 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0100, testing::ext::TestSize.Level1)
855 {
856 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0100";
857 if (proxy_ == nullptr) {
858 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0100 proxy_ == nullptr";
859 return;
860 }
861 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
862 .Times(2)
863 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
864 .WillOnce(Return(EPERM));
865
866 string bundleName = "com.example.app2backup";
867 TestManager tm("AppIncrementalFileReady_GetFd_0100");
868 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
869 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
870 UniqueFd manifestFd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
871
872 int32_t result = proxy_->AppIncrementalFileReady(bundleName, move(fd), move(manifestFd), 0);
873 EXPECT_EQ(result, BError(BError::Codes::OK));
874
875 TestManager tmErr("AppIncrementalFileReady_GetFd_0200");
876 UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
877 UniqueFd manifestFdErr(
878 open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
879 result = proxy_->AppIncrementalFileReady(bundleName, move(fdErr), move(manifestFdErr), 0);
880 EXPECT_NE(result, BError(BError::Codes::OK));
881 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalFileReady_0100";
882 }
883
884 /**
885 * @tc.number: SUB_Service_proxy_AppIncrementalFileReady_0200
886 * @tc.name: SUB_Service_proxy_AppIncrementalFileReady_0200
887 * @tc.desc: 测试 AppIncrementalFileReady 接口成功和失败
888 * @tc.size: MEDIUM
889 * @tc.type: FUNC
890 * @tc.level Level 1
891 * @tc.require: I90ZV5
892 */
893 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0200, testing::ext::TestSize.Level1)
894 {
895 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0200";
896 if (proxy_ == nullptr) {
897 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0200 proxy_ == nullptr";
898 return;
899 }
900 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
901 .Times(2)
902 .WillOnce(Return(0))
903 .WillOnce(Return(0));
904
905 string bundleName = "com.example.app2backup";
906 TestManager tm("AppIncrementalFileReady_0200");
907 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
908 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
909 UniqueFd manifestFd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
910
911 int32_t result = proxy_->AppIncrementalFileReady(bundleName, UniqueFd(-1), move(manifestFd), 0);
912 EXPECT_EQ(result, BError(BError::Codes::OK));
913
914 result = proxy_->AppIncrementalFileReady(bundleName, move(fd), UniqueFd(-1), 0);
915 EXPECT_EQ(result, BError(BError::Codes::OK));
916 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalFileReady_0200";
917 }
918
919 /**
920 * @tc.number: SUB_Service_proxy_AppIncrementalFileReady_0300
921 * @tc.name: SUB_Service_proxy_AppIncrementalFileReady_0300
922 * @tc.desc: 测试 AppIncrementalFileReady 接口成功和失败
923 * @tc.size: MEDIUM
924 * @tc.type: FUNC
925 * @tc.level Level 1
926 * @tc.require: I90ZV5
927 */
928 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0300, testing::ext::TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0300";
931 if (proxy_ == nullptr) {
932 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0300 proxy_ == nullptr";
933 return;
934 }
935 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
936 .Times(2)
937 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
938 .WillOnce(Return(EPERM));
939
940 string bundleName = "com.example.app2backup";
941 int32_t result = proxy_->AppIncrementalFileReady(bundleName, UniqueFd(-1), UniqueFd(-1), 0);
942 EXPECT_EQ(result, BError(BError::Codes::OK));
943
944 result = proxy_->AppIncrementalFileReady(bundleName, UniqueFd(-1), UniqueFd(-1), 0);
945 EXPECT_NE(result, BError(BError::Codes::OK));
946 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalFileReady_0300";
947 }
948
949 /**
950 * @tc.number: SUB_Service_proxy_AppIncrementalDone_0100
951 * @tc.name: SUB_Service_proxy_AppIncrementalDone_0100
952 * @tc.desc: 测试 AppIncrementalDone 接口成功和失败
953 * @tc.size: MEDIUM
954 * @tc.type: FUNC
955 * @tc.level Level 1
956 * @tc.require: I90ZV5
957 */
958 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalDone_0100, testing::ext::TestSize.Level1)
959 {
960 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalDone_0100";
961 if (proxy_ == nullptr) {
962 GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalDone_0100 proxy_ == nullptr";
963 return;
964 }
965 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
966 .Times(2)
967 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
968 .WillOnce(Return(EPERM));
969 int32_t result = proxy_->AppIncrementalDone(BError(BError::Codes::OK));
970 EXPECT_EQ(result, BError(BError::Codes::OK));
971
972 result = proxy_->AppIncrementalDone(BError(BError::Codes::OK));
973 EXPECT_NE(result, BError(BError::Codes::OK));
974 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalDone_0100";
975 }
976
977 /**
978 * @tc.number: SUB_Service_proxy_GetIncrementalFileHandle_0100
979 * @tc.name: SUB_Service_proxy_GetIncrementalFileHandle_0100
980 * @tc.desc: 测试 GetIncrementalFileHandle 接口成功和失败
981 * @tc.size: MEDIUM
982 * @tc.type: FUNC
983 * @tc.level Level 1
984 * @tc.require: I90ZV5
985 */
986 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetIncrementalFileHandle_0100, testing::ext::TestSize.Level1)
987 {
988 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetIncrementalFileHandle_0100";
989 if (proxy_ == nullptr) {
990 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetIncrementalFileHandle_0100 proxy_ == nullptr";
991 return;
992 }
993 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
994 .Times(2)
995 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
996 .WillOnce(Return(EPERM));
997 string bundleName = "com.example.app2backup";
998 string fileName = "1.tar";
999 int32_t result = proxy_->GetIncrementalFileHandle(bundleName, fileName);
1000 EXPECT_EQ(result, BError(BError::Codes::OK));
1001
1002 result = proxy_->GetIncrementalFileHandle(bundleName, fileName);
1003 EXPECT_NE(result, BError(BError::Codes::OK));
1004 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetIncrementalFileHandle_0100";
1005 }
1006
1007 /**
1008 * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100
1009 * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100
1010 * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
1011 * @tc.size: MEDIUM
1012 * @tc.type: FUNC
1013 * @tc.level Level 1
1014 * @tc.require: I6F3GV
1015 */
1016 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100, testing::ext::TestSize.Level1)
1017 {
1018 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100";
1019 if (proxy_ == nullptr) {
1020 GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100 proxy_ == nullptr";
1021 return;
1022 }
1023 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1024 EXPECT_NE(loadCallback, nullptr);
1025 loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, nullptr);
1026 loadCallback = nullptr;
1027 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100";
1028 }
1029
1030 /**
1031 * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101
1032 * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101
1033 * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
1034 * @tc.size: MEDIUM
1035 * @tc.type: FUNC
1036 * @tc.level Level 1
1037 * @tc.require: I6F3GV
1038 */
1039 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101, testing::ext::TestSize.Level1)
1040 {
1041 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101";
1042 if (proxy_ == nullptr) {
1043 GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101 proxy_ == nullptr";
1044 return;
1045 }
1046 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1047 EXPECT_NE(loadCallback, nullptr);
1048 int32_t systemAbilityId = 0;
1049 sptr<MockIRemoteObject> remoteObject = new MockIRemoteObject();
1050 loadCallback->OnLoadSystemAbilitySuccess(systemAbilityId, remoteObject);
1051 loadCallback = nullptr;
1052 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101";
1053 }
1054
1055 /**
1056 * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102
1057 * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102
1058 * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
1059 * @tc.size: MEDIUM
1060 * @tc.type: FUNC
1061 * @tc.level Level 1
1062 * @tc.require: I6F3GV
1063 */
1064 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102, testing::ext::TestSize.Level1)
1065 {
1066 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102";
1067 if (proxy_ == nullptr) {
1068 GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102 proxy_ == nullptr";
1069 return;
1070 }
1071 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1072 EXPECT_NE(loadCallback, nullptr);
1073 int32_t systemAbilityId = 0;
1074 loadCallback->OnLoadSystemAbilitySuccess(systemAbilityId, nullptr);
1075 loadCallback = nullptr;
1076 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102";
1077 }
1078
1079 /**
1080 * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103
1081 * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103
1082 * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
1083 * @tc.size: MEDIUM
1084 * @tc.type: FUNC
1085 * @tc.level Level 1
1086 * @tc.require: I6F3GV
1087 */
1088 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103, testing::ext::TestSize.Level1)
1089 {
1090 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103";
1091 if (proxy_ == nullptr) {
1092 GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103 proxy_ == nullptr";
1093 return;
1094 }
1095 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1096 EXPECT_NE(loadCallback, nullptr);
1097 sptr<MockIRemoteObject> remoteObject = new MockIRemoteObject();
1098 loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, remoteObject);
1099 loadCallback = nullptr;
1100 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0103";
1101 }
1102
1103 /**
1104 * @tc.number: SUB_Service_proxy_OnLoadSystemAbilityFail_0100
1105 * @tc.name: SUB_Service_proxy_OnLoadSystemAbilityFail_0100
1106 * @tc.desc: 测试 OnLoadSystemAbilityFail 接口
1107 * @tc.size: MEDIUM
1108 * @tc.type: FUNC
1109 * @tc.level Level 1
1110 * @tc.require: I6F3GV
1111 */
1112 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilityFail_0100, testing::ext::TestSize.Level1)
1113 {
1114 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilityFail_0100";
1115 if (proxy_ == nullptr) {
1116 GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilityFail_0100 proxy_ == nullptr";
1117 return;
1118 }
1119 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1120 EXPECT_NE(loadCallback, nullptr);
1121 loadCallback->OnLoadSystemAbilityFail(SERVICE_ID);
1122 loadCallback = nullptr;
1123 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilityFail_0100";
1124 }
1125
1126 /**
1127 * @tc.number: SUB_Service_proxy_GetInstance_0100
1128 * @tc.name: SUB_Service_proxy_GetInstance_0100
1129 * @tc.desc: 测试 GetInstance 接口
1130 * @tc.size: MEDIUM
1131 * @tc.type: FUNC
1132 * @tc.level Level 1
1133 * @tc.require: I6F3GV
1134 */
1135 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetInstance_0100, testing::ext::TestSize.Level1)
1136 {
1137 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetInstance_0100";
1138 if (proxy_ == nullptr) {
1139 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetInstance_0100 proxy_ == nullptr";
1140 return;
1141 }
1142 GTEST_LOG_(INFO) << "MockLoadSystemAbility is false";
1143 SetMockLoadSystemAbility(false);
1144 auto proxy = ServiceProxy::GetInstance();
1145 EXPECT_EQ(proxy, nullptr);
1146 GTEST_LOG_(INFO) << "MockLoadSystemAbility is true";
1147 SetMockLoadSystemAbility(true);
1148 proxy = ServiceProxy::GetInstance();
1149 EXPECT_EQ(proxy, nullptr);
1150 sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
1151 sptr<IRemoteObject> object = new MockIRemoteObject();
1152 loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, object);
1153 GTEST_LOG_(INFO) << "GetInstance is ok";
1154 proxy = ServiceProxy::GetInstance();
1155 EXPECT_NE(proxy, nullptr);
1156 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetInstance_0100";
1157 }
1158
1159 /**
1160 * @tc.number: SUB_Service_proxy_InvaildInstance_0100
1161 * @tc.name: SUB_Service_proxy_InvaildInstance_0100
1162 * @tc.desc: 测试 InvaildInstance 接口
1163 * @tc.size: MEDIUM
1164 * @tc.type: FUNC
1165 * @tc.level Level 1
1166 * @tc.require: I6F3GV
1167 */
1168 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InvaildInstance_0100, testing::ext::TestSize.Level1)
1169 {
1170 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InvaildInstance_0100";
1171 if (proxy_ == nullptr) {
1172 GTEST_LOG_(INFO) << "SUB_Service_proxy_InvaildInstance_0100 proxy_ == nullptr";
1173 return;
1174 }
1175 ServiceProxy::InvaildInstance();
1176 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InvaildInstance_0100";
1177 }
1178
1179 /**
1180 * @tc.number: SUB_Service_proxy_GetBackupInfo_0100
1181 * @tc.name: SUB_Service_proxy_GetBackupInfo_0100
1182 * @tc.desc: 测试 GetBackupInfo 获取应用信息接口调用成功和失败
1183 * @tc.size: MEDIUM
1184 * @tc.type: FUNC
1185 * @tc.level Level 1
1186 * @tc.require: I6F3GV
1187 */
1188 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupInfo_0100, testing::ext::TestSize.Level1)
1189 {
1190 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupInfo_0100";
1191 if (proxy_ == nullptr) {
1192 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupInfo_0100 proxy_ == nullptr";
1193 return;
1194 }
1195 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1196 .Times(1)
1197 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1198 std::string result;
1199 std::string bundleName = "com.example.app2backup";
1200 int32_t ret = proxy_->GetBackupInfo(bundleName, result);
1201 EXPECT_EQ(ret, BError(BError::Codes::OK));
1202 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetBackupInfo_0100";
1203 }
1204
1205 /**
1206 * @tc.number: SUB_Service_proxy_UpdateTimer_0100
1207 * @tc.name: SUB_Service_proxy_UpdateTimer_0100
1208 * @tc.desc: 测试 UpdateTimer 获取应用信息接口调用成功和失败
1209 * @tc.size: MEDIUM
1210 * @tc.type: FUNC
1211 * @tc.level Level 1
1212 * @tc.require: I6F3GV
1213 */
1214 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateTimer_0100, testing::ext::TestSize.Level1)
1215 {
1216 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateTimer_0100";
1217 if (proxy_ == nullptr) {
1218 GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateTimer_0100 proxy_ == nullptr";
1219 return;
1220 }
1221 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1222 .Times(1)
1223 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1224 bool result;
1225 std::string bundleName = "com.example.app2backup";
1226 uint32_t timeout = 30000;
1227 int32_t ret = proxy_->UpdateTimer(bundleName, timeout, result);
1228 EXPECT_EQ(ret, BError(BError::Codes::OK));
1229 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_UpdateTimer_0100";
1230 }
1231
1232 /**
1233 * @tc.number: SUB_Service_proxy_UpdateSendRate_0100
1234 * @tc.name: SUB_Service_proxy_UpdateSendRate_0100
1235 * @tc.desc: 测试 UpdateSendRate 获取应用信息接口调用成功和失败
1236 * @tc.size: MEDIUM
1237 * @tc.type: FUNC
1238 * @tc.level Level 1
1239 * @tc.require: I6F3GV
1240 */
1241 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateSendRate_0100, testing::ext::TestSize.Level1)
1242 {
1243 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateSendRate_0100";
1244 if (proxy_ == nullptr) {
1245 GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateSendRate_0100 proxy_ == nullptr";
1246 return;
1247 }
1248 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1249 .Times(1)
1250 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1251 bool result;
1252 std::string bundleName = "com.example.app2backup";
1253 int32_t sendRate = 300;
1254 int32_t ret = proxy_->UpdateSendRate(bundleName, sendRate, result);
1255 EXPECT_EQ(ret, BError(BError::Codes::OK));
1256 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_UpdateSendRate_0100";
1257 }
1258
1259 /**
1260 * @tc.number: SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100
1261 * @tc.name: SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100
1262 * @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 执行DoBackup的接口成功和失败
1263 * @tc.size: MEDIUM
1264 * @tc.type: FUNC
1265 * @tc.level Level 1
1266 * @tc.require: I90ZV5
1267 */
1268 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100, testing::ext::TestSize.Level1)
1269 {
1270 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100";
1271 if (proxy_ == nullptr) {
1272 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100 proxy_ == nullptr";
1273 return;
1274 }
1275 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1276 .Times(2)
1277 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1278 .WillOnce(Return(EPERM));
1279 int32_t ret = proxy_->GetAppLocalListAndDoIncrementalBackup();
1280 EXPECT_EQ(ret, BError(BError::Codes::OK));
1281 ret = proxy_->GetAppLocalListAndDoIncrementalBackup();
1282 EXPECT_NE(ret, BError(BError::Codes::OK));
1283 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100";
1284 }
1285
1286 /**
1287 * @tc.number: SUB_Service_proxy_ReportAppProcessInfo_0100
1288 * @tc.name: SUB_Service_proxy_ReportAppProcessInfo_0100
1289 * @tc.desc: 测试 ReportAppProcessInfo 接口成功
1290 * @tc.size: MEDIUM
1291 * @tc.type: FUNC
1292 * @tc.level Level 1
1293 * @tc.require: I90ZV5
1294 */
1295 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_ReportAppProcessInfo_0100, testing::ext::TestSize.Level1)
1296 {
1297 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_ReportAppProcessInfo_0100";
1298 if (proxy_ == nullptr) {
1299 GTEST_LOG_(INFO) << "SUB_Service_proxy_ReportAppProcessInfo_0100 proxy_ == nullptr";
1300 return;
1301 }
1302 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1303 .Times(4)
1304 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1305 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1306 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1307 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1308 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
1309 int32_t result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_RESTORE);
1310 EXPECT_EQ(result, BError(BError::Codes::OK));
1311
1312 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_RESTORE);
1313 EXPECT_EQ(result, BError(BError::Codes::OK));
1314
1315 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_BACKUP);
1316 EXPECT_EQ(result, BError(BError::Codes::OK));
1317
1318 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_BACKUP);
1319 EXPECT_EQ(result, BError(BError::Codes::OK));
1320 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_ReportAppProcessInfo_0100";
1321 }
1322
1323 /**
1324 * @tc.number: SUB_Service_proxy_ReportAppProcessInfo_0101
1325 * @tc.name: SUB_Service_proxy_ReportAppProcessInfo_0101
1326 * @tc.desc: 测试 ReportAppProcessInfo 接口失败
1327 * @tc.size: MEDIUM
1328 * @tc.type: FUNC
1329 * @tc.level Level 1
1330 * @tc.require: I90ZV5
1331 */
1332 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_ReportAppProcessInfo_0101, testing::ext::TestSize.Level1)
1333 {
1334 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_ReportAppProcessInfo_0101";
1335 if (proxy_ == nullptr) {
1336 GTEST_LOG_(INFO) << "SUB_Service_proxy_ReportAppProcessInfo_0101 proxy_ == nullptr";
1337 return;
1338 }
1339 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1340 .Times(4)
1341 .WillOnce(Return(EPERM))
1342 .WillOnce(Return(EPERM))
1343 .WillOnce(Return(EPERM))
1344 .WillOnce(Return(EPERM));
1345 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
1346 int32_t result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_RESTORE);
1347 EXPECT_NE(result, BError(BError::Codes::OK));
1348
1349 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_RESTORE);
1350 EXPECT_NE(result, BError(BError::Codes::OK));
1351
1352 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_BACKUP);
1353 EXPECT_NE(result, BError(BError::Codes::OK));
1354
1355 result = proxy_->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_BACKUP);
1356 EXPECT_NE(result, BError(BError::Codes::OK));
1357 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_ReportAppProcessInfo_0101";
1358 }
1359
1360 /**
1361 * @tc.number: SUB_Service_proxy_StartExtTimer_0100
1362 * @tc.name: SUB_Service_proxy_StartExtTimer_0100
1363 * @tc.desc: 测试 StartExtTimer 执行DoBackup的接口成功和失败
1364 * @tc.size: MEDIUM
1365 * @tc.type: FUNC
1366 * @tc.level Level 1
1367 * @tc.require: I90ZV5
1368 */
1369 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_StartExtTimer_0100, testing::ext::TestSize.Level1)
1370 {
1371 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_StartExtTimer_0100";
1372 if (proxy_ == nullptr) {
1373 GTEST_LOG_(INFO) << "SUB_Service_proxy_StartExtTimer_0100 proxy_ == nullptr";
1374 return;
1375 }
1376 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1377 .Times(2)
1378 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1379 .WillOnce(Return(EPERM));
1380 bool isExtStart;
1381 int32_t ret = proxy_->StartExtTimer(isExtStart);
1382 EXPECT_EQ(ret, BError(BError::Codes::OK));
1383 ret = proxy_->StartExtTimer(isExtStart);
1384 EXPECT_NE(ret, BError(BError::Codes::OK));
1385 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_StartExtTimer_0100";
1386 }
1387
1388 /**
1389 * @tc.number: SUB_Service_proxy_StartFwkTimer_0100
1390 * @tc.name: SUB_Service_proxy_StartFwkTimer_0100
1391 * @tc.desc: 测试 StartFwkTimer 执行DoBackup的接口成功和失败
1392 * @tc.size: MEDIUM
1393 * @tc.type: FUNC
1394 * @tc.level Level 1
1395 * @tc.require: I90ZV5
1396 */
1397 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_StartFwkTimer_0100, testing::ext::TestSize.Level1)
1398 {
1399 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_StartFwkTimer_0100";
1400 if (proxy_ == nullptr) {
1401 GTEST_LOG_(INFO) << "SUB_Service_proxy_StartFwkTimer_0100 proxy_ == nullptr";
1402 return;
1403 }
1404 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1405 .Times(2)
1406 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1407 .WillOnce(Return(EPERM));
1408 bool isFwkStart;
1409 int32_t ret = proxy_->StartFwkTimer(isFwkStart);
1410 EXPECT_EQ(ret, BError(BError::Codes::OK));
1411 ret = proxy_->StartFwkTimer(isFwkStart);
1412 EXPECT_NE(ret, BError(BError::Codes::OK));
1413 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_StartFwkTimer_0100";
1414 }
1415
1416 /**
1417 * @tc.number: SUB_Service_proxy_Cancel_0100
1418 * @tc.name: SUB_Service_proxy_Cancel_0100
1419 * @tc.desc: 测试 Cancel 调用成功和失败
1420 * @tc.size: MEDIUM
1421 * @tc.type: FUNC
1422 * @tc.level Level 1
1423 * @tc.require: I90ZV5
1424 */
1425 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Cancel_0100, testing::ext::TestSize.Level1)
1426 {
1427 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Cancel_0100";
1428 if (proxy_ == nullptr) {
1429 GTEST_LOG_(INFO) << "SUB_Service_proxy_Cancel_0100 proxy_ == nullptr";
1430 return;
1431 }
1432 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1433 .Times(2)
1434 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1435 .WillOnce(Return(EPERM));
1436 std::string bundleName;
1437 int result;
1438 ErrCode ret = proxy_->Cancel(bundleName, result);
1439 EXPECT_EQ(ret, BError(BError::Codes::OK));
1440 ret = proxy_->Cancel(bundleName, result);
1441 EXPECT_NE(ret, BError(BError::Codes::OK));
1442 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Cancel_0100";
1443 }
1444
1445 /**
1446 * @tc.number: SUB_Service_proxy_RefreshDataSize_0100
1447 * @tc.name: SUB_Service_proxy_RefreshDataSize_0100
1448 * @tc.desc: 测试 RefreshDataSize 调用成功和失败
1449 * @tc.size: MEDIUM
1450 * @tc.type: FUNC
1451 * @tc.level Level 1
1452 * @tc.require: I90ZV5
1453 */
1454 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_RefreshDataSize_0100, testing::ext::TestSize.Level1)
1455 {
1456 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_RefreshDataSize_0100";
1457 if (proxy_ == nullptr) {
1458 GTEST_LOG_(INFO) << "SUB_Service_proxy_RefreshDataSize_0100 proxy_ == nullptr";
1459 return;
1460 }
1461 int64_t totalSize = 0;
1462 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
1463 ErrCode ret = proxy_->RefreshDataSize(totalSize);
1464 EXPECT_EQ(ret, BError(BError::Codes::SDK_INVAL_ARG));
1465
1466 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
1467 ret = proxy_->RefreshDataSize(totalSize);
1468 EXPECT_EQ(ret, BError(BError::Codes::SDK_INVAL_ARG));
1469 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_RefreshDataSize_0100";
1470 }
1471
1472 /**
1473 * @tc.number: SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100
1474 * @tc.name: SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100
1475 * @tc.desc: 测试 GetLocalCapabilitiesForBundleInfos 调用成功和失败
1476 * @tc.size: MEDIUM
1477 * @tc.type: FUNC
1478 * @tc.level Level 1
1479 * @tc.require: I90ZV5
1480 */
1481 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100, testing::ext::TestSize.Level1)
1482 {
1483 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100";
1484 if (proxy_ == nullptr) {
1485 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100 proxy_ == nullptr";
1486 return;
1487 }
1488 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1489 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1490 .WillOnce(Return(EPERM));
1491 ErrCode ret = proxy_->GetLocalCapabilitiesForBundleInfos();
1492 EXPECT_NE(ret, BError(BError::Codes::OK));
1493 ret = proxy_->GetLocalCapabilitiesForBundleInfos();
1494 EXPECT_NE(ret, BError(BError::Codes::OK));
1495 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100";
1496 }
1497
1498 /**
1499 * @tc.number: SUB_Service_proxy_GetBackupDataSize_0100
1500 * @tc.name: SUB_Service_proxy_GetBackupDataSize_0100
1501 * @tc.desc: 测试 GetBackupDataSize 调用成功和失败
1502 * @tc.size: MEDIUM
1503 * @tc.type: FUNC
1504 * @tc.level Level 1
1505 * @tc.require: I90ZV5
1506 */
1507 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupDataSize_0100, testing::ext::TestSize.Level1)
1508 {
1509 GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupDataSize_0100";
1510 if (proxy_ == nullptr) {
1511 GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupDataSize_0100 proxy_ == nullptr";
1512 return;
1513 }
1514 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1515 .Times(2)
1516 .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1517 .WillOnce(Return(EPERM));
1518 bool isPreciseScan = true;
1519 vector<BIncrementalData> bundleNameList;
1520 ErrCode ret = proxy_->GetBackupDataSize(isPreciseScan, bundleNameList);
1521 EXPECT_EQ(ret, BError(BError::Codes::OK));
1522 ret = proxy_->GetBackupDataSize(isPreciseScan, bundleNameList);
1523 EXPECT_NE(ret, BError(BError::Codes::OK));
1524 GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetBackupDataSize_0100";
1525 }
1526 } // namespace OHOS::FileManagement::Backup