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
31using namespace Updater;
32using namespace std;
33using namespace testing::ext;
34
35namespace {
36constexpr uint32_t MAX_ARG_SIZE = 24;
37class UpdaterUtilUnitTest : public testing::Test {
38public:
39    UpdaterUtilUnitTest()
40    {
41        InitUpdaterLogger("UPDATER", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH);
42    }
43    ~UpdaterUtilUnitTest() {}
44
45    static void SetUpTestCase(void) {}
46    static void TearDownTestCase(void) {}
47    void SetUp() {}
48    void TearDown() {}
49    void TestBody() {}
50};
51
52HWTEST_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
63HWTEST_F(UpdaterUtilUnitTest, ClearMisc, TestSize.Level1)
64{
65    bool ret = ClearMisc();
66    EXPECT_EQ(ret, true);
67}
68
69HWTEST_F(UpdaterUtilUnitTest, IsSDCardExist, TestSize.Level1)
70{
71    std::string sdcardStr = "";
72    bool ret = IsSDCardExist(sdcardStr);
73    EXPECT_EQ(ret, false);
74}
75
76HWTEST_F(UpdaterUtilUnitTest, IsFlashd, TestSize.Level1)
77{
78    EXPECT_EQ(IsFlashd({"boot_updater", "", "boot_flash"}), true);
79    EXPECT_EQ(IsFlashd({"boot_updater", "", ""}), false);
80}
81
82HWTEST_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
89HWTEST_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
112HWTEST_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
151HWTEST_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
179HWTEST_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
204HWTEST_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
218HWTEST_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
230HWTEST_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
246HWTEST_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
278HWTEST_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
291HWTEST_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
302HWTEST_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
315HWTEST_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
323HWTEST_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