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 <iostream>
17 #include <map>
18 #include <sstream>
19 
20 #include <gtest/gtest.h>
21 
22 #include "b_resources/b_constants.h"
23 #include "tools_op.h"
24 #include "tools_op_backup.h"
25 #include "utils_mock_global_variable.h"
26 
27 namespace OHOS::FileManagement::Backup {
28 using namespace std;
29 class ToolsOpBackupTest : public testing::Test {
30 public:
SetUpTestCase(void)31     static void SetUpTestCase(void) {};
TearDownTestCase()32     static void TearDownTestCase() {};
SetUp()33     void SetUp() {};
TearDown()34     void TearDown() {};
35 };
36 
PerformBackupOperation(map<string,vector<string>> & mapArgToVal)37 static void PerformBackupOperation(map<string, vector<string>> &mapArgToVal)
38 {
39     GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
40     vector<string_view> curOp;
41     curOp.emplace_back("backup");
42     auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
43     auto &&opeartions = ToolsOp::GetAllOperations();
44     auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
45     if (matchedOp != opeartions.end()) {
46         auto ret = matchedOp->Execute(mapArgToVal);
47         EXPECT_EQ(ret, 0);
48     }
49 }
50 
PrepareBackupArguments()51 static map<string, vector<string>> PrepareBackupArguments()
52 {
53     map<string, vector<string>> mapArgToVal;
54     vector<string> path = {"/data/backup/tmp"};
55     mapArgToVal.insert(make_pair("pathCapFile", path));
56     vector<string> bundles = {"com.example.app2backup", "com.example.app3backup", "com.example.app4backup"};
57     mapArgToVal.insert(make_pair("bundles", bundles));
58     vector<string> local = {"false"};
59     mapArgToVal.insert(make_pair("isLocal", local));
60 
61     return mapArgToVal;
62 }
63 
64 /**
65  * @tc.number: SUB_backup_tools_op_backup_0100
66  * @tc.name: SUB_backup_tools_op_backup_0100
67  * @tc.desc: 测试backup流程
68  * @tc.size: MEDIUM
69  * @tc.type: FUNC
70  * @tc.level Level 1
71  * @tc.require: I6F3GV
72  */
73 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0100, testing::ext::TestSize.Level1)
74 {
75     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0100";
76     try {
77         SetMockGetInstance(true);
78         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
79         map<string, vector<string>> mapArgToVal;
80         string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp";
81         vector<string> path = {localCap.data()};
82         mapArgToVal.insert(make_pair("pathCapFile", path));
83         vector<string> bundles = {"com.example.app2backup"};
84         mapArgToVal.insert(make_pair("bundles", bundles));
85         vector<string> local = {"true"};
86         mapArgToVal.insert(make_pair("isLocal", local));
87 
88         // 尝试匹配当前命令，成功后执行
89         PerformBackupOperation(mapArgToVal);
90     } catch (...) {
91         EXPECT_TRUE(false);
92         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
93     }
94     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0100";
95 }
96 
97 /**
98  * @tc.number: SUB_backup_tools_op_backup_0200
99  * @tc.name: SUB_backup_tools_op_backup_0200
100  * @tc.desc: 测试Exec分支
101  * @tc.size: MEDIUM
102  * @tc.type: FUNC
103  * @tc.level Level 1
104  * @tc.require: I6F3GV
105  */
106 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestSize.Level1)
107 {
108     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0200";
109     try {
110         GTEST_LOG_(INFO) << "ToolsOpBackupTest-The pathCapFile field is not contained.";
111         map<string, vector<string>> mapArgToVal;
112         vector<string> bundles = {"com.example.app2backup"};
113         vector<string> path = {"/data/backup/tmp"};
114         vector<string> local = {"true"};
115         mapArgToVal.insert(make_pair("bundles", bundles));
116         mapArgToVal.insert(make_pair("isLocal", local));
117 
118         vector<string_view> curOp;
119         curOp.emplace_back("backup");
__anonb7f0dea10202(const ToolsOp &op) 120         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
121         auto &&opeartions = ToolsOp::GetAllOperations();
122         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
123         int ret = 0;
124         if (matchedOp != opeartions.end()) {
125             ret = matchedOp->Execute(mapArgToVal);
126             EXPECT_NE(ret, 0);
127         }
128 
129         GTEST_LOG_(INFO) << "ToolsOpBackupTest-The bundles field is noGt contained.";
130         mapArgToVal.clear();
131         mapArgToVal.insert(make_pair("pathCapFile", path));
132         mapArgToVal.insert(make_pair("isLocal", local));
133         if (matchedOp != opeartions.end()) {
134             ret = matchedOp->Execute(mapArgToVal);
135             EXPECT_NE(ret, 0);
136         }
137 
138         GTEST_LOG_(INFO) << "ToolsOpBackupTest-The isLocal field is noGt contained.";
139         mapArgToVal.clear();
140         mapArgToVal.insert(make_pair("pathCapFile", path));
141         mapArgToVal.insert(make_pair("bundles", bundles));
142         if (matchedOp != opeartions.end()) {
143             ret = matchedOp->Execute(mapArgToVal);
144             EXPECT_NE(ret, 0);
145         }
146 
147         mapArgToVal.clear();
148         if (matchedOp != opeartions.end()) {
149             ret = matchedOp->Execute(mapArgToVal);
150             EXPECT_NE(ret, 0);
151         }
152     } catch (...) {
153         EXPECT_TRUE(false);
154         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
155     }
156     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0200";
157 }
158 
159 /**
160  * @tc.number: SUB_backup_tools_op_backup_0300
161  * @tc.name: SUB_backup_tools_op_backup_0300
162  * @tc.desc: 测试Exec分支
163  * @tc.size: MEDIUM
164  * @tc.type: FUNC
165  * @tc.level Level 1
166  * @tc.require: I6F3GV
167  */
168 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0300, testing::ext::TestSize.Level1)
169 {
170     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0300";
171     try {
172         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
173         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
174 
175         // 尝试匹配当前命令，成功后执行
176         PerformBackupOperation(mapArgToVal);
177     } catch (...) {
178         EXPECT_TRUE(false);
179         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
180     }
181     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0300";
182 }
183 
184 /**
185  * @tc.number: SUB_backup_tools_op_backup_0400
186  * @tc.name: SUB_backup_tools_op_backup_0400
187  * @tc.desc: 测试InitPathCapFile分支
188  * @tc.size: MEDIUM
189  * @tc.type: FUNC
190  * @tc.level Level 1
191  * @tc.require: I6F3GV
192  */
193 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0400, testing::ext::TestSize.Level1)
194 {
195     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0400";
196     try {
197         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
198         BackUpRegister();
199         map<string, vector<string>> mapArgToVal;
200         vector<string> path = {"/data/backup/tmp"};
201         mapArgToVal.insert(make_pair("pathCapFile", path));
202         vector<string> bundles = {"com.example.app2backup", "com.example.app3backup", "com.example.app4backup"};
203         mapArgToVal.insert(make_pair("bundles", bundles));
204         vector<string> local = {"false"};
205         mapArgToVal.insert(make_pair("isLocal", local));
206 
207         // 尝试匹配当前命令，成功后执行
208         PerformBackupOperation(mapArgToVal);
209     } catch (...) {
210         EXPECT_TRUE(false);
211         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
212     }
213     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0400";
214 }
215 
216 /**
217  * @tc.number: SUB_backup_tools_op_backup_0500
218  * @tc.name: SUB_backup_tools_op_backup_0500
219  * @tc.desc: 测试OnAllBundlesFinished分支
220  * @tc.size: MEDIUM
221  * @tc.type: FUNC
222  * @tc.level Level 1
223  * @tc.require: I6F3GV
224  */
225 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0500, testing::ext::TestSize.Level1)
226 {
227     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0500";
228     try {
229         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
230         BackUpRegister();
231         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
232 
233         // 尝试匹配当前命令，成功后执行
234         PerformBackupOperation(mapArgToVal);
235     } catch (...) {
236         EXPECT_TRUE(false);
237         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
238     }
239     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0500";
240 }
241 
242 /**
243  * @tc.number: SUB_backup_tools_op_backup_0600
244  * @tc.name: SUB_backup_tools_op_backup_0600
245  * @tc.desc: 测试InitPathCapFile分支
246  * @tc.size: MEDIUM
247  * @tc.type: FUNC
248  * @tc.level Level 1
249  * @tc.require: I6F3GV
250  */
251 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0600, testing::ext::TestSize.Level1)
252 {
253     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0600";
254     try {
255         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
256         BackUpRegister();
257         rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data());
258         mkdir((BConstants::BACKUP_TOOL_LINK_DIR).data(), S_IRWXO);
259         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
260 
261         // 尝试匹配当前命令，成功后执行
262         PerformBackupOperation(mapArgToVal);
263         rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data());
264     } catch (...) {
265         EXPECT_TRUE(false);
266         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
267     }
268     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0600";
269 }
270 
271 /**
272  * @tc.number: SUB_backup_tools_op_backup_0700
273  * @tc.name: SUB_backup_tools_op_backup_0700
274  * @tc.desc: 测试InitPathCapFile分支
275  * @tc.size: MEDIUM
276  * @tc.type: FUNC
277  * @tc.level Level 1
278  * @tc.require: I6F3GV
279  */
280 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0700, testing::ext::TestSize.Level1)
281 {
282     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0700";
283     try {
284         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
285         BackUpRegister();
286         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
287 
288         // 尝试匹配当前命令，成功后执行
289         PerformBackupOperation(mapArgToVal);
290     } catch (...) {
291         EXPECT_TRUE(false);
292         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
293     }
294     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0700";
295 }
296 
297 /**
298  * @tc.number: SUB_backup_tools_op_backup_0900
299  * @tc.name: SUB_backup_tools_op_backup_0900
300  * @tc.desc: 测试BackupToolDirSoftlinkToBackupDir分支
301  * @tc.size: MEDIUM
302  * @tc.type: FUNC
303  * @tc.level Level 1
304  * @tc.require: I6F3GV
305  */
306 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0900, testing::ext::TestSize.Level1)
307 {
308     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0900";
309     try {
310         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
311         BackUpRegister();
312         rmdir(BConstants::BACKUP_TOOL_LINK_DIR.data());
313         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
314 
315         // 尝试匹配当前命令，成功后执行
316         PerformBackupOperation(mapArgToVal);
317     } catch (...) {
318         EXPECT_TRUE(false);
319         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
320     }
321     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0900";
322 }
323 
324 /**
325  * @tc.number: SUB_backup_tools_op_backup_1000
326  * @tc.name: SUB_backup_tools_op_backup_1000
327  * @tc.desc: 测试InitPathCapFile分支
328  * @tc.size: MEDIUM
329  * @tc.type: FUNC
330  * @tc.level Level 1
331  * @tc.require: I6F3GV
332  */
333 HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_1000, testing::ext::TestSize.Level1)
334 {
335     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_1000";
336     try {
337         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
338         BackUpRegister();
339         string cmdusermod = string("usermod -u 1000") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data();
340         system(cmdusermod.c_str());
341         map<string, vector<string>> mapArgToVal = PrepareBackupArguments();
342 
343         // 尝试匹配当前命令，成功后执行
344         PerformBackupOperation(mapArgToVal);
345         rmdir((BConstants::BACKUP_TOOL_RECEIVE_DIR).data());
346     } catch (...) {
347         EXPECT_TRUE(false);
348         GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
349     }
350     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_1000";
351 }
352 } // namespace OHOS::FileManagement::Backup