• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-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 <cstdio>
17 #include <fcntl.h>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include <message_parcel.h>
21 #include <string_ex.h>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24 
25 #include "b_error/b_error.h"
26 #include "i_service_reverse.h"
27 #include "service_reverse_stub.h"
28 #include "test_manager.h"
29 #include "unique_fd.h"
30 
31 namespace OHOS::FileManagement::Backup {
32 using namespace std;
33 using namespace testing;
34 
35 namespace {
36 const string BUNDLE_NAME = "com.example.app2backup";
37 const string FILE_NAME = "1.tar";
38 } // namespace
39 
40 class MockServiceReverse final : public ServiceReverseStub {
41 public:
42     MOCK_METHOD3(BackupOnFileReady, void(string bundleName, string fileName, int fd));
43     MOCK_METHOD2(BackupOnBundleStarted, void(int32_t errCode, string bundleName));
44     MOCK_METHOD2(BackupOnBundleFinished, void(int32_t errCode, string bundleName));
45     MOCK_METHOD1(BackupOnAllBundlesFinished, void(int32_t errCode));
46     MOCK_METHOD2(RestoreOnBundleStarted, void(int32_t errCode, std::string bundleName));
47     MOCK_METHOD2(RestoreOnBundleFinished, void(int32_t errCode, string bundleName));
48     MOCK_METHOD1(RestoreOnAllBundlesFinished, void(int32_t errCode));
49     MOCK_METHOD3(RestoreOnFileReady, void(string bundleName, string fileName, int fd));
50 };
51 
52 class ServiceReverseStubTest : public testing::Test {
53 public:
SetUpTestCase(void)54     static void SetUpTestCase(void) {};
TearDownTestCase()55     static void TearDownTestCase() {};
SetUp()56     void SetUp() override {};
TearDown()57     void TearDown() override {};
58 };
59 
60 /**
61  * @tc.number: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100
62  * @tc.name: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100
63  * @tc.desc: Test function of BackupOnFileReady interface for SUCCESS.
64  * @tc.size: MEDIUM
65  * @tc.type: FUNC
66  * @tc.level Level 1
67  * @tc.require: I6F3GV
68  */
69 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_BackupOnFileReady_0100, testing::ext::TestSize.Level1)
70 {
71     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnFileReady_0100";
72     try {
73         MockServiceReverse service;
74         EXPECT_CALL(service, BackupOnFileReady(_, _, _)).WillOnce(Return());
75         MessageParcel data;
76         MessageParcel reply;
77         MessageOption option;
78 
79         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
80         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
81         EXPECT_TRUE(data.WriteString(FILE_NAME));
82         TestManager tm("ServiceReverseStub_0100");
83         string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
84         UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
85         data.WriteFileDescriptor(fd);
86 
87         EXPECT_EQ(
88             BError(BError::Codes::OK),
89             service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY),
90                                     data, reply, option));
91     } catch (...) {
92         EXPECT_TRUE(false);
93         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnFileReady.";
94     }
95     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnFileReady_0100";
96 }
97 
98 /**
99  * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100
100  * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100
101  * @tc.desc: Test function of BackupOnBundleStarted interface for SUCCESS.
102  * @tc.size: MEDIUM
103  * @tc.type: FUNC
104  * @tc.level Level 1
105  * @tc.require: I6F3GV
106  */
107 HWTEST_F(ServiceReverseStubTest,
108          SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100,
109          testing::ext::TestSize.Level1)
110 {
111     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100";
112     try {
113         MockServiceReverse service;
114         EXPECT_CALL(service, BackupOnBundleStarted(_, _)).WillOnce(Return());
115         MessageParcel data;
116         MessageParcel reply;
117         MessageOption option;
118 
119         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
120         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
121         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
122 
123         EXPECT_EQ(BError(BError::Codes::OK),
124                   service.OnRemoteRequest(
125                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED), data,
126                       reply, option));
127     } catch (...) {
128         EXPECT_TRUE(false);
129         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleStarted.";
130     }
131     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100";
132 }
133 
134 /**
135  * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100
136  * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100
137  * @tc.desc: Test function of BackupOnBundleFinished interface for SUCCESS.
138  * @tc.size: MEDIUM
139  * @tc.type: FUNC
140  * @tc.level Level 1
141  * @tc.require: I6F3GV
142  */
143 HWTEST_F(ServiceReverseStubTest,
144          SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100,
145          testing::ext::TestSize.Level1)
146 {
147     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100";
148     try {
149         MockServiceReverse service;
150         EXPECT_CALL(service, BackupOnBundleFinished(_, _)).WillOnce(Return());
151         MessageParcel data;
152         MessageParcel reply;
153         MessageOption option;
154 
155         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
156         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
157         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
158 
159         EXPECT_EQ(BError(BError::Codes::OK),
160                   service.OnRemoteRequest(
161                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED), data,
162                       reply, option));
163     } catch (...) {
164         EXPECT_TRUE(false);
165         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleFinished.";
166     }
167     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100";
168 }
169 
170 /**
171  * @tc.number: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100
172  * @tc.name: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100
173  * @tc.desc: Test function of BackupOnAllBundlesFinished interface for SUCCESS.
174  * @tc.size: MEDIUM
175  * @tc.type: FUNC
176  * @tc.level Level 1
177  * @tc.require: I6F3GV
178  */
179 HWTEST_F(ServiceReverseStubTest,
180          SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100,
181          testing::ext::TestSize.Level1)
182 {
183     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100";
184     try {
185         MockServiceReverse service;
186         EXPECT_CALL(service, BackupOnAllBundlesFinished(_)).WillOnce(Return());
187         MessageParcel data;
188         MessageParcel reply;
189         MessageOption option;
190 
191         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
192         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
193 
194         EXPECT_EQ(BError(BError::Codes::OK),
195                   service.OnRemoteRequest(
196                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED), data,
197                       reply, option));
198     } catch (...) {
199         EXPECT_TRUE(false);
200         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnAllBundlesFinished.";
201     }
202     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100";
203 }
204 
205 /**
206  * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100
207  * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100
208  * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS.
209  * @tc.size: MEDIUM
210  * @tc.type: FUNC
211  * @tc.level Level 1
212  * @tc.require: I6F3GV
213  */
214 HWTEST_F(ServiceReverseStubTest,
215          SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100,
216          testing::ext::TestSize.Level1)
217 {
218     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100";
219     try {
220         MockServiceReverse service;
221         EXPECT_CALL(service, RestoreOnBundleStarted(_, _)).WillOnce(Return());
222         MessageParcel data;
223         MessageParcel reply;
224         MessageOption option;
225 
226         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
227         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
228         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
229 
230         EXPECT_EQ(BError(BError::Codes::OK),
231                   service.OnRemoteRequest(
232                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED), data,
233                       reply, option));
234     } catch (...) {
235         EXPECT_TRUE(false);
236         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleStarted.";
237     }
238     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100";
239 }
240 
241 /**
242  * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100
243  * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100
244  * @tc.desc: Test function of RestoreOnBundleFinished interface for SUCCESS.
245  * @tc.size: MEDIUM
246  * @tc.type: FUNC
247  * @tc.level Level 1
248  * @tc.require: I6F3GV
249  */
250 HWTEST_F(ServiceReverseStubTest,
251          SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100,
252          testing::ext::TestSize.Level1)
253 {
254     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100";
255     try {
256         MockServiceReverse service;
257         EXPECT_CALL(service, RestoreOnBundleFinished(_, _)).WillOnce(Return());
258         MessageParcel data;
259         MessageParcel reply;
260         MessageOption option;
261 
262         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
263         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
264         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
265 
266         EXPECT_EQ(BError(BError::Codes::OK),
267                   service.OnRemoteRequest(
268                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED), data,
269                       reply, option));
270     } catch (...) {
271         EXPECT_TRUE(false);
272         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleFinished.";
273     }
274     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100";
275 }
276 
277 /**
278  * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100
279  * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100
280  * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS.
281  * @tc.size: MEDIUM
282  * @tc.type: FUNC
283  * @tc.level Level 1
284  * @tc.require: I6F3GV
285  */
286 HWTEST_F(ServiceReverseStubTest,
287          SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100,
288          testing::ext::TestSize.Level1)
289 {
290     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100";
291     try {
292         MockServiceReverse service;
293         EXPECT_CALL(service, RestoreOnAllBundlesFinished(_)).WillOnce(Return());
294         MessageParcel data;
295         MessageParcel reply;
296         MessageOption option;
297 
298         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
299         EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK)));
300 
301         EXPECT_EQ(BError(BError::Codes::OK),
302                   service.OnRemoteRequest(
303                       static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED), data,
304                       reply, option));
305     } catch (...) {
306         EXPECT_TRUE(false);
307         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnAllBundlesFinished.";
308     }
309     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100";
310 }
311 
312 /**
313  * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100
314  * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100
315  * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS.
316  * @tc.size: MEDIUM
317  * @tc.type: FUNC
318  * @tc.level Level 1
319  * @tc.require: I6F3GV
320  */
321 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100, testing::ext::TestSize.Level1)
322 {
323     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100";
324     try {
325         MockServiceReverse service;
326         EXPECT_CALL(service, RestoreOnFileReady(_, _, _)).WillOnce(Return());
327         MessageParcel data;
328         MessageParcel reply;
329         MessageOption option;
330 
331         EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
332         EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
333         EXPECT_TRUE(data.WriteString(FILE_NAME));
334 
335         TestManager tm("ServiceReverseStub_0200");
336         string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
337         UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
338         data.WriteFileDescriptor(fd);
339 
340         EXPECT_EQ(
341             BError(BError::Codes::OK),
342             service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY),
343                                     data, reply, option));
344     } catch (...) {
345         EXPECT_TRUE(false);
346         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnFileReady.";
347     }
348     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100";
349 }
350 
351 /**
352  * @tc.number: SUB_backup_ServiceReverseStub_error_0100
353  * @tc.name: SUB_backup_ServiceReverseStub_error_0100
354  * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS.
355  * @tc.size: MEDIUM
356  * @tc.type: FUNC
357  * @tc.level Level 1
358  * @tc.require: I6F3GV
359  */
360 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_error_0100, testing::ext::TestSize.Level1)
361 {
362     GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_error_0100";
363     try {
364         MockServiceReverse service;
365         MessageParcel data;
366         MessageParcel reply;
367         MessageOption option;
368         EXPECT_TRUE(data.WriteInterfaceToken(Str8ToStr16("test")));
369 
370         EXPECT_NE(BError(BError::Codes::OK), service.OnRemoteRequest(3333, data, reply, option));
371         EXPECT_NE(
372             BError(BError::Codes::OK),
373             service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY),
374                                     data, reply, option));
375     } catch (...) {
376         EXPECT_TRUE(false);
377         GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred.";
378     }
379     GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_error_0100";
380 }
381 } // namespace OHOS::FileManagement::Backup