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 <iostream>
17 #include <map>
18 #include <sstream>
19 #include <string>
20 #include <sys/stat.h>
21 #include <unistd.h>
22 #include <vector>
23 
24 #include <gtest/gtest.h>
25 
26 #include "b_resources/b_constants.h"
27 #include "tools_op.h"
28 
29 #include "b_error/b_error.h"
30 #include "b_error/b_excep_utils.h"
31 #include "b_file_info.h"
32 #include "tools_op_restore.cpp"
33 
34 namespace OHOS::FileManagement::Backup {
35 using namespace std;
36 
37 namespace {
38 const string BUNDLE_NAME = "com.example.app2backup/";
39 const string MANAGE_JSON = "manage.json";
40 const string FILE_NAME = "1.tar";
41 } // namespace
42 
43 class ToolsOpRestoreTest : public testing::Test {
44 public:
SetUpTestCase(void)45     static void SetUpTestCase(void) {};
TearDownTestCase()46     static void TearDownTestCase() {};
SetUp()47     void SetUp() {};
TearDown()48     void TearDown() {};
49 };
50 
51 /**
52  * @tc.number: SUB_backup_tools_op_restore_0100
53  * @tc.name: SUB_backup_tools_op_restore_0100
54  * @tc.desc: 测试
55  * @tc.size: MEDIUM
56  * @tc.type: FUNC
57  * @tc.level Level 1
58  * @tc.require: I6F3GV
59  */
60 HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0100, testing::ext::TestSize.Level1)
61 {
62     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0100";
63     try {
64         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-info";
65         map<string, vector<string>> mapArgToVal;
66         string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp";
67         vector<string> path = {localCap.data()};
68         mapArgToVal.insert(make_pair("pathCapFile", path));
69         vector<string> bundles = {"com.example.app2backup"};
70         mapArgToVal.insert(make_pair("bundles", bundles));
71 
72         // 创建测试路径以及测试环境
73         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME;
74         system(cmdMkdir.c_str());
75         string cmdTool = string("mkdir -p ") + BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data();
76         system(cmdTool.c_str());
77         string touchTar = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + FILE_NAME;
78         system(touchTar.c_str());
79         string touchManage = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + MANAGE_JSON;
80         system(touchManage.c_str());
81         string touchTmp = string("touch ") + localCap;
82         system(touchTmp.c_str());
83 
84         // 尝试匹配当前命令，成功后执行
85         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-restore";
86         vector<string_view> curOp;
87         curOp.emplace_back("restore");
__anon98937daf0202(const ToolsOp &op) 88         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
89         auto &&opeartions = ToolsOp::GetAllOperations();
90         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
91         if (matchedOp != opeartions.end()) {
92             auto ret = matchedOp->Execute(mapArgToVal);
93             EXPECT_EQ(ret, 0);
94         }
95     } catch (...) {
96         EXPECT_TRUE(false);
97         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
98     }
99     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0100";
100 }
101 
102 /**
103  * @tc.number: SUB_backup_tools_op_restore_0200
104  * @tc.name: SUB_backup_tools_op_restore_0200
105  * @tc.desc: 测试
106  * @tc.size: MEDIUM
107  * @tc.type: FUNC
108  * @tc.level Level 1
109  * @tc.require: I6F3GV
110  */
111 HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::TestSize.Level1)
112 {
113     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0200";
114     try {
115         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
116         map<string, vector<string>> mapArgToVal;
117         vector<string> bundles = {"com.example.app2backup"};
118         vector<string> path = {"/data/backup/tmp"};
119         mapArgToVal.insert(make_pair("bundles", bundles));
120 
121         vector<string_view> curOp;
122         curOp.emplace_back("restore");
__anon98937daf0302(const ToolsOp &op) 123         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
124         auto &&opeartions = ToolsOp::GetAllOperations();
125         auto matchedOperation = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
126         int ret = 0;
127         if (matchedOperation != opeartions.end()) {
128             ret = matchedOperation->Execute(mapArgToVal);
129             EXPECT_NE(ret, 0);
130         }
131         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained.";
132         mapArgToVal.clear();
133         mapArgToVal.insert(make_pair("pathCapFile", path));
134         if (matchedOperation != opeartions.end()) {
135             ret = matchedOperation->Execute(mapArgToVal);
136             EXPECT_NE(ret, 0);
137         }
138 
139         mapArgToVal.clear();
140         if (matchedOperation != opeartions.end()) {
141             ret = matchedOperation->Execute(mapArgToVal);
142             EXPECT_NE(ret, 0);
143         }
144     } catch (...) {
145         EXPECT_TRUE(false);
146         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
147     }
148     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0200";
149 }
150 
151 /**
152  * @tc.number: SUB_backup_tools_op_restore_0300
153  * @tc.name: SUB_backup_tools_op_restore_0300
154  * @tc.desc: 测试
155  * @tc.size: MEDIUM
156  * @tc.type: FUNC
157  * @tc.level Level 1
158  * @tc.require: I6F3GV
159  */
160 HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0300, testing::ext::TestSize.Level1)
161 {
162     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0300";
163     try {
164         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
165         map<string, vector<string>> mapArgToVal;
166 
167         vector<string> bundles = {"com.example.app2backup"};
168         vector<string> path = {"/data/backup/tmp"};
169         vector<string> depMode = {"true"};
170         mapArgToVal.insert(make_pair("pathCapFile", path));
171         mapArgToVal.insert(make_pair("bundles", bundles));
172         mapArgToVal.insert(make_pair("depMode", depMode));
173 
174         vector<string_view> curOp;
175         curOp.emplace_back("restore");
__anon98937daf0402(const ToolsOp &op) 176         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
177         auto &&opeartions = ToolsOp::GetAllOperations();
178         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
179         int ret = 0;
180         if (matchedOp != opeartions.end()) {
181             ret = matchedOp->Execute(mapArgToVal);
182             EXPECT_NE(ret, 0);
183         }
184         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained.";
185         mapArgToVal.clear();
186         mapArgToVal.insert(make_pair("pathCapFile", path));
187         if (matchedOp != opeartions.end()) {
188             ret = matchedOp->Execute(mapArgToVal);
189             EXPECT_NE(ret, 0);
190         }
191 
192         mapArgToVal.clear();
193         if (matchedOp != opeartions.end()) {
194             ret = matchedOp->Execute(mapArgToVal);
195             EXPECT_NE(ret, 0);
196         }
197 
198         vector<string> path1 = {"/data/tmp/abdc"};
199         mapArgToVal.insert(make_pair("pathCapFile", path1));
200         if (matchedOp != opeartions.end()) {
201             ret = matchedOp->Execute(mapArgToVal);
202             EXPECT_NE(ret, 0);
203         }
204     } catch (...) {
205         EXPECT_TRUE(false);
206         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
207     }
208     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0300";
209 }
210 
211 /**
212  * @tc.number: SUB_backup_tools_op_restore_0400
213  * @tc.name: SUB_backup_tools_op_restore_0400
214  * @tc.desc: 测试
215  * @tc.size: MEDIUM
216  * @tc.type: FUNC
217  * @tc.level Level 1
218  * @tc.require: I6F3GV
219  */
220 HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0400, testing::ext::TestSize.Level1)
221 {
222     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0400";
223     try {
224         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
225         map<string, vector<string>> mapArgToVal;
226 
227         vector<string> bundles = {"com.example.app2backup"};
228         vector<string> path = {"/data/backup/tmp"};
229         vector<string> depMode = {"false"};
230         mapArgToVal.insert(make_pair("depMode", depMode));
231         mapArgToVal.insert(make_pair("bundles", bundles));
232 
233         vector<string_view> curOp;
234         curOp.emplace_back("restore");
__anon98937daf0502(const ToolsOp &op) 235         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
236         auto &&opeartions = ToolsOp::GetAllOperations();
237         auto matchedOpIterator = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
238         int ret = 0;
239         if (matchedOpIterator != opeartions.end()) {
240             ret = matchedOpIterator->Execute(mapArgToVal);
241             EXPECT_NE(ret, 0);
242         }
243         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained.";
244         mapArgToVal.clear();
245         mapArgToVal.insert(make_pair("pathCapFile", path));
246         if (matchedOpIterator != opeartions.end()) {
247             ret = matchedOpIterator->Execute(mapArgToVal);
248             EXPECT_NE(ret, 0);
249         }
250 
251         mapArgToVal.clear();
252         if (matchedOpIterator != opeartions.end()) {
253             ret = matchedOpIterator->Execute(mapArgToVal);
254             EXPECT_NE(ret, 0);
255         }
256     } catch (...) {
257         EXPECT_TRUE(false);
258         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
259     }
260     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0400";
261 }
262 
263 /**
264  * @tc.number: SUB_backup_tools_op_restore_0500
265  * @tc.name: tools_op_restore_OnFileReady_0500
266  * @tc.desc: 测试文件名包含BConstants::EXT_BACKUP_MANAGE,且tmpPath存在
267  * @tc.size: MEDIUM
268  * @tc.type: FUNC
269  * @tc.level Level 1
270  * @tc.require: I9NOPD
271  */
272 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnFileReady_0500, testing::ext::TestSize.Level1)
273 {
274     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnFileReady_0500";
275     try {
276         auto ctx = make_shared<Session>();
277         BFileInfo fileInfo;
278         fileInfo.owner = "test";
279         fileInfo.fileName = "manage.json";
280         fileInfo.sn = 1;
281         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
282         OnFileReady(ctx, fileInfo, move(fd), 0);
283     } catch (BError &e) {
284         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
285         EXPECT_TRUE(true);
286     } catch (...) {
287         EXPECT_TRUE(false);
288         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
289     }
290     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnFileReady_0500";
291 }
292 
293 /**
294  * @tc.number: SUB_backup_tools_op_restore_0501
295  * @tc.name: tools_op_restore_OnFileReady_0501
296  * @tc.desc: 测试文件名不包含BConstants::EXT_BACKUP_MANAGE,且tmpPath存在
297  * @tc.size: MEDIUM
298  * @tc.type: FUNC
299  * @tc.level Level 1
300  * @tc.require: I9NOPD
301  */
302 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnFileReady_0501, testing::ext::TestSize.Level1)
303 {
304     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnFileReady_0501";
305     try {
306 
307         auto ctx = make_shared<Session>();
308         BFileInfo fileInfo;
309         fileInfo.owner = "test";
310         fileInfo.fileName = "test.json";
311         fileInfo.sn = 1;
312         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
313         OnFileReady(ctx, fileInfo, move(fd), 0);
314     } catch (BError &e) {
315         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
316         EXPECT_TRUE(true);
317     } catch (...) {
318         EXPECT_TRUE(false);
319         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
320     }
321     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnFileReady_0501";
322 }
323 
324 /**
325  * @tc.number: SUB_backup_tools_op_restore_0502
326  * @tc.name: tools_op_restore_OnFileReady_0502
327  * @tc.desc: 测试文件名包含'/'
328  * @tc.size: MEDIUM
329  * @tc.type: FUNC
330  * @tc.level Level 1
331  * @tc.require: I9NOPD
332  */
333 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnFileReady_0502, testing::ext::TestSize.Level1)
334 {
335     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnFileReady_0502";
336     try {
337         auto ctx = make_shared<Session>();
338         BFileInfo fileInfo;
339         fileInfo.owner = "test";
340         fileInfo.fileName = "/test.json";
341         fileInfo.sn = 1;
342         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
343         OnFileReady(ctx, fileInfo, move(fd), 0);
344     } catch (BError &e) {
345         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
346         EXPECT_TRUE(true);
347     } catch (...) {
348         EXPECT_TRUE(false);
349         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
350     }
351     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnFileReady_0502";
352 }
353 
354 /**
355  * @tc.number: SUB_backup_tools_op_restore_0503
356  * @tc.name: tools_op_restore_OnFileReady_0503
357  * @tc.desc: 测试tmpPath不存在
358  * @tc.size: MEDIUM
359  * @tc.type: FUNC
360  * @tc.level Level 1
361  * @tc.require: I9NOPD
362  */
363 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnFileReady_0503, testing::ext::TestSize.Level1)
364 {
365     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnFileReady_0503";
366     try {
367         auto ctx = make_shared<Session>();
368         BFileInfo fileInfo;
369         fileInfo.owner = " ";
370         fileInfo.fileName = " ";
371         fileInfo.sn = 1;
372         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
373         OnFileReady(ctx, fileInfo, move(fd), 0);
374     } catch (BError &e) {
375         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
376         EXPECT_TRUE(true);
377     } catch (...) {
378         EXPECT_TRUE(false);
379         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
380     }
381     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnFileReady_0503";
382 }
383 
384 /**
385  * @tc.number: SUB_backup_tools_op_restore_0600
386  * @tc.name: tools_op_restore_OnBundleStarted_0600
387  * @tc.desc: 测试当err=0时
388  * @tc.size: MEDIUM
389  * @tc.type: FUNC
390  * @tc.level Level 1
391  * @tc.require: I9NOPD
392  */
393 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleStarted_0600, testing::ext::TestSize.Level1)
394 {
395     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleStarted_0600";
396     try {
397         auto ctx = make_shared<Session>();
398         ErrCode err = 0;
399         BundleName name = BUNDLE_NAME;
400         OnBundleStarted(ctx, err, name);
401         EXPECT_TRUE(true);
402     } catch (...) {
403         EXPECT_TRUE(false);
404         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
405     }
406     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleStarted_0600";
407 }
408 
409 /**
410  * @tc.number: SUB_backup_tools_op_restore_0601
411  * @tc.name: tools_op_restore_OnBundleStarted_0601
412  * @tc.desc: 测试当err！=0时调用UpdateBundleFinishedCount()方法
413  * @tc.size: MEDIUM
414  * @tc.type: FUNC
415  * @tc.level Level 1
416  * @tc.require: I9NOPD
417  */
418 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleStarted_0601, testing::ext::TestSize.Level1)
419 {
420     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleStarted_0601";
421     try {
422         auto ctx = make_shared<Session>();
423         ctx->cnt_ = 1;
424         ErrCode err = -1;
425         BundleName name = BUNDLE_NAME;
426         OnBundleStarted(ctx, err, name);
427         EXPECT_EQ(ctx->cnt_, 0);
428     } catch (...) {
429         EXPECT_TRUE(false);
430         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
431     }
432     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleStarted_0601";
433 }
434 
435 /**
436  * @tc.number: SUB_backup_tools_op_restore_0700
437  * @tc.name: tools_op_restore_OnBundleFinished_0700
438  * @tc.desc: test func
439  * @tc.size: MEDIUM
440  * @tc.type: FUNC
441  * @tc.level Level 1
442  * @tc.require: I9NOPD
443  */
444 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleFinished_0700, testing::ext::TestSize.Level1)
445 {
446     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleFinished_0700";
447     try {
448         auto ctx = make_shared<Session>();
449         ctx->cnt_ = 1;
450         ErrCode err = 0;
451         BundleName name = BUNDLE_NAME;
452         OnBundleFinished(ctx, err, name);
453         EXPECT_TRUE(true);
454     } catch (...) {
455         EXPECT_TRUE(false);
456         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
457     }
458     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleFinished_0700";
459 }
460 
461 /**
462  * @tc.number: SUB_backup_tools_op_restore_0701
463  * @tc.name: tools_op_restore_OnBundleFinished_0701
464  * @tc.desc: test func
465  * @tc.size: MEDIUM
466  * @tc.type: FUNC
467  * @tc.level Level 1
468  * @tc.require: I9NOPD
469  */
470 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleFinished_0701, testing::ext::TestSize.Level1)
471 {
472     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleFinished_0701";
473     try {
474         auto ctx = make_shared<Session>();
475         ctx->cnt_ = 1;
476         ErrCode err = -1;
477         BundleName name = BUNDLE_NAME;
478         OnBundleFinished(ctx, err, name);
479         EXPECT_TRUE(true);
480     } catch (...) {
481         EXPECT_TRUE(false);
482         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
483     }
484     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleFinished_0701";
485 }
486 
487 /**
488  * @tc.number: SUB_backup_tools_op_restore_0702
489  * @tc.name: tools_op_restore_OnBundleFinished_0702
490  * @tc.desc: test func
491  * @tc.size: MEDIUM
492  * @tc.type: FUNC
493  * @tc.level Level 1
494  * @tc.require: I9NOPD
495  */
496 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleFinished_0702, testing::ext::TestSize.Level1)
497 {
498     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleFinished_0702";
499     try {
500         auto ctx = make_shared<Session>();
501         ErrCode err = 0;
502         OnAllBundlesFinished(ctx, err);
503         EXPECT_TRUE(true);
504     } catch (...) {
505         EXPECT_TRUE(false);
506         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
507     }
508     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleFinished_0702";
509 }
510 
511 /**
512  * @tc.number: SUB_backup_tools_op_restore_0703
513  * @tc.name: tools_op_restore_OnBundleFinished_0703
514  * @tc.desc: test func
515  * @tc.size: MEDIUM
516  * @tc.type: FUNC
517  * @tc.level Level 1
518  * @tc.require: I9NOPD
519  */
520 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleFinished_0703, testing::ext::TestSize.Level1)
521 {
522     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleFinished_0703";
523     try {
524         auto ctx = make_shared<Session>();
525         ErrCode err = -1;
526         OnAllBundlesFinished(ctx, err);
527         EXPECT_TRUE(true);
528     } catch (...) {
529         EXPECT_TRUE(false);
530         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
531     }
532     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleFinished_0703";
533 }
534 
535 /**
536  * @tc.number: SUB_backup_tools_op_restore_0704
537  * @tc.name: tools_op_restore_OnBundleFinished_0704
538  * @tc.desc: test func
539  * @tc.size: MEDIUM
540  * @tc.type: FUNC
541  * @tc.level Level 1
542  * @tc.require: I9NOPD
543  */
544 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OnBundleFinished_0704, testing::ext::TestSize.Level1)
545 {
546     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OnBundleFinished_0704";
547     try {
548         auto ctx = make_shared<Session>();
549         OnBackupServiceDied(ctx);
550         EXPECT_TRUE(true);
551     } catch (...) {
552         EXPECT_TRUE(false);
553         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
554     }
555     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OnBundleFinished_0704";
556 }
557 
558 /**
559  * @tc.number: SUB_backup_tools_op_restore_0800
560  * @tc.name: tools_op_restore_OnResultReport_0800
561  * @tc.desc: 测试当err=0时
562  * @tc.size: MEDIUM
563  * @tc.type: FUNC
564  * @tc.level Level 1
565  * @tc.require: I9NOPD
566  */
567 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_OOnResultReport_0800, testing::ext::TestSize.Level1)
568 {
569     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_OOnResultReport_0800";
570     try {
571         auto ctx = make_shared<Session>();
572         std::string bundleName = "com.example.app2backup";
573         std::string resultInfo = "result info";
574         OnResultReport(ctx, bundleName, resultInfo);
575         EXPECT_TRUE(true);
576     } catch (...) {
577         EXPECT_TRUE(false);
578         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
579     }
580     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_OOnResultReport_0800";
581 }
582 
583 /**
584  * @tc.number: SUB_backup_tools_op_restore_0900
585  * @tc.name: tools_op_restore_RestoreApp_0900
586  * @tc.desc: 测试当!restore时
587  * @tc.size: MEDIUM
588  * @tc.type: FUNC
589  * @tc.level Level 1
590  * @tc.require: I9NOPD
591  */
592 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_RestoreApp_0900, testing::ext::TestSize.Level1)
593 {
594     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_RestoreApp_0900";
595     try {
596         shared_ptr<Session> restore = nullptr;
597         vector<BundleName> bundleNames = {"com.example.app2backup/"};
598         bool updateSendFiles = false;
599         RestoreApp(restore, bundleNames, updateSendFiles);
600     } catch (BError &e) {
601         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
602         EXPECT_TRUE(true);
603     } catch (...) {
604         EXPECT_TRUE(false);
605         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
606     }
607     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_RestoreApp_0900";
608 }
609 
610 /**
611  * @tc.number: SUB_backup_tools_op_restore_0901
612  * @tc.name: tools_op_restore_RestoreApp_0901
613  * @tc.desc: 测试当!restore->session_时
614  * @tc.size: MEDIUM
615  * @tc.type: FUNC
616  * @tc.level Level 1
617  * @tc.require: I9NOPD
618  */
619 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_RestoreApp_0901, testing::ext::TestSize.Level1)
620 {
621     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_RestoreApp_0901";
622     try {
623         shared_ptr<Session> restore = make_shared<Session>();
624         restore->session_ = nullptr;
625         vector<BundleName> bundleNames = {"com.example.app2backup/"};
626         bool updateSendFiles = false;
627         RestoreApp(restore, bundleNames, updateSendFiles);
628     } catch (BError &e) {
629         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
630         EXPECT_TRUE(true);
631     } catch (...) {
632         EXPECT_TRUE(false);
633         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
634     }
635     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_RestoreApp_0901";
636 }
637 
638 /**
639  * @tc.number: SUB_backup_tools_op_restore_0902
640  * @tc.name: tools_op_restore_RestoreApp_0902
641  * @tc.desc: 测试当bundlename 包含'/'时
642  * @tc.size: MEDIUM
643  * @tc.type: FUNC
644  * @tc.level Level 1
645  * @tc.require: I9NOPD
646  */
647 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_RestoreApp_0902, testing::ext::TestSize.Level1)
648 {
649     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_RestoreApp_0902";
650     try {
651         shared_ptr<Session> restore = make_shared<Session>();
652         restore->session_ = {};
653         vector<BundleName> bundleNames = {"com.example.app2backup/"};
654         bool updateSendFiles = false;
655         RestoreApp(restore, bundleNames, updateSendFiles);
656     } catch (BError &e) {
657         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
658         EXPECT_TRUE(true);
659     } catch (...) {
660         EXPECT_TRUE(false);
661         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
662     }
663     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_RestoreApp_0902";
664 }
665 
666 /**
667  * @tc.number: SUB_backup_tools_op_restore_1000
668  * @tc.name: tools_op_restore_GetRealPath_1000
669  * @tc.desc: 测试当path为空
670  * @tc.size: MEDIUM
671  * @tc.type: FUNC
672  * @tc.level Level 1
673  * @tc.require: I9NOPD
674  */
675 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_GetRealPath_1000, testing::ext::TestSize.Level1)
676 {
677     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_GetRealPath_1000";
678     try {
679         string path = " ";
680         bool ret = GetRealPath(path);
681         EXPECT_EQ(ret, false);
682     } catch (...) {
683         EXPECT_TRUE(false);
684         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
685     }
686     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_GetRealPath_1000";
687 }
688 
689 /**
690  * @tc.number: SUB_backup_tools_op_restore_1001
691  * @tc.name: tools_op_restore_GetRealPath_1001
692  * @tc.desc: 测试当path不存在
693  * @tc.size: MEDIUM
694  * @tc.type: FUNC
695  * @tc.level Level 1
696  * @tc.require: I9NOPD
697  */
698 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_GetRealPath_1001, testing::ext::TestSize.Level1)
699 {
700     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_GetRealPath_1001";
701     try {
702         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data();
703         system(cmdMkdir.c_str());
704         string path = "/data/backup/no/recived/";
705         bool ret = GetRealPath(path);
706         EXPECT_EQ(ret, false);
707     } catch (...) {
708         EXPECT_TRUE(false);
709         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
710     }
711     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_GetRealPath_1001";
712 }
713 
714 /**
715  * @tc.number: SUB_backup_tools_op_restore_1002
716  * @tc.name: tools_op_restore_GetRealPath_1002
717  * @tc.desc: 测试当path正常
718  * @tc.size: MEDIUM
719  * @tc.type: FUNC
720  * @tc.level Level 1
721  * @tc.require: I9NOPD
722  */
723 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_GetRealPath_1002, testing::ext::TestSize.Level1)
724 {
725     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_GetRealPath_1002";
726     try {
727         string path = string(BConstants::BACKUP_TOOL_RECEIVE_DIR.data()) + "/tmp";
728         int fd = open(path.data(), O_RDWR | O_CREAT, S_IRWXU);
729         EXPECT_GT(fd, 0);
730         close(fd);
731         bool ret = GetRealPath(path);
732         EXPECT_EQ(ret, true);
733     } catch (...) {
734         EXPECT_TRUE(false);
735         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
736     }
737     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_GetRealPath_1002";
738 }
739 
740 /**
741  * @tc.number: SUB_backup_tools_op_restore_1100
742  * @tc.name: tools_op_restore_InitRestoreSession_1100
743  * @tc.desc: 测试当!ctx
744  * @tc.size: MEDIUM
745  * @tc.type: FUNC
746  * @tc.level Level 1
747  * @tc.require: I9NOPD
748  */
749 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_InitRestoreSession_1100, testing::ext::TestSize.Level1)
750 {
751     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_GInitRestoreSession_1100";
752     try {
753         shared_ptr<Session> ctx = nullptr;
754         InitRestoreSession(ctx);
755     } catch (BError &e) {
756         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
757         EXPECT_TRUE(true);
758     } catch (...) {
759         EXPECT_TRUE(false);
760         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
761     }
762     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_GInitRestoreSession_1100";
763 }
764 
765 /**
766  * @tc.number: SUB_backup_tools_op_restore_1101
767  * @tc.name: tools_op_restore_InitRestoreSession_1101
768  * @tc.desc: 测试当ctx
769  * @tc.size: MEDIUM
770  * @tc.type: FUNC
771  * @tc.level Level 1
772  * @tc.require: I9NOPD
773  */
774 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_InitRestoreSession_1101, testing::ext::TestSize.Level1)
775 {
776     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_InitRestoreSession_1101";
777     try {
778         shared_ptr<Session> ctx = make_shared<Session>();
779         InitRestoreSession(ctx);
780     } catch (BError &e) {
781         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
782         EXPECT_TRUE(true);
783     } catch (...) {
784         EXPECT_TRUE(false);
785         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
786     }
787     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_InitRestoreSession_1101";
788 }
789 
790 /**
791  * @tc.number: SUB_backup_tools_op_restore_1200
792  * @tc.name: tools_op_restore_InitPathCapFile_1200
793  * @tc.desc: realPath 为空
794  * @tc.size: MEDIUM
795  * @tc.type: FUNC
796  * @tc.level Level 1
797  * @tc.require: I9NOPD
798  */
799 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_InitPathCapFile_1200, testing::ext::TestSize.Level1)
800 {
801     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_InitPathCapFile_1200";
802     try {
803         string pathCapFile = " ";
804         vector<string> bundleNames = {"com.example.app2backup/"};
805         bool depMode = true;
806         int32_t ret = InitPathCapFile(pathCapFile, bundleNames, depMode);
807         EXPECT_LT(ret, 0);
808     } catch (...) {
809         EXPECT_TRUE(false);
810         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
811     }
812     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_InitPathCapFile_1200";
813 }
814 
815 /**
816  * @tc.number: SUB_backup_tools_op_restore_1201
817  * @tc.name: tools_op_restore_InitPathCapFile_1201
818  * @tc.desc: test func
819  * @tc.size: MEDIUM
820  * @tc.type: FUNC
821  * @tc.level Level 1
822  * @tc.require: I9NOPD
823  */
824 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_InitPathCapFile_1201, testing::ext::TestSize.Level1)
825 {
826     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_InitPathCapFile_1201";
827     try {
828         string pathCapFile = "/data/backup/tmp";
829         vector<string> bundleNames = {"com.example.app2backup/"};
830         bool depMode = true;
831         int32_t ret = InitPathCapFile(pathCapFile, bundleNames, depMode);
832         EXPECT_LT(ret, 0);
833     } catch (BError &e) {
834         EXPECT_TRUE(true);
835     } catch (...) {
836         EXPECT_TRUE(false);
837         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
838     }
839     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_InitPathCapFile_1201";
840 }
841 
842 /**
843  * @tc.number: SUB_backup_tools_op_restore_1202
844  * @tc.name: tools_op_restore_InitPathCapFile_1202
845  * @tc.desc: test func
846  * @tc.size: MEDIUM
847  * @tc.type: FUNC
848  * @tc.level Level 1
849  * @tc.require: I9NOPD
850  */
851 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_InitPathCapFile_1202, testing::ext::TestSize.Level1)
852 {
853     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_InitPathCapFile_1202";
854     try {
855         string pathCapFile = "/data/backup/tmp";
856         vector<string> bundleNames = {"com.example.app2backup/"};
857         bool depMode = false;
858         int32_t ret = InitPathCapFile(pathCapFile, bundleNames, depMode);
859         EXPECT_LT(ret, 0);
860     } catch (BError &e) {
861         EXPECT_TRUE(true);
862     } catch (...) {
863         EXPECT_TRUE(false);
864         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
865     }
866     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_InitPathCapFile_1202";
867 }
868 
869 /**
870  * @tc.number: SUB_backup_tools_op_restore_1300
871  * @tc.name: tools_op_restore_Exec_1300
872  * @tc.desc: 测试depMOde =false
873  * @tc.size: MEDIUM
874  * @tc.type: FUNC
875  * @tc.level Level 1
876  * @tc.require: I9NOPD
877  */
878 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_Exec_1300, testing::ext::TestSize.Level1)
879 {
880     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_Exec_1300";
881     try {
882         map<string, vector<string>> mapArgToVal;
883         mapArgToVal["depMode"] = {"true"};
884         Exec(mapArgToVal);
885         EXPECT_EQ(mapArgToVal["depMode"][0], "true");
886     } catch (...) {
887         EXPECT_TRUE(false);
888         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
889     }
890     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_Exec_1300";
891 }
892 
893 /**
894  * @tc.number: SUB_backup_tools_op_restore_1301
895  * @tc.name: tools_op_restore_Exec_1301
896  * @tc.desc: 测试pathCapFile不存在
897  * @tc.size: MEDIUM
898  * @tc.type: FUNC
899  * @tc.level Level 1
900  * @tc.require: I9NOPD
901  */
902 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_Exec_1301, testing::ext::TestSize.Level1)
903 {
904     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_Exec_1301";
905     try {
906         map<string, vector<string>> mapArgToVal;
907         mapArgToVal["depMode"] = {"false"};
908         mapArgToVal["bundles"] = {"com.example.app2backup/"};
909         int ret = Exec(mapArgToVal);
910         EXPECT_LT(ret, 0);
911     } catch (...) {
912         EXPECT_TRUE(false);
913         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
914     }
915     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_Exec_1301";
916 }
917 
918 /**
919  * @tc.number: SUB_backup_tools_op_restore_1302
920  * @tc.name: tools_op_restore_Exec_1302
921  * @tc.desc: 测试bundles不存在
922  * @tc.size: MEDIUM
923  * @tc.type: FUNC
924  * @tc.level Level 1
925  * @tc.require: I9NOPD
926  */
927 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_Exec_1302, testing::ext::TestSize.Level1)
928 {
929     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_Exec_1302";
930     try {
931         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME;
932         system(cmdMkdir.c_str());
933         map<string, vector<string>> mapArgToVal;
934         mapArgToVal["depMode"] = {"false"};
935         mapArgToVal["pathCapFile"] = {"/data/backup/recived/"};
936         int ret = Exec(mapArgToVal);
937         EXPECT_LT(ret, 0);
938     } catch (...) {
939         EXPECT_TRUE(false);
940         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
941     }
942     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_Exec_1302";
943 }
944 
945 /**
946  * @tc.number: SUB_backup_tools_op_restore_1303
947  * @tc.name: tools_op_restore_Exec_1303
948  * @tc.desc: 测试都存在
949  * @tc.size: MEDIUM
950  * @tc.type: FUNC
951  * @tc.level Level 1
952  * @tc.require: I9NOPD
953  */
954 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_Exec_1303, testing::ext::TestSize.Level1)
955 {
956     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_Exec_1303";
957     try {
958         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME;
959         system(cmdMkdir.c_str());
960         map<string, vector<string>> mapArgToVal;
961         mapArgToVal["depMode"] = {"false"};
962         mapArgToVal["bundles"] = {"com.example.app2backup/"};
963         mapArgToVal["pathCapFile"] = {"/data/backup/recived/com.example.app2backup/"};
964         int ret = Exec(mapArgToVal);
965         EXPECT_LT(ret, 0);
966     } catch (...) {
967         EXPECT_TRUE(false);
968         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
969     }
970     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_Exec_1303";
971 }
972 
973 /**
974  * @tc.number: SUB_backup_tools_op_restore_1304
975  * @tc.name: tools_op_restore_Exec_1304
976  * @tc.desc: test func
977  * @tc.size: MEDIUM
978  * @tc.type: FUNC
979  * @tc.level Level 1
980  * @tc.require: I9NOPD
981  */
982 HWTEST_F(ToolsOpRestoreTest, tools_op_restore_Exec_1304, testing::ext::TestSize.Level1)
983 {
984     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin tools_op_restore_Exec_1304";
985     try {
986         map<string, vector<string>> mapArgToVal;
987         mapArgToVal["pathCapFile"] = {"/data/backup/recived/com.example.app2backup/"};
988         mapArgToVal["bundles"] = {"com.example.app2backup/"};
989         int ret = Exec(mapArgToVal);
990         EXPECT_LT(ret, 0);
991     } catch (...) {
992         EXPECT_TRUE(false);
993         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
994     }
995     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end tools_op_restore_Exec_1304";
996 }
997 } // namespace OHOS::FileManagement::Backup