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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <memory>
19 #include <sys/ioctl.h>
20 #include "log/log.h"
21 #include "securec.h"
22 #include "updater/updater_const.h"
23 #include "updater/updater.h"
24 #include "sdcard_update/sdcard_update.h"
25 #include "fs_manager/mount.h"
26 #include "misc_info/misc_info.h"
27 #include "updater_main.h"
28 #include "updater_ui_stub.h"
29 #include "utils.h"
30 
31 using namespace Updater;
32 using namespace std;
33 using namespace testing::ext;
34 
35 namespace {
36 constexpr uint32_t MAX_ARG_SIZE = 24;
37 class UpdaterUtilUnitTest : public testing::Test {
38 public:
UpdaterUtilUnitTest()39     UpdaterUtilUnitTest()
40     {
41         InitUpdaterLogger("UPDATER", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH);
42     }
~UpdaterUtilUnitTest()43     ~UpdaterUtilUnitTest() {}
44 
SetUpTestCase(void)45     static void SetUpTestCase(void) {}
TearDownTestCase(void)46     static void TearDownTestCase(void) {}
SetUp()47     void SetUp() {}
TearDown()48     void TearDown() {}
TestBody()49     void TestBody() {}
50 };
51 
HWTEST_F(UpdaterUtilUnitTest, DeleteUpdaterPath, TestSize.Level1)52 HWTEST_F(UpdaterUtilUnitTest, DeleteUpdaterPath, TestSize.Level1)
53 {
54     std::string path = "/data/test/test/test";
55     bool ret = DeleteUpdaterPath(path);
56     EXPECT_EQ(ret, true);
57 
58     path = "/data/test";
59     ret = DeleteUpdaterPath(path);
60     EXPECT_EQ(ret, true);
61 }
62 
HWTEST_F(UpdaterUtilUnitTest, ClearMisc, TestSize.Level1)63 HWTEST_F(UpdaterUtilUnitTest, ClearMisc, TestSize.Level1)
64 {
65     bool ret = ClearMisc();
66     EXPECT_EQ(ret, true);
67 }
68 
HWTEST_F(UpdaterUtilUnitTest, IsSDCardExist, TestSize.Level1)69 HWTEST_F(UpdaterUtilUnitTest, IsSDCardExist, TestSize.Level1)
70 {
71     std::string sdcardStr = "";
72     bool ret = IsSDCardExist(sdcardStr);
73     EXPECT_EQ(ret, false);
74 }
75 
HWTEST_F(UpdaterUtilUnitTest, IsFlashd, TestSize.Level1)76 HWTEST_F(UpdaterUtilUnitTest, IsFlashd, TestSize.Level1)
77 {
78     EXPECT_EQ(IsFlashd({"boot_updater", "", "boot_flash"}), true);
79     EXPECT_EQ(IsFlashd({"boot_updater", "", ""}), false);
80 }
81 
HWTEST_F(UpdaterUtilUnitTest, IsUpdater, TestSize.Level1)82 HWTEST_F(UpdaterUtilUnitTest, IsUpdater, TestSize.Level1)
83 {
84     EXPECT_EQ(IsUpdater({"boot_updater", "", ""}), true);
85     EXPECT_EQ(IsUpdater({"boot_updater", "", "boot_flash"}), false);
86     EXPECT_EQ(IsUpdater({"boot_updater", "", "xxx"}), true);
87 }
88 
HWTEST_F(UpdaterUtilUnitTest, SelectMode, TestSize.Level1)89 HWTEST_F(UpdaterUtilUnitTest, SelectMode, TestSize.Level1)
90 {
91     // clear already registered mode
92     GetBootModes().clear();
93 
94     auto dummyEntry = [] (int argc, char **argv) -> int { return 0; };
95     // register modes
96     RegisterMode({ IsFlashd, "FLASHD", "", dummyEntry });
97     RegisterMode({ IsUpdater, "UPDATER", "", dummyEntry });
98 
99     // test select mode
100     auto mode = SelectMode({"boot_updater", "", ""});
101     ASSERT_NE(mode, std::nullopt);
102     EXPECT_EQ(mode->modeName, "UPDATER");
103 
104     mode = SelectMode({"boot_updater", "", "boot_flash"});
105     ASSERT_NE(mode, std::nullopt);
106     EXPECT_EQ(mode->modeName, "FLASHD");
107 
108     mode = SelectMode({"invalid_command", "", ""});
109     EXPECT_EQ(mode, std::nullopt);
110 }
111 
HWTEST_F(UpdaterUtilUnitTest, ParseParams, TestSize.Level1)112 HWTEST_F(UpdaterUtilUnitTest, ParseParams, TestSize.Level1)
113 {
114     UpdateMessage boot {};
115     std::string commandMsg = "";
116     std::string updateMsg = "";
117     const std::string commandFile = "/data/updater/command";
118     auto fp = std::unique_ptr<FILE, decltype(&fclose)>(fopen(commandFile.c_str(), "wb"), fclose);
119     EXPECT_NE(fp, nullptr);
120     EXPECT_EQ(strncpy_s(boot.command, sizeof(boot.command) - 1, commandMsg.c_str(), commandMsg.size()), 0);
121     EXPECT_EQ(strncpy_s(boot.update, sizeof(boot.update) - 1, updateMsg.c_str(), updateMsg.size()), 0);
122     bool bRet = WriteUpdaterMessage(commandFile, boot);
123     EXPECT_EQ(bRet, true);
124     char **argv = new char*[1];
125     argv[0] = new char[MAX_ARG_SIZE];
126     std::string str = "./UpdaterMain";
127     EXPECT_EQ(strncpy_s(argv[0], MAX_ARG_SIZE, str.c_str(), str.size()), 0);
128     int argc = 1;
129     std::vector<std::string> args = Utils::ParseParams(argc, argv);
130     std::string res = "";
131     for (auto s : args) {
132         res += s;
133     }
134     EXPECT_EQ("./UpdaterMain", res);
135 
136     commandMsg = "boot_updater";
137     updateMsg = "--update_package=updater_full.zip";
138     EXPECT_EQ(strncpy_s(boot.command, sizeof(boot.command) - 1, commandMsg.c_str(), commandMsg.size()), 0);
139     EXPECT_EQ(strncpy_s(boot.update, sizeof(boot.update) - 1, updateMsg.c_str(), updateMsg.size()), 0);
140     bRet = WriteUpdaterMessage(commandFile, boot);
141     EXPECT_EQ(bRet, true);
142 
143     args = Utils::ParseParams(argc, argv);
144     res = "";
145     for (auto s : args) {
146         res += s;
147     }
148     EXPECT_EQ("./UpdaterMain--update_package=updater_full.zip", res);
149 }
150 
HWTEST_F(UpdaterUtilUnitTest, UpdaterMain, TestSize.Level1)151 HWTEST_F(UpdaterUtilUnitTest, UpdaterMain, TestSize.Level1)
152 {
153     UpdateMessage boot {};
154     if (access("/data/updater/", 0)) {
155         int ret = mkdir("/data/updater/", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
156         ASSERT_EQ(ret, 0);
157     }
158     const std::string commandFile = "/data/updater/command";
159     auto fp = std::unique_ptr<FILE, decltype(&fclose)>(fopen(commandFile.c_str(), "wb"), fclose);
160     EXPECT_NE(fp, nullptr);
161     const std::string commandMsg = "boot_updater";
162     const std::string updateMsg = "--update_package=/data/updater/updater/updater_full.zip";
163     EXPECT_EQ(strncpy_s(boot.command, sizeof(boot.command) - 1, commandMsg.c_str(), commandMsg.size()), 0);
164     EXPECT_EQ(strncpy_s(boot.update, sizeof(boot.update) - 1, updateMsg.c_str(), updateMsg.size()), 0);
165     bool bRet = WriteUpdaterMessage(commandFile, boot);
166     EXPECT_EQ(bRet, true);
167     char **argv = new char*[1];
168     argv[0] = new char[MAX_ARG_SIZE];
169     EXPECT_EQ(strncpy_s(argv[0], MAX_ARG_SIZE, "./UpdaterMain", MAX_ARG_SIZE), 0);
170     int argc = 1;
171 
172     int ret = UpdaterMain(argc, argv);
173     EXPECT_EQ(ret, 0);
174     PostUpdater(true);
175     delete argv[0];
176     delete []argv;
177 }
178 
HWTEST_F(UpdaterUtilUnitTest, UpdaterFromSdcardTest, TestSize.Level1)179 HWTEST_F(UpdaterUtilUnitTest, UpdaterFromSdcardTest, TestSize.Level1)
180 {
181     UpdateMessage boot {};
182     if (access("/data/updater/", 0)) {
183         int ret = mkdir("/data/updater/", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
184         ASSERT_EQ(ret, 0);
185     }
186     const std::string commandFile = "/data/updater/command";
187     auto fp = std::unique_ptr<FILE, decltype(&fclose)>(fopen(commandFile.c_str(), "wb"), fclose);
188     EXPECT_NE(fp, nullptr);
189     const std::string commandMsg = "boot_updater";
190     const std::string updateMsg = "--sdcard_update";
191     EXPECT_EQ(strncpy_s(boot.command, sizeof(boot.command) - 1, commandMsg.c_str(), commandMsg.size()), 0);
192     EXPECT_EQ(strncpy_s(boot.update, sizeof(boot.update) - 1, updateMsg.c_str(), updateMsg.size()), 0);
193     bool bRet = WriteUpdaterMessage(commandFile, boot);
194     EXPECT_EQ(bRet, true);
195     char **argv = new char*[1];
196     argv[0] = new char[MAX_ARG_SIZE];
197     EXPECT_EQ(strncpy_s(argv[0], MAX_ARG_SIZE, "./UpdaterMain", MAX_ARG_SIZE), 0);
198     int argc = 1;
199     EXPECT_EQ(UpdaterMain(argc, argv), 0);
200     delete argv[0];
201     delete []argv;
202 }
203 
HWTEST_F(UpdaterUtilUnitTest, DoInstallUpdaterPackageTest, TestSize.Level1)204 HWTEST_F(UpdaterUtilUnitTest, DoInstallUpdaterPackageTest, TestSize.Level1)
205 {
206     UpdaterParams upParams;
207     upParams.callbackProgress = nullptr;
208     std::vector<std::string> output;
209     EXPECT_EQ(DoInstallUpdaterPackage(nullptr, upParams, HOTA_UPDATE), UPDATE_CORRUPT);
210     upParams.callbackProgress = [] (float value) {};
211     EXPECT_EQ(DoInstallUpdaterPackage(nullptr, upParams, HOTA_UPDATE), UPDATE_CORRUPT);
212     upParams.retryCount = 0;
213     EXPECT_EQ(DoInstallUpdaterPackage(nullptr, upParams, HOTA_UPDATE), UPDATE_CORRUPT);
214     upParams.retryCount = 1;
215     EXPECT_EQ(DoInstallUpdaterPackage(nullptr, upParams, HOTA_UPDATE), UPDATE_CORRUPT);
216 }
217 
HWTEST_F(UpdaterUtilUnitTest, updater_ExtractUpdaterBinary, TestSize.Level1)218 HWTEST_F(UpdaterUtilUnitTest, updater_ExtractUpdaterBinary, TestSize.Level1)
219 {
220     Hpackage::PkgManager::PkgManagerPtr pkgManager = Hpackage::PkgManager::CreatePackageInstance();
221     std::string path = "xxx";
222     int32_t ret = ExtractUpdaterBinary(pkgManager, path, UPDATER_BINARY);
223     EXPECT_EQ(ret, 1);
224     path = "/data/updater/updater/updater_full.zip";
225     ret = ExtractUpdaterBinary(pkgManager, path, UPDATER_BINARY);
226     Hpackage::PkgManager::ReleasePackageInstance(pkgManager);
227     EXPECT_EQ(ret, 1);
228 }
229 
HWTEST_F(UpdaterUtilUnitTest, updater_IsSpaceCapacitySufficient, TestSize.Level1)230 HWTEST_F(UpdaterUtilUnitTest, updater_IsSpaceCapacitySufficient, TestSize.Level1)
231 {
232     UpdaterParams upParams {};
233     UpdaterStatus status = IsSpaceCapacitySufficient(upParams);
234     EXPECT_EQ(status, UPDATE_ERROR);
235     upParams.updatePackage.push_back("/data/updater/updater/updater_full.zip");
236     status = IsSpaceCapacitySufficient(upParams);
237     EXPECT_EQ(status, UPDATE_SUCCESS);
238     upParams.updatePackage.push_back("xxx");
239     ProgressSmoothHandler(0, 0);
240     ProgressSmoothHandler(-1, 0);
241     ProgressSmoothHandler(0, 1);
242     status = IsSpaceCapacitySufficient(upParams);
243     EXPECT_EQ(status, UPDATE_ERROR);
244 }
245 
HWTEST_F(UpdaterUtilUnitTest, updater_HandleChildOutput, TestSize.Level1)246 HWTEST_F(UpdaterUtilUnitTest, updater_HandleChildOutput, TestSize.Level1)
247 {
248     std::string buf = "xxx";
249     bool retryUpdate = false;
250     UpdaterParams upParams;
251     HandleChildOutput(buf, 0, retryUpdate, upParams);
252     EXPECT_EQ(retryUpdate, false);
253     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
254     EXPECT_EQ(retryUpdate, false);
255     buf = "write_log:xxx";
256     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
257     EXPECT_EQ(retryUpdate, false);
258     buf = "retry_update:xxx";
259     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
260     EXPECT_EQ(retryUpdate, true);
261     buf = "ui_log:xxx";
262     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
263     EXPECT_EQ(retryUpdate, true);
264     buf = "show_progress:xxx";
265     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
266     EXPECT_EQ(retryUpdate, true);
267     buf = "show_progress:xxx:xxx";
268     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
269     EXPECT_EQ(retryUpdate, true);
270     buf = "set_progress:xxx";
271     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
272     EXPECT_EQ(retryUpdate, true);
273     buf = "xxx:xxx";
274     HandleChildOutput(buf, buf.size(), retryUpdate, upParams);
275     EXPECT_EQ(retryUpdate, true);
276 }
277 
HWTEST_F(UpdaterUtilUnitTest, InstallUpdaterPackageTest, TestSize.Level1)278 HWTEST_F(UpdaterUtilUnitTest, InstallUpdaterPackageTest, TestSize.Level1)
279 {
280     UpdaterParams upParams;
281     upParams.retryCount = 0;
282     upParams.callbackProgress = [] (float value) { UPDATER_UI_INSTANCE.ShowProgress(value); };
283     upParams.updatePackage.push_back("/data/updater/updater/updater_full.zip");
284     Hpackage::PkgManager::PkgManagerPtr pkgManager = Hpackage::PkgManager::CreatePackageInstance();
285     EXPECT_EQ(InstallUpdaterPackage(upParams, pkgManager), UPDATE_ERROR);
286     upParams.updateMode = SDCARD_UPDATE;
287     upParams.retryCount = 1;
288     EXPECT_EQ(InstallUpdaterPackage(upParams, pkgManager), UPDATE_ERROR);
289 }
290 
HWTEST_F(UpdaterUtilUnitTest, DoUpdatePackagesTest, TestSize.Level1)291 HWTEST_F(UpdaterUtilUnitTest, DoUpdatePackagesTest, TestSize.Level1)
292 {
293     UpdaterParams upParams;
294     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
295     upParams.updatePackage.push_back("/data/updater/updater/updater_full.zip");
296     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
297     upParams.callbackProgress = [] (float value) { UPDATER_UI_INSTANCE.ShowProgress(value); };
298     upParams.installTime.push_back(std::chrono::duration<double>(0));
299     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_ERROR);
300 }
301 
HWTEST_F(UpdaterUtilUnitTest, StartUpdaterEntryTest, TestSize.Level1)302 HWTEST_F(UpdaterUtilUnitTest, StartUpdaterEntryTest, TestSize.Level1)
303 {
304     UpdaterParams upParams;
305     upParams.factoryResetMode = "factory_wipe_data";
306     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
307     upParams.factoryResetMode = "user_wipe_data";
308     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
309     upParams.factoryResetMode = "menu_wipe_data";
310     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
311     upParams.factoryResetMode = "";
312     EXPECT_EQ(DoUpdatePackages(upParams), UPDATE_CORRUPT);
313 }
314 
HWTEST_F(UpdaterUtilUnitTest, StartUpdaterProcTest, TestSize.Level1)315 HWTEST_F(UpdaterUtilUnitTest, StartUpdaterProcTest, TestSize.Level1)
316 {
317     Hpackage::PkgManager::PkgManagerPtr pkgManager = Hpackage::PkgManager::CreatePackageInstance();
318     UpdaterParams upParams;
319     EXPECT_EQ(StartUpdaterProc(nullptr, upParams), UPDATE_CORRUPT);
320     EXPECT_EQ(StartUpdaterProc(pkgManager, upParams), UPDATE_ERROR);
321 }
322 
HWTEST_F(UpdaterUtilUnitTest, CheckPathNeedMountSD, TestSize.Level0)323 HWTEST_F(UpdaterUtilUnitTest, CheckPathNeedMountSD, TestSize.Level0)
324 {
325     UpdaterParams upParams;
326     upParams.updatePackage.push_back("/data/updater/updater_full.zip");
327     EXPECT_EQ(CheckPathNeedMountSD(upParams), false);
328     upParams.updatePackage.clear();
329     upParams.updatePackage.push_back("/sdcard/updater/updater_full.zip");
330     EXPECT_EQ(CheckPathNeedMountSD(upParams), true);
331     upParams.updatePackage.clear();
332     upParams.updatePackage.push_back("/data/sdcard/updater_full.zip");
333     EXPECT_EQ(CheckPathNeedMountSD(upParams), false);
334 }
335 }
336