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 <cstddef>
17 #include <cstdio>
18 #include <fcntl.h>
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <message_parcel.h>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24
25 #include "b_error/b_error.h"
26 #include "b_session_restore.h"
27 #include "refbase.h"
28 #include "service_reverse.h"
29 #include "test_manager.h"
30 #include "unique_fd.h"
31
32 namespace OHOS::FileManagement::Backup {
33 using namespace std;
34 using namespace testing;
35
36 namespace {
37 const string BUNDLE_NAME = "com.example.app2backup";
38 const string FILE_NAME = "1.tar";
39 } // namespace
40
41 class ServiceReverseTest : public testing::Test {
42 public:
SetUpTestCase(void)43 static void SetUpTestCase(void) {};
TearDownTestCase()44 static void TearDownTestCase() {};
SetUp()45 void SetUp() override {};
46 void TearDown() override;
47
48 void Init(IServiceReverse::Scenario scenario, int nType = 0);
49 sptr<ServiceReverse> service_ = nullptr;
50 };
51
OnFileReadyTest(const BFileInfo & fileInfo,UniqueFd fd)52 static void OnFileReadyTest(const BFileInfo &fileInfo, UniqueFd fd)
53 {
54 EXPECT_EQ(fileInfo.owner, BUNDLE_NAME);
55 EXPECT_EQ(fileInfo.fileName, FILE_NAME);
56 GTEST_LOG_(INFO) << "ServiceReverseTest-OnFileReadyTest SUCCESS";
57 }
58
OnBundleStartedTest(ErrCode err,const BundleName name)59 static void OnBundleStartedTest(ErrCode err, const BundleName name)
60 {
61 EXPECT_EQ(name, BUNDLE_NAME);
62 GTEST_LOG_(INFO) << "ServiceReverseTest-OnBundleStartedTest SUCCESS";
63 }
64
OnBundleFinishedTest(ErrCode err,const BundleName name)65 static void OnBundleFinishedTest(ErrCode err, const BundleName name)
66 {
67 EXPECT_EQ(name, BUNDLE_NAME);
68 GTEST_LOG_(INFO) << "ServiceReverseTest-OnBundleFinishedTest SUCCESS";
69 }
70
OnAllBundlesFinishedTest(ErrCode err)71 static void OnAllBundlesFinishedTest(ErrCode err)
72 {
73 EXPECT_EQ(err, BError(BError::Codes::OK));
74 GTEST_LOG_(INFO) << "ServiceReverseTest-OnAllBundlesFinishedTest SUCCESS";
75 }
76
OnBackupServiceDiedTest()77 static void OnBackupServiceDiedTest() {}
78
TearDown()79 void ServiceReverseTest::TearDown()
80 {
81 service_ = nullptr;
82 }
83
Init(IServiceReverse::Scenario scenario,int nType)84 void ServiceReverseTest::Init(IServiceReverse::Scenario scenario, int nType)
85 {
86 if (scenario == IServiceReverse::Scenario::BACKUP) {
87 if (nType) {
88 service_ = new ServiceReverse(BSessionBackup::Callbacks {.onFileReady = nullptr,
89 .onBundleStarted = nullptr,
90 .onBundleFinished = nullptr,
91 .onAllBundlesFinished = nullptr,
92 .onBackupServiceDied = nullptr});
93 } else {
94 service_ = new ServiceReverse(BSessionBackup::Callbacks {
95 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
96 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
97 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
98 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
99 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
100 }
101 } else {
102 if (nType) {
103 service_ = new ServiceReverse(BSessionRestore::Callbacks {.onFileReady = nullptr,
104 .onBundleStarted = nullptr,
105 .onBundleFinished = nullptr,
106 .onAllBundlesFinished = nullptr,
107 .onBackupServiceDied = nullptr});
108 } else {
109 service_ = new ServiceReverse(BSessionRestore::Callbacks {
110 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
111 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
112 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
113 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
114 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
115 }
116 }
117 }
118
119 /**
120 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReady_0100
121 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReady_0100
122 * @tc.desc: 测试 BackupOnFileReady 接口
123 * @tc.size: MEDIUM
124 * @tc.type: FUNC
125 * @tc.level Level 1
126 * @tc.require: I6F3GV
127 */
128 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0100, testing::ext::TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0100";
131 try {
132 Init(IServiceReverse::Scenario::BACKUP);
133 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
134 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
135 } catch (...) {
136 EXPECT_TRUE(false);
137 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnFileReady.";
138 }
139 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReady_0100";
140 }
141
142 /**
143 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
144 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
145 * @tc.desc: 测试 BackupOnBundleStarted 接口
146 * @tc.size: MEDIUM
147 * @tc.type: FUNC
148 * @tc.level Level 1
149 * @tc.require: I6F3GV
150 */
151 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0100, testing::ext::TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
154 try {
155 Init(IServiceReverse::Scenario::BACKUP);
156 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
157 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
158 } catch (...) {
159 EXPECT_TRUE(false);
160 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
161 }
162 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
163 }
164
165 /**
166 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
167 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
168 * @tc.desc: 测试 BackupOnBundleFinished 接口
169 * @tc.size: MEDIUM
170 * @tc.type: FUNC
171 * @tc.level Level 1
172 * @tc.require: I6F3GV
173 */
174 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0100, testing::ext::TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
177 try {
178 Init(IServiceReverse::Scenario::BACKUP);
179 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
180 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
181 } catch (...) {
182 EXPECT_TRUE(false);
183 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
184 }
185 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
186 }
187
188 /**
189 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
190 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
191 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
192 * @tc.size: MEDIUM
193 * @tc.type: FUNC
194 * @tc.level Level 1
195 * @tc.require: I6F3GV
196 */
197 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
200 try {
201 Init(IServiceReverse::Scenario::BACKUP);
202 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
203 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
204 } catch (...) {
205 EXPECT_TRUE(false);
206 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
207 }
208 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
209 }
210
211 /**
212 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
213 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
214 * @tc.desc: 测试 RestoreOnFileReady 接口
215 * @tc.size: MEDIUM
216 * @tc.type: FUNC
217 * @tc.level Level 1
218 * @tc.require: I6F3GV
219 */
220 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0100, testing::ext::TestSize.Level1)
221 {
222 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
223 try {
224 Init(IServiceReverse::Scenario::RESTORE);
225 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
226 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
227 } catch (...) {
228 EXPECT_TRUE(false);
229 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
230 }
231 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
232 }
233
234 /**
235 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
236 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
237 * @tc.desc: 测试 RestoreOnBundleStarted 接口
238 * @tc.size: MEDIUM
239 * @tc.type: FUNC
240 * @tc.level Level 1
241 * @tc.require: I6F3GV
242 */
243 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100, testing::ext::TestSize.Level1)
244 {
245 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
246 try {
247 Init(IServiceReverse::Scenario::RESTORE);
248 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
249 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
250 } catch (...) {
251 EXPECT_TRUE(false);
252 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
253 }
254 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
255 }
256
257 /**
258 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
259 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
260 * @tc.desc: 测试 RestoreOnBundleFinished 接口
261 * @tc.size: MEDIUM
262 * @tc.type: FUNC
263 * @tc.level Level 1
264 * @tc.require: I6F3GV
265 */
266 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100, testing::ext::TestSize.Level1)
267 {
268 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
269 try {
270 Init(IServiceReverse::Scenario::RESTORE);
271 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
272 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
273 } catch (...) {
274 EXPECT_TRUE(false);
275 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
276 }
277 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
278 }
279
280 /**
281 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
282 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
283 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
284 * @tc.size: MEDIUM
285 * @tc.type: FUNC
286 * @tc.level Level 1
287 * @tc.require: I6F3GV
288 */
289 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
290 {
291 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
292 try {
293 Init(IServiceReverse::Scenario::RESTORE);
294 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
295 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
296 } catch (...) {
297 EXPECT_TRUE(false);
298 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
299 }
300 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
301 }
302
303 /**
304 * @tc.number: SUB_backup_ServiceReverse_0200
305 * @tc.name: SUB_backup_ServiceReverse_0200
306 * @tc.desc: 测试分支
307 * @tc.size: MEDIUM
308 * @tc.type: FUNC
309 * @tc.level Level 1
310 * @tc.require: I6F3GV
311 */
312 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0200, testing::ext::TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200";
315 try {
316 Init(IServiceReverse::Scenario::RESTORE, 1);
317 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
318 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
319 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
320 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
321 } catch (...) {
322 EXPECT_TRUE(false);
323 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
324 }
325 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0200";
326 }
327
328 /**
329 * @tc.number: SUB_backup_ServiceReverse_0300
330 * @tc.name: SUB_backup_ServiceReverse_0300
331 * @tc.desc: 测试分支
332 * @tc.size: MEDIUM
333 * @tc.type: FUNC
334 * @tc.level Level 1
335 * @tc.require: I6F3GV
336 */
337 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestSize.Level1)
338 {
339 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300";
340 try {
341 Init(IServiceReverse::Scenario::BACKUP, 1);
342 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1);
343 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
344 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
345 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
346 } catch (...) {
347 EXPECT_TRUE(false);
348 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
349 }
350 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0300";
351 }
352 } // namespace OHOS::FileManagement::Backup