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 <gtest/gtest.h>
17 
18 #include "b_error/b_error.h"
19 #include "b_file_info.h"
20 #include "backup_kit_inner.h"
21 #include "unique_fd.h"
22 #include "utils_mock_global_variable.h"
23 
24 namespace OHOS::FileManagement::Backup {
25 using namespace std;
26 
OnFileReady(const BFileInfo & fileInfo,UniqueFd fd,ErrCode errCode)27 static void OnFileReady(const BFileInfo &fileInfo, UniqueFd fd, ErrCode errCode)
28 {
29     GTEST_LOG_(INFO) << "BSessionBackupTest OnFileReady OK";
30 }
31 
OnBundleStarted(ErrCode err,const BundleName name)32 static void OnBundleStarted(ErrCode err, const BundleName name)
33 {
34     GTEST_LOG_(INFO) << "BSessionBackupTest OnBundleStarted OK";
35 }
36 
OnBundleFinished(ErrCode err,const BundleName name)37 static void OnBundleFinished(ErrCode err, const BundleName name)
38 {
39     GTEST_LOG_(INFO) << "BSessionBackupTest OnBundleFinished OK";
40 }
41 
OnAllBundlesFinished(ErrCode err)42 static void OnAllBundlesFinished(ErrCode err)
43 {
44     GTEST_LOG_(INFO) << "BSessionBackupTest OnAllBundlesFinished OK";
45 }
46 
OnBackupServiceDied()47 static void OnBackupServiceDied()
48 {
49     GTEST_LOG_(INFO) << "BSessionBackupTest OnBackupServiceDied OK";
50 }
51 
52 class BSessionBackupTest : public testing::Test {
53 public:
SetUpTestCase(void)54     static void SetUpTestCase(void) {};
TearDownTestCase()55     static void TearDownTestCase() {};
56     void SetUp() override;
57     void TearDown() override;
58 
59     void Init();
60 
61     unique_ptr<BSessionBackup> backupPtr_ = nullptr;
62     BSessionBackup::Callbacks callbacks_;
63 };
64 
SetUp()65 void BSessionBackupTest::SetUp()
66 {
67     SetMockInitBackupOrRestoreSession(true);
68     SetMockGetInstance(true);
69     SetMockLoadSystemAbility(true);
70     backupPtr_ = make_unique<BSessionBackup>();
71 }
72 
TearDown()73 void BSessionBackupTest::TearDown()
74 {
75     backupPtr_ = nullptr;
76 }
77 
Init()78 void BSessionBackupTest::Init()
79 {
80     callbacks_.onFileReady = OnFileReady;
81     callbacks_.onBundleStarted = OnBundleStarted;
82     callbacks_.onBundleFinished = OnBundleFinished;
83     callbacks_.onAllBundlesFinished = OnAllBundlesFinished;
84     callbacks_.onBackupServiceDied = OnBackupServiceDied;
85 }
86 
87 /**
88  * @tc.number: SUB_backup_b_session_backup_0100
89  * @tc.name: SUB_backup_b_session_backup_0100
90  * @tc.desc: 测试Start接口
91  * @tc.size: MEDIUM
92  * @tc.type: FUNC
93  * @tc.level Level 1
94  * @tc.require: I6F3GV
95  */
96 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0100, testing::ext::TestSize.Level1)
97 {
98     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0100";
99     try {
100         GTEST_LOG_(INFO) << "GetInstance is true";
101         if (backupPtr_ == nullptr) {
102             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0100 backupPtr_ == nullptr";
103             return;
104         }
105         auto ret = backupPtr_->Start();
106         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
107         GTEST_LOG_(INFO) << "GetInstance is false";
108         SetMockGetInstance(false);
109         ret = backupPtr_->Start();
110         EXPECT_NE(ret, ErrCode(BError::Codes::OK));
111     } catch (...) {
112         EXPECT_TRUE(false);
113         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Start.";
114     }
115     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0100";
116 }
117 
118 /**
119  * @tc.number: SUB_backup_b_session_backup_0200
120  * @tc.name: SUB_backup_b_session_backup_0200
121  * @tc.desc: 测试Finish接口
122  * @tc.size: MEDIUM
123  * @tc.type: FUNC
124  * @tc.level Level 1
125  * @tc.require: I6F3GV
126  */
127 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0200, testing::ext::TestSize.Level1)
128 {
129     GTEST_LOG_(INFO) << "BSessionBackupTest-Finish SUB_backup_b_session_backup_0200";
130     try {
131         if (backupPtr_ == nullptr) {
132             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0200 backupPtr_ == nullptr";
133             return;
134         }
135         GTEST_LOG_(INFO) << "GetInstance is true";
136         SetMockGetInstance(true);
137         auto ret = backupPtr_->Finish();
138         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
139         GTEST_LOG_(INFO) << "GetInstance is false";
140         SetMockGetInstance(false);
141         ret = backupPtr_->Finish();
142         EXPECT_NE(ret, ErrCode(BError::Codes::OK));
143     } catch (...) {
144         EXPECT_TRUE(false);
145         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Finish.";
146     }
147     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0200";
148 }
149 
150 /**
151  * @tc.number: SUB_backup_b_session_backup_0300
152  * @tc.name: SUB_backup_b_session_backup_0300
153  * @tc.desc: 测试AppendBundles接口
154  * @tc.size: MEDIUM
155  * @tc.type: FUNC
156  * @tc.level Level 1
157  * @tc.require: I6F3GV
158  */
159 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0300, testing::ext::TestSize.Level1)
160 {
161     GTEST_LOG_(INFO) << "BSessionBackupTest-AppendBundles SUB_backup_b_session_backup_0300";
162     try {
163         if (backupPtr_ == nullptr) {
164             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0300 backupPtr_ == nullptr";
165             return;
166         }
167         vector<BundleName> bundleNames;
168         GTEST_LOG_(INFO) << "GetInstance is true";
169         SetMockGetInstance(true);
170         auto ret = backupPtr_->AppendBundles(bundleNames);
171         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
172         GTEST_LOG_(INFO) << "GetInstance is false";
173         SetMockGetInstance(false);
174         ret = backupPtr_->AppendBundles(bundleNames);
175         EXPECT_NE(ret, ErrCode(BError::Codes::OK));
176     } catch (...) {
177         EXPECT_TRUE(false);
178         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by AppendBundles.";
179     }
180     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0300";
181 }
182 
183 /**
184  * @tc.number: SUB_backup_b_session_backup_0400
185  * @tc.name: SUB_backup_b_session_backup_0400
186  * @tc.desc: 测试Callbacks接口
187  * @tc.size: MEDIUM
188  * @tc.type: FUNC
189  * @tc.level Level 1
190  * @tc.require: I6F3GV
191  */
192 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0400, testing::ext::TestSize.Level1)
193 {
194     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0400";
195     try {
196         Init();
197         BFileInfo backupFileInfo("", "", 0);
198         callbacks_.onFileReady(backupFileInfo, UniqueFd(-1), 0);
199         callbacks_.onBundleStarted(ErrCode(BError::Codes::OK), "");
200         callbacks_.onBundleFinished(ErrCode(BError::Codes::OK), "");
201         callbacks_.onAllBundlesFinished(ErrCode(BError::Codes::OK));
202         callbacks_.onBackupServiceDied();
203     } catch (...) {
204         EXPECT_TRUE(false);
205         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Callbacks.";
206     }
207     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0400";
208 }
209 
210 /**
211  * @tc.number: SUB_backup_b_session_backup_0500
212  * @tc.name: SUB_backup_b_session_backup_0500
213  * @tc.desc: 测试Init接口
214  * @tc.size: MEDIUM
215  * @tc.type: FUNC
216  * @tc.level Level 1
217  * @tc.require: I6F3GV
218  */
219 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0500, testing::ext::TestSize.Level1)
220 {
221     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0500";
222     try {
223         GTEST_LOG_(INFO) << "GetInstance is false";
224         SetMockGetInstance(false);
225         auto backupPtr = BSessionBackup::Init(BSessionBackup::Callbacks {});
226         EXPECT_EQ(backupPtr, nullptr);
227         GTEST_LOG_(INFO) << "GetInstance is true";
228         GTEST_LOG_(INFO) << "InitBackupSession is false";
229         SetMockGetInstance(true);
230         SetMockInitBackupOrRestoreSession(false);
231         backupPtr = BSessionBackup::Init(BSessionBackup::Callbacks {});
232         EXPECT_EQ(backupPtr, nullptr);
233         GTEST_LOG_(INFO) << "InitBackupSession is true";
234         SetMockInitBackupOrRestoreSession(true);
235         Init();
236         backupPtr = BSessionBackup::Init(callbacks_);
237         EXPECT_NE(backupPtr, nullptr);
238     } catch (...) {
239         EXPECT_TRUE(false);
240         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Init.";
241     }
242     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0500";
243 }
244 
245 /**
246  * @tc.number: SUB_backup_b_session_backup_0600
247  * @tc.name: SUB_backup_b_session_backup_0600
248  * @tc.desc: 测试RegisterBackupServiceDied接口
249  * @tc.size: MEDIUM
250  * @tc.type: FUNC
251  * @tc.level Level 1
252  * @tc.require: I6F3GV
253  */
254 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0600, testing::ext::TestSize.Level1)
255 {
256     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0600";
257     try {
258         if (backupPtr_ == nullptr) {
259             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0600 backupPtr_ == nullptr";
260             return;
261         }
262         GTEST_LOG_(INFO) << "GetInstance is false";
263         SetMockGetInstance(false);
264         backupPtr_->RegisterBackupServiceDied(nullptr);
265         GTEST_LOG_(INFO) << "GetInstance is true";
266         SetMockGetInstance(true);
267         backupPtr_->RegisterBackupServiceDied(nullptr);
268     } catch (...) {
269         EXPECT_TRUE(false);
270         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by RegisterBackupServiceDied.";
271     }
272     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0600";
273 }
274 
275 /**
276  * @tc.number: SUB_backup_b_session_backup_0700
277  * @tc.name: SUB_backup_b_session_backup_0700
278  * @tc.desc: 测试析构流程接口
279  * @tc.size: MEDIUM
280  * @tc.type: FUNC
281  * @tc.level Level 1
282  * @tc.require: I6F3GV
283  */
284 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0700, testing::ext::TestSize.Level1)
285 {
286     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0700";
287     try {
288         SetMockGetInstance(true);
289         SetMockLoadSystemAbility(true);
290         Init();
291         auto backupPtr = BSessionBackup::Init(callbacks_);
292         EXPECT_NE(backupPtr, nullptr);
293 
294         GTEST_LOG_(INFO) << "GetInstance is false";
295         SetMockGetInstance(false);
296         backupPtr = nullptr;
297 
298         SetMockGetInstance(true);
299         SetMockLoadSystemAbility(true);
300         backupPtr = BSessionBackup::Init(callbacks_);
301         EXPECT_NE(backupPtr, nullptr);
302 
303         GTEST_LOG_(INFO) << "LoadSystemAbility is false";
304         SetMockLoadSystemAbility(false);
305         backupPtr = nullptr;
306     } catch (...) {
307         EXPECT_TRUE(false);
308         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by ~BSessionBackup.";
309     }
310     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0700";
311 }
312 
313 /**
314  * @tc.number: SUB_backup_b_session_backup_0800
315  * @tc.name: SUB_backup_b_session_backup_0800
316  * @tc.desc: 测试AppendBundles接口
317  * @tc.size: MEDIUM
318  * @tc.type: FUNC
319  * @tc.level Level 1
320  * @tc.require: I6F3GV
321  */
322 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0800, testing::ext::TestSize.Level1)
323 {
324     GTEST_LOG_(INFO) << "BSessionBackupTest-AppendBundles SUB_backup_b_session_backup_0800";
325     try {
326         if (backupPtr_ == nullptr) {
327             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0800 backupPtr_ == nullptr";
328             return;
329         }
330         vector<BundleName> bundleNames;
331         vector<std::string> detailInfos;
332         GTEST_LOG_(INFO) << "GetInstance is true";
333         SetMockGetInstance(true);
334         auto ret = backupPtr_->AppendBundles(bundleNames, detailInfos);
335         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
336         GTEST_LOG_(INFO) << "GetInstance is false";
337         SetMockGetInstance(false);
338         ret = backupPtr_->AppendBundles(bundleNames, detailInfos);
339         EXPECT_NE(ret, ErrCode(BError::Codes::OK));
340     } catch (...) {
341         EXPECT_TRUE(false);
342         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by AppendBundles.";
343     }
344     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0800";
345 }
346 
347 /**
348  * @tc.number: SUB_backup_b_session_backup_0900
349  * @tc.name: SUB_backup_b_session_backup_0900
350  * @tc.desc: 测试AppendBundles接口
351  * @tc.size: MEDIUM
352  * @tc.type: FUNC
353  * @tc.level Level 1
354  * @tc.require: I6F3GV
355  */
356 HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0900, testing::ext::TestSize.Level1)
357 {
358     GTEST_LOG_(INFO) << "BSessionBackupTest-Release SUB_backup_b_session_backup_0900";
359     try {
360         if (backupPtr_ == nullptr) {
361             GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0900 backupPtr_ == nullptr";
362             return;
363         }
364         GTEST_LOG_(INFO) << "GetInstance is true";
365         SetMockGetInstance(true);
366         auto ret = backupPtr_->Release();
367         EXPECT_EQ(ret, ErrCode(BError::Codes::OK));
368         GTEST_LOG_(INFO) << "GetInstance is false";
369         SetMockGetInstance(false);
370         ret = backupPtr_->Release();
371         EXPECT_NE(ret, ErrCode(BError::Codes::OK));
372     } catch (...) {
373         EXPECT_TRUE(false);
374         GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Release.";
375     }
376     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0900";
377 }
378 } // namespace OHOS::FileManagement::Backup