1 /*
2  * Copyright (c) 2023-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 
23 #include <gtest/gtest.h>
24 
25 #include "b_resources/b_constants.h"
26 #include "tools_op.h"
27 
28 #include "b_error/b_error.h"
29 #include "b_error/b_excep_utils.h"
30 #include "b_file_info.h"
31 #include "tools_op_restore_async.cpp"
32 
33 namespace OHOS::FileManagement::Backup {
34 using namespace std;
35 
36 namespace {
37 const string FILE_NAME = "1.tar";
38 const string BUNDLE_NAME = "com.example.app2backup/";
39 const string MANAGE_JSON = "manage.json";
40 } // namespace
41 
42 class ToolsOpRestoreAsyncTest : public testing::Test {
43 public:
SetUpTestCase(void)44     static void SetUpTestCase(void) {};
TearDownTestCase()45     static void TearDownTestCase() {};
SetUp()46     void SetUp() {};
TearDown()47     void TearDown() {};
48 };
49 
50 /**
51  * @tc.number: SUB_backup_tools_op_restore_async_0100
52  * @tc.name: SUB_backup_tools_op_restore_async_0100
53  * @tc.desc: 测试
54  * @tc.size: MEDIUM
55  * @tc.type: FUNC
56  * @tc.level Level 1
57  * @tc.require: I7L7A6
58  */
59 HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testing::ext::TestSize.Level1)
60 {
61     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin SUB_backup_tools_op_restore_async_0100";
62     try {
63         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-info";
64         map<string, vector<string>> mapArgToVal;
65         string localCap = string(BConstants::SA_BUNDLE_BACKUP_TMP_DIR.data()) + "/tmp";
66         vector<string> path = { localCap.data() };
67         mapArgToVal.insert(make_pair("pathCapFile", path));
68         vector<string> bundles = { "com.example.app2backup" };
69         mapArgToVal.insert(make_pair("bundles", bundles));
70         vector<string> restoreType = { "true" };
71         mapArgToVal.insert(make_pair("restoreType", restoreType));
72         vector<string> userId = { "100" };
73         mapArgToVal.insert(make_pair("userId", userId));
74 
75         // 创建测试路径以及测试环境
76         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME;
77         system(cmdMkdir.c_str());
78         string cmdTool = string("mkdir -p ") + BConstants::SA_BUNDLE_BACKUP_TMP_DIR.data();
79         system(cmdTool.c_str());
80         string touchTar = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + FILE_NAME;
81         system(touchTar.c_str());
82         string touchManage = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + MANAGE_JSON;
83         system(touchManage.c_str());
84         string touchTmp = string("touch ") + localCap;
85         system(touchTmp.c_str());
86 
87         // 尝试匹配当前命令，成功后执行
88         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-restoreAsync";
89         vector<string_view> curOp;
90         curOp.emplace_back("restoreAsync");
__anonbb973b0c0202(const ToolsOp &op) 91         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
92         auto &&opeartions = ToolsOp::GetAllOperations();
93         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
94         if (matchedOp != opeartions.end()) {
95             auto ret = matchedOp->Execute(mapArgToVal);
96             EXPECT_EQ(ret, 0);
97         }
98         mapArgToVal.clear();
99     } catch (...) {
100         EXPECT_TRUE(false);
101         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
102     }
103     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end SUB_backup_tools_op_restore_async_0100";
104 }
105 
106 /**
107  * @tc.number: SUB_backup_tools_op_restore_async_0101
108  * @tc.name: SUB_backup_tools_op_restore_async_0101
109  * @tc.desc: 测试
110  * @tc.size: MEDIUM
111  * @tc.type: FUNC
112  * @tc.level Level 1
113  * @tc.require: I7L7A6
114  */
115 HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0101, testing::ext::TestSize.Level1)
116 {
117     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin SUB_backup_tools_op_restore_async_0100";
118     try {
119         string localCap = string(BConstants::SA_BUNDLE_BACKUP_TMP_DIR.data()) + "/tmp";
120         vector<string> path = { localCap.data() };
121         vector<string> bundles = { "com.example.app2backup" };
122         vector<string> userId = { "100" };
123         vector<string> restoreTypeF = { "false" };
124         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-info";
125         map<string, vector<string>> mapArgToVal;
126         mapArgToVal.insert(make_pair("pathCapFile", path));
127         mapArgToVal.insert(make_pair("bundles", bundles));
128         mapArgToVal.insert(make_pair("restoreType", restoreTypeF));
129         mapArgToVal.insert(make_pair("userId", userId));
130         vector<string_view> curOp;
131         curOp.emplace_back("restoreAsync");
132         auto &&opeartions = ToolsOp::GetAllOperations();
__anonbb973b0c0302(const ToolsOp &op) 133         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
134         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
135         if (matchedOp != opeartions.end()) {
136             auto ret = matchedOp->Execute(mapArgToVal);
137             EXPECT_EQ(ret, 0);
138         }
139         mapArgToVal.clear();
140     } catch (...) {
141         EXPECT_TRUE(false);
142         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
143     }
144     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end SUB_backup_tools_op_restore_async_0100";
145 }
146 
147 /**
148  * @tc.number: SUB_backup_tools_op_restore_async_0200
149  * @tc.name: SUB_backup_tools_op_restore_async_0200
150  * @tc.desc: 测试
151  * @tc.size: MEDIUM
152  * @tc.type: FUNC
153  * @tc.level Level 1
154  * @tc.require: I7L7A6
155  */
156 HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testing::ext::TestSize.Level1)
157 {
158     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin SUB_backup_tools_op_restore_async_0200";
159     try {
160         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-The pathCapFile field is not contained.";
161         map<string, vector<string>> mapArgToVal;
162         vector<string> bundles = {"com.example.app2backup"};
163         vector<string> path = {"/data/backup/tmp"};
164         mapArgToVal.insert(make_pair("bundles", bundles));
165         vector<string> restoreType = {"false"};
166         mapArgToVal.insert(make_pair("restoreType", restoreType));
167         vector<string> userId = {"100"};
168         mapArgToVal.insert(make_pair("userId", userId));
169 
170         vector<string_view> curOp;
171         curOp.emplace_back("restoreAsync");
__anonbb973b0c0402(const ToolsOp &op) 172         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
173         auto &&opeartions = ToolsOp::GetAllOperations();
174         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
175         int ret = 0;
176         if (matchedOp != opeartions.end()) {
177             ret = matchedOp->Execute(mapArgToVal);
178             EXPECT_NE(ret, 0);
179         }
180         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-The bundles field is not contained.";
181         mapArgToVal.clear();
182         if (matchedOp != opeartions.end()) {
183             mapArgToVal.insert(make_pair("pathCapFile", path));
184             ret = matchedOp->Execute(mapArgToVal);
185             EXPECT_NE(ret, 0);
186 
187             mapArgToVal.clear();
188             mapArgToVal.insert(make_pair("pathCapFile", path));
189             mapArgToVal.insert(make_pair("bundles", bundles));
190             ret = matchedOp->Execute(mapArgToVal);
191             EXPECT_NE(ret, 0);
192 
193             mapArgToVal.clear();
194             mapArgToVal.insert(make_pair("pathCapFile", path));
195             mapArgToVal.insert(make_pair("bundles", bundles));
196             mapArgToVal.insert(make_pair("restoreType", restoreType));
197             ret = matchedOp->Execute(mapArgToVal);
198             EXPECT_NE(ret, 0);
199 
200             mapArgToVal.clear();
201             ret = matchedOp->Execute(mapArgToVal);
202             EXPECT_NE(ret, 0);
203         }
204     } catch (...) {
205         EXPECT_TRUE(false);
206         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
207     }
208     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end SUB_backup_tools_op_restore_async_0200";
209 }
210 
211 /**
212  * @tc.number: SUB_backup_tools_op_restore_async_0300
213  * @tc.name: tools_op_restore_async_0300
214  * @tc.desc: 测试文件名包含BConstants::EXT_BACKUP_MANAGE,且tmpPath存在
215  * @tc.size: MEDIUM
216  * @tc.type: FUNC
217  * @tc.level Level 1
218  * @tc.require: I9JNFM
219  */
220 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0300, testing::ext::TestSize.Level1)
221 {
222     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0300";
223     try {
224         auto ctx = make_shared<SessionAsync>();
225         BFileInfo fileInfo;
226         fileInfo.owner = "test";
227         fileInfo.fileName = "manage.json";
228         fileInfo.sn = 1;
229         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
230         OnFileReady(ctx, fileInfo, move(fd), 0);
231     } catch (BError &e) {
232         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
233         EXPECT_TRUE(true);
234     } catch (...) {
235         EXPECT_TRUE(false);
236         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
237     }
238     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0300";
239 }
240 
241 /**
242  * @tc.number: SUB_backup_tools_op_restore_async_0301
243  * @tc.name: tools_op_restore_async_0301
244  * @tc.desc: 测试文件名不包含BConstants::EXT_BACKUP_MANAGE,且tmpPath存在
245  * @tc.size: MEDIUM
246  * @tc.type: FUNC
247  * @tc.level Level 1
248  * @tc.require: I9JNFM
249  */
250 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0301, testing::ext::TestSize.Level1)
251 {
252     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0301";
253     try {
254         auto ctx = make_shared<SessionAsync>();
255         BFileInfo fileInfo;
256         fileInfo.owner = "test";
257         fileInfo.fileName = "test.json";
258         fileInfo.sn = 1;
259         UniqueFd fd(open("text.txt", O_RDWR | O_CREAT, 0666));
260         OnFileReady(ctx, fileInfo, move(fd), 0);
261     } catch (BError &e) {
262         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
263         EXPECT_TRUE(true);
264     } catch (...) {
265         EXPECT_TRUE(false);
266         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
267     }
268     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0301";
269 }
270 
271 /**
272  * @tc.number: SUB_backup_tools_op_restore_async_0400
273  * @tc.name: tools_op_restore_async_0400
274  * @tc.desc: 测试当err=0时，不会调用UpdateBundleFinishedCount和TryNotify方法
275  * @tc.size: MEDIUM
276  * @tc.type: FUNC
277  * @tc.level Level 1
278  * @tc.require: I9JNFM
279  */
280 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0400, testing::ext::TestSize.Level1)
281 {
282     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0400";
283     try {
284         auto ctx = make_shared<SessionAsync>();
285         ErrCode err = 0;
286         BundleName name = "testBundle";
287         OnBundleStarted(ctx, err, name);
288         EXPECT_TRUE(true);
289     } catch (...) {
290         EXPECT_TRUE(false);
291         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
292     }
293     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0400";
294 }
295 
296 /**
297  * @tc.number: SUB_backup_tools_op_restore_async_0401
298  * @tc.name: tools_op_restore_async_0401
299  * @tc.desc: test func
300  * @tc.size: MEDIUM
301  * @tc.type: FUNC
302  * @tc.level Level 1
303  * @tc.require: I9JNFM
304  */
305 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0401, testing::ext::TestSize.Level1)
306 {
307     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0401";
308     try {
309         auto ctx = make_shared<SessionAsync>();
310         ctx->cnt_ = 1;
311         ErrCode err = -1;
312         BundleName name = "testBundle";
313         OnBundleStarted(ctx, err, name);
314         EXPECT_TRUE(true);
315     } catch (...) {
316         EXPECT_TRUE(false);
317         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
318     }
319     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0401";
320 }
321 
322 /**
323  * @tc.number: SUB_backup_tools_op_restore_async_0500
324  * @tc.name: tools_op_restore_async_0500
325  * @tc.desc: 测试OnBundleFinished方法
326  * @tc.size: MEDIUM
327  * @tc.type: FUNC
328  * @tc.level Level 1
329  * @tc.require: I9JNFM
330  */
331 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0500, testing::ext::TestSize.Level1)
332 {
333     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0500";
334     try {
335         auto ctx = make_shared<SessionAsync>();
336         ErrCode err = 0;
337         BundleName name = "testBundle";
338         OnBundleFinished(ctx, err, name);
339         EXPECT_TRUE(true);
340     } catch (...) {
341         EXPECT_TRUE(false);
342         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
343     }
344     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0500";
345 }
346 
347 /**
348  * @tc.number: SUB_backup_tools_op_restore_async_0501
349  * @tc.name: tools_op_restore_async_0501
350  * @tc.desc: 测试OnBundleFinished方法
351  * @tc.size: MEDIUM
352  * @tc.type: FUNC
353  * @tc.level Level 1
354  * @tc.require: I9JNFM
355  */
356 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0501, testing::ext::TestSize.Level1)
357 {
358     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0501";
359     try {
360         auto ctx = make_shared<SessionAsync>();
361         ctx->cnt_ = 1;
362         ErrCode err = -1;
363         BundleName name = "testBundle";
364         OnBundleFinished(ctx, err, name);
365         EXPECT_TRUE(true);
366     } catch (...) {
367         EXPECT_TRUE(false);
368         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
369     }
370     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0501";
371 }
372 
373 /**
374  * @tc.number: SUB_backup_tools_op_restore_async_0600
375  * @tc.name: tools_op_restore_async_0600
376  * @tc.desc: 测试OnAllBundlesFinished方法
377  * @tc.size: MEDIUM
378  * @tc.type: FUNC
379  * @tc.level Level 1
380  * @tc.require: I9JNFM
381  */
382 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0600, testing::ext::TestSize.Level1)
383 {
384     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0600";
385     try {
386         auto ctx = make_shared<SessionAsync>();
387         ErrCode err = 0;
388         OnAllBundlesFinished(ctx, err);
389         EXPECT_TRUE(true);
390     } catch (...) {
391         EXPECT_TRUE(false);
392         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
393     }
394     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0600";
395 }
396 
397 /**
398  * @tc.number: SUB_backup_tools_op_restore_async_0700
399  * @tc.name: tools_op_restore_async_0700
400  * @tc.desc: 测试OnResultReport方法
401  * @tc.size: MEDIUM
402  * @tc.type: FUNC
403  * @tc.level Level 1
404  * @tc.require: I9JNFM
405  */
406 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0700, testing::ext::TestSize.Level1)
407 {
408     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0700";
409     try {
410         auto ctx = make_shared<SessionAsync>();
411         std::string bundleName = "com.example.app2backup";
412         std::string resultInfo = "test result info";
413         OnResultReport(ctx, bundleName, resultInfo);
414         EXPECT_TRUE(true);
415     } catch (...) {
416         EXPECT_TRUE(false);
417         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
418     }
419     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0700";
420 }
421 
422 /**
423  * @tc.number: SUB_backup_tools_op_restore_async_0800
424  * @tc.name: tools_op_restore_async_0800
425  * @tc.desc: 测试OnBackupServiceDied方法
426  * @tc.size: MEDIUM
427  * @tc.type: FUNC
428  * @tc.level Level 1
429  * @tc.require: I9JNFM
430  */
431 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0800, testing::ext::TestSize.Level1)
432 {
433     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0800";
434     try {
435         auto ctx = make_shared<SessionAsync>();
436         OnBackupServiceDied(ctx);
437         EXPECT_TRUE(true);
438     } catch (...) {
439         EXPECT_TRUE(false);
440         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
441     }
442     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0800";
443 }
444 
445 /**
446  * @tc.number: SUB_backup_tools_op_restore_async_0900
447  * @tc.name: tools_op_restore_async_0900
448  * @tc.desc: 测试AdapteCloneOptimize方法路径存在
449  * @tc.size: MEDIUM
450  * @tc.type: FUNC
451  * @tc.level Level 1
452  * @tc.require: I9JNFM
453  */
454 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_0900, testing::ext::TestSize.Level1)
455 {
456     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_0900";
457     try {
458         string path = "/data/backup/receive";
459         AdapteCloneOptimize(path);
460         EXPECT_TRUE(true);
461     } catch (...) {
462         EXPECT_TRUE(false);
463         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
464     }
465     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_0900";
466 }
467 
468 /**
469  * @tc.number: SUB_backup_tools_op_restore_async_1000
470  * @tc.name: tools_op_restore_async_1000
471  * @tc.desc: 测试restore为空的情况
472  * @tc.size: MEDIUM
473  * @tc.type: FUNC
474  * @tc.level Level 1
475  * @tc.require: I9JNFM
476  */
477 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1000, testing::ext::TestSize.Level1)
478 {
479     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1000";
480     try {
481         vector<BundleName> bundleNames;
482         RestoreApp(nullptr, bundleNames);
483     } catch (BError &e) {
484         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
485         EXPECT_TRUE(true);
486     } catch (...) {
487         EXPECT_TRUE(false);
488         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
489     }
490     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1000";
491 }
492 
493 /**
494  * @tc.number: SUB_backup_tools_op_restore_async_1001
495  * @tc.name: tools_op_restore_async_1001
496  * @tc.desc: 测试restore不为空bundlename包含'/'的情况
497  * @tc.size: MEDIUM
498  * @tc.type: FUNC
499  * @tc.level Level 1
500  * @tc.require: I9JNFM
501  */
502 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1001, testing::ext::TestSize.Level1)
503 {
504     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1001";
505     try {
506         vector<BundleName> bundleNames;
507         bundleNames.push_back("bundle/name");
508         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
509         restore->session_ = {};
510         RestoreApp(restore, bundleNames);
511     } catch (BError &e) {
512         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
513         EXPECT_TRUE(true);
514     } catch (...) {
515         EXPECT_TRUE(false);
516         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
517     }
518     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1001";
519 }
520 
521 /**
522  * @tc.number: SUB_backup_tools_op_restore_async_1002
523  * @tc.name: tools_op_restore_async_1002
524  * @tc.desc: 测试正常情况
525  * @tc.size: MEDIUM
526  * @tc.type: FUNC
527  * @tc.level Level 1
528  * @tc.require: I9JNFM
529  */
530 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1002, testing::ext::TestSize.Level1)
531 {
532     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1002";
533     try {
534         vector<BundleName> bundleNames;
535         bundleNames.push_back("bundlename");
536         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
537         restore->session_ = {};
538         RestoreApp(restore, bundleNames);
539     } catch (BError &e) {
540         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
541         EXPECT_TRUE(true);
542     } catch (...) {
543         EXPECT_TRUE(false);
544         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
545     }
546     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1002";
547 }
548 
549 /**
550  * @tc.number: SUB_backup_tools_op_restore_async_1100
551  * @tc.name: tools_op_restore_async_1100
552  * @tc.desc: 测试正type =false 的情况
553  * @tc.size: MEDIUM
554  * @tc.type: FUNC
555  * @tc.level Level 1
556  * @tc.require: I9JNFM
557  */
558 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1100, testing::ext::TestSize.Level1)
559 {
560     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1100";
561     try {
562         string pathCapFile = "/data/user/0/test/files/bundleInfo.json";
563         vector<string> bundleNames = {"bundlenames"};
564         string type = "false";
565         int32_t ret = ChangeBundleInfo(pathCapFile, bundleNames, type);
566         EXPECT_LT(ret, 0);
567     } catch (...) {
568         EXPECT_TRUE(false);
569         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
570     }
571     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1100";
572 }
573 
574 /**
575  * @tc.number: SUB_backup_tools_op_restore_async_1101
576  * @tc.name: tools_op_restore_async_1101
577  * @tc.desc: 测试正打开失败的情况
578  * @tc.size: MEDIUM
579  * @tc.type: FUNC
580  * @tc.level Level 1
581  * @tc.require: I9JNFM
582  */
583 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1101, testing::ext::TestSize.Level1)
584 {
585     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1101";
586     try {
587         string pathCapFile = " ";
588         vector<string> bundleNames = {"bundlenames"};
589         string type = "false";
590         int32_t ret = ChangeBundleInfo(pathCapFile, bundleNames, type);
591         EXPECT_LT(ret, 0);
592     } catch (...) {
593         EXPECT_TRUE(false);
594         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
595     }
596     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1101";
597 }
598 
599 /**
600  * @tc.number: SUB_backup_tools_op_restore_async_1102
601  * @tc.name: tools_op_restore_async_1102
602  * @tc.desc: 测试正打开失败的情况
603  * @tc.size: MEDIUM
604  * @tc.type: FUNC
605  * @tc.level Level 1
606  * @tc.require: I9JNFM
607  */
608 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1102, testing::ext::TestSize.Level1)
609 {
610     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1102";
611     try {
612         string pathCapFile = "/data/user/0/test/files/bundleInfo.json";
613         vector<string> bundleNames = {};
614         string type = "true";
615         int32_t ret = ChangeBundleInfo(pathCapFile, bundleNames, type);
616         EXPECT_LT(ret, 0);
617     } catch (...) {
618         EXPECT_TRUE(false);
619         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
620     }
621     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1102";
622 }
623 
624 /**
625  * @tc.number: SUB_backup_tools_op_restore_async_1200
626  * @tc.name: tools_op_restore_async_1200
627  * @tc.desc: 测试当BExcepUltils::VerifyPath方法抛出异常时
628  * @tc.size: MEDIUM
629  * @tc.type: FUNC
630  * @tc.level Level 1
631  * @tc.require: I9JNFM
632  */
633 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1200, testing::ext::TestSize.Level1)
634 {
635     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1200";
636     try {
637         string pathCapFile = "invalid/path";
638         vector<string> bundleNames = {"bundle1", "bundle2"};
639         string type = "true";
640         string userId = "123456";
641         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
642         AppendBundles(restore, pathCapFile, bundleNames, type, userId);
643     } catch (BError &e) {
644         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
645     } catch (...) {
646         EXPECT_TRUE(false);
647         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
648     }
649     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1200";
650 }
651 
652 /**
653  * @tc.number: SUB_backup_tools_op_restore_async_1201
654  * @tc.name: tools_op_restore_async_1201
655  * @tc.desc: 测试当open方法返回错误时
656  * @tc.size: MEDIUM
657  * @tc.type: FUNC
658  * @tc.level Level 1
659  * @tc.require: I9JNFM
660  */
661 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1201, testing::ext::TestSize.Level1)
662 {
663     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1201";
664     try {
665         string pathCapFile = " ";
666         vector<string> bundleNames = {"bundle1", "bundle2"};
667         string type = "true";
668         string userId = "123456";
669         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
670         EXPECT_EQ(-errno, AppendBundles(restore, pathCapFile, bundleNames, type, userId));
671     } catch (...) {
672         EXPECT_TRUE(false);
673         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
674     }
675     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1201";
676 }
677 
678 /**
679  * @tc.number: SUB_backup_tools_op_restore_async_1202
680  * @tc.name: tools_op_restore_async_1202
681  * @tc.desc: 测试当type = "true"
682  * @tc.size: MEDIUM
683  * @tc.type: FUNC
684  * @tc.level Level 1
685  * @tc.require: I9JNFM
686  */
687 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1202, testing::ext::TestSize.Level1)
688 {
689     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1202";
690     try {
691         string pathCapFile = "/invalid/path";
692         vector<string> bundleNames = {"bundle1", "bundle2"};
693         string type = "true";
694         string userId = "123456";
695         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
696         int32_t ret = AppendBundles(restore, pathCapFile, bundleNames, type, userId);
697         EXPECT_LT(ret, 0);
698     } catch (...) {
699         EXPECT_TRUE(false);
700         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
701     }
702     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1202";
703 }
704 
705 /**
706  * @tc.number: SUB_backup_tools_op_restore_async_1204
707  * @tc.name: tools_op_restore_async_1204
708  * @tc.desc: 测试AppendBundles方法抛出异常
709  * @tc.size: MEDIUM
710  * @tc.type: FUNC
711  * @tc.level Level 1
712  * @tc.require: I9JNFM
713  */
714 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1204, testing::ext::TestSize.Level1)
715 {
716     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1204";
717     try {
718         string pathCapFile = "/invalid/path";
719         vector<string> bundleNames = {"bun/dle1"};
720         string type = "false";
721         string userId = "123456";
722         shared_ptr<SessionAsync> restore = make_shared<SessionAsync>();
723         int32_t ret = AppendBundles(restore, pathCapFile, bundleNames, type, userId);
724         EXPECT_LT(ret, 0);
725     } catch (...) {
726         EXPECT_TRUE(false);
727         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
728     }
729     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1204";
730 }
731 
732 /**
733  * @tc.number: SUB_backup_tools_op_restore_async_1300
734  * @tc.name: tools_op_restore_async_1300
735  * @tc.desc: 测试InitArg方法中ChangeBundleInfo返回false的情况
736  * @tc.size: MEDIUM
737  * @tc.type: FUNC
738  * @tc.level Level 1
739  * @tc.require: I9JNFM
740  */
741 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1300, testing::ext::TestSize.Level1)
742 {
743     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1300";
744     try {
745         string pathCapFile = " ";
746         vector<string> bundleNames = {"bundle1", "bundle2"};
747         string type = "type1";
748         string userId = "user1";
749         EXPECT_EQ(InitArg(pathCapFile, bundleNames, type, userId), -errno);
750     } catch (...) {
751         EXPECT_TRUE(false);
752         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
753     }
754     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1300";
755 }
756 
757 /**
758  * @tc.number: SUB_backup_tools_op_restore_async_1301
759  * @tc.name: tools_op_restore_async_1301
760  * @tc.desc: 测试InitArg正常
761  * @tc.size: MEDIUM
762  * @tc.type: FUNC
763  * @tc.level Level 1
764  * @tc.require: I9NOPD
765  */
766 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1301, testing::ext::TestSize.Level1)
767 {
768     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1301";
769     try {
770         string pathCapFile = "/data/test/tmp";
771         int fd = open(pathCapFile.data(), O_RDWR | O_CREAT, S_IRWXU);
772         EXPECT_GT(fd, 0);
773         close(fd);
774         vector<string> bundleNames = {"com.example.app2backup"};
775         string type = "true";
776         string userId = "100";
777         EXPECT_EQ(InitArg(pathCapFile, bundleNames, type, userId), 0);
778     } catch (...) {
779         EXPECT_TRUE(false);
780         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
781     }
782     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1301";
783 }
784 
785 /**
786  * @tc.number: SUB_backup_tools_op_restore_async_1400
787  * @tc.name: tools_op_restore_async_1400
788  * @tc.desc: 测试包含所有参数的情况
789  * @tc.size: MEDIUM
790  * @tc.type: FUNC
791  * @tc.level Level 1
792  * @tc.require: I9NOPD
793  */
794 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1400, testing::ext::TestSize.Level1)
795 {
796     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1400";
797     try {
798         map<string, vector<string>> mapArgToVal;
799         mapArgToVal["pathCapFile"] = {"/tmp/"};
800         mapArgToVal["bundles"] = {"com.example.app2backup"};
801         mapArgToVal["restoreType"] = {"true"};
802         mapArgToVal["userId"] = {"100"};
803         int ret = Exec(mapArgToVal);
804         EXPECT_LT(ret, 0);
805     } catch (...) {
806         EXPECT_TRUE(false);
807         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
808     }
809     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1400";
810 }
811 
812 /**
813  * @tc.number: SUB_backup_tools_op_restore_async_1401
814  * @tc.name: tools_op_restore_async_1401
815  * @tc.desc: 测试不包含所有参数的情况
816  * @tc.size: MEDIUM
817  * @tc.type: FUNC
818  * @tc.level Level 1
819  * @tc.require: I9NOPD
820  */
821 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1401, testing::ext::TestSize.Level1)
822 {
823     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1401";
824     try {
825         map<string, vector<string>> mapArgToVal;
826         int ret = Exec(mapArgToVal);
827         EXPECT_EQ(ret, -EPERM);
828     } catch (...) {
829         EXPECT_TRUE(false);
830         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
831     }
832     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1401";
833 }
834 
835 /**
836  * @tc.number: SUB_backup_tools_op_restore_async_1500
837  * @tc.name: tools_op_restore_async_1500
838  * @tc.desc: test func
839  * @tc.size: MEDIUM
840  * @tc.type: FUNC
841  * @tc.level Level 1
842  * @tc.require: I9NOPD
843  */
844 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1500, testing::ext::TestSize.Level1)
845 {
846     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1500";
847     try {
848         std::string path = "/data/backup/receive";
849         std::vector<ExtManageInfo> pkgInfo;
850         ExtManageInfo info;
851         info.hashName = "hashName";
852         info.fileName = "fileName";
853         info.isBigFile = false;
854         info.isUserTar = false;
855         pkgInfo.push_back(info);
856 
857         auto result = ReadyExtManage(path, pkgInfo);
858         EXPECT_EQ(result.size(), 1);
859     } catch (...) {
860         EXPECT_TRUE(false);
861         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
862     }
863     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1500";
864 }
865 
866 /**
867  * @tc.number: SUB_backup_tools_op_restore_async_1501
868  * @tc.name: tools_op_restore_async_1501
869  * @tc.desc: test func
870  * @tc.size: MEDIUM
871  * @tc.type: FUNC
872  * @tc.level Level 1
873  * @tc.require: I9NOPD
874  */
875 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1501, testing::ext::TestSize.Level1)
876 {
877     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1501";
878     try {
879         std::string path = "/data/backup/receive";
880         std::vector<ExtManageInfo> pkgInfo;
881         ExtManageInfo info;
882         info.hashName = "";
883         info.fileName = "";
884         info.isBigFile = false;
885         info.isUserTar = false;
886         pkgInfo.push_back(info);
887 
888         auto result = ReadyExtManage(path, pkgInfo);
889         EXPECT_EQ(result.size(), 0);
890     } catch (...) {
891         EXPECT_TRUE(false);
892         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
893     }
894     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1501";
895 }
896 
897 /**
898  * @tc.number: SUB_backup_tools_op_restore_async_1502
899  * @tc.name: tools_op_restore_async_1502
900  * @tc.desc: test func
901  * @tc.size: MEDIUM
902  * @tc.type: FUNC
903  * @tc.level Level 1
904  * @tc.require: I9NOPD
905  */
906 HWTEST_F(ToolsOpRestoreAsyncTest, tools_op_restore_async_1502, testing::ext::TestSize.Level1)
907 {
908     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin tools_op_restore_async_1502";
909     try {
910         std::string path = "/data/backup/receive";
911         std::vector<ExtManageInfo> pkgInfo;
912         ExtManageInfo info;
913         info.hashName = "hashName";
914         info.fileName = "fileName";
915         info.isBigFile = true;
916         info.isUserTar = true;
917         pkgInfo.push_back(info);
918 
919         auto result = ReadyExtManage(path, pkgInfo);
920         EXPECT_EQ(result.size(), 1);
921     } catch (...) {
922         EXPECT_TRUE(false);
923         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
924     }
925     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-end tools_op_restore_async_1502";
926 }
927 } // namespace OHOS::FileManagement::Backup