1/*
2 * Copyright (c) 2022 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 "common/flashd_define.h"
21#include "daemon/format_commander.h"
22#include "daemon/commander_factory.h"
23#include "daemon/daemon_updater.h"
24#include "daemon/flashd_utils.h"
25#include "hdi/client/update_hdi_client.h"
26#include "partition.h"
27#include "fs_manager/mount.h"
28#include "log/log.h"
29#include "securec.h"
30#include "updater/updater_const.h"
31#include "misc_info/misc_info.h"
32
33using namespace std;
34using namespace Flashd;
35using namespace testing::ext;
36using namespace Hdc;
37
38namespace {
39
40class FLashServiceUnitTest : public testing::Test {
41public:
42    FLashServiceUnitTest()
43    {
44        std::cout<<"FLashServiceUnitTest()";
45    }
46    ~FLashServiceUnitTest() {}
47
48    static void SetUpTestCase(void)
49    {
50        InitUpdaterLogger("FLASHD", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH);
51    }
52    static void TearDownTestCase(void) {}
53    void SetUp() {}
54    void TearDown() {}
55    void TestBody() {}
56    std::unique_ptr<Flashd::Commander> commander_ = nullptr;
57};
58
59HWTEST_F(FLashServiceUnitTest, FormatCommanderDoCommand, TestSize.Level1)
60{
61    LoadFstab();
62    std::unique_ptr<Flashd::Commander> commander = nullptr;
63    Flashd::UpdaterState ret = UpdaterState::DOING;
64    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
65        ret = state;
66    };
67    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FORMAT_PARTITION, callbackFail);
68    EXPECT_NE(nullptr, commander);
69    std::string cmdstr = "format data";
70    uint8_t *payload = nullptr;
71    int payloadSize = cmdstr.size() + 1;
72    commander->DoCommand(payload, payloadSize);
73    EXPECT_EQ(UpdaterState::FAIL, ret);
74
75    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
76    payloadSize = 0;
77    commander->DoCommand(payload, payloadSize);
78    EXPECT_EQ(UpdaterState::FAIL, ret);
79
80    cmdstr = "format";
81    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
82    payloadSize = cmdstr.size();
83    commander->DoCommand(payload, payloadSize);
84    EXPECT_EQ(UpdaterState::FAIL, ret);
85
86    cmdstr = "format databack";
87    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
88    payloadSize = cmdstr.size() + 1;
89    commander->DoCommand(payload, payloadSize);
90    EXPECT_EQ(UpdaterState::FAIL, ret);
91}
92
93HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand, TestSize.Level1)
94{
95    LoadFstab();
96    std::unique_ptr<Flashd::Commander> commander = nullptr;
97    Flashd::UpdaterState ret = UpdaterState::DOING;
98    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
99        ret = state;
100    };
101    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail);
102    EXPECT_NE(nullptr, commander);
103    std::string cmdstr = "test.zip";
104    uint8_t *payload = nullptr;
105    int payloadSize = cmdstr.size();
106    commander->DoCommand(payload, payloadSize);
107    EXPECT_EQ(UpdaterState::FAIL, ret);
108
109    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
110    payloadSize = 0;
111    commander->DoCommand(payload, payloadSize);
112    EXPECT_EQ(UpdaterState::FAIL, ret);
113
114    cmdstr = "update 123.zip";
115    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
116    payloadSize = cmdstr.size() + 1;
117    commander->DoCommand(payload, payloadSize);
118    EXPECT_EQ(UpdaterState::FAIL, ret);
119
120    cmdstr = "format databack";
121    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
122    payloadSize = cmdstr.size() + 1;
123    commander->DoCommand(payload, payloadSize);
124    EXPECT_EQ(UpdaterState::FAIL, ret);
125}
126
127HWTEST_F(FLashServiceUnitTest, EraseCommanderDoCommand, TestSize.Level1)
128{
129    LoadFstab();
130    std::unique_ptr<Flashd::Commander> commander = nullptr;
131    Flashd::UpdaterState ret = UpdaterState::DOING;
132    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
133        ret = state;
134    };
135    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_ERASE_PARTITION, callbackFail);
136    EXPECT_NE(nullptr, commander);
137    std::string cmdstr = "erase misc";
138    uint8_t *payload = nullptr;
139    int payloadSize = cmdstr.size() + 1;
140    commander->DoCommand(payload, payloadSize);
141    EXPECT_EQ(UpdaterState::FAIL, ret);
142
143    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
144    payloadSize = 0;
145    commander->DoCommand(payload, payloadSize);
146    EXPECT_EQ(UpdaterState::FAIL, ret);
147
148    cmdstr = "erase";
149    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
150    payloadSize = cmdstr.size();
151    commander->DoCommand(payload, payloadSize);
152    EXPECT_EQ(UpdaterState::FAIL, ret);
153
154    cmdstr = "erase misctest";
155    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
156    payloadSize = cmdstr.size() + 1;
157    commander->DoCommand(payload, payloadSize);
158    EXPECT_EQ(UpdaterState::FAIL, ret);
159}
160
161HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand, TestSize.Level1)
162{
163    LoadFstab();
164    std::unique_ptr<Flashd::Commander> commander = nullptr;
165    Flashd::UpdaterState ret = UpdaterState::DOING;
166    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
167        ret = state;
168    };
169    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
170    EXPECT_NE(nullptr, commander);
171    std::string cmdstr = "flash updater updater.img";
172    uint8_t *payload = nullptr;
173    int payloadSize = cmdstr.size() + 1;
174    commander->DoCommand(payload, payloadSize);
175    EXPECT_EQ(UpdaterState::FAIL, ret);
176
177    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
178    payloadSize = 0;
179    commander->DoCommand(payload, payloadSize);
180    EXPECT_EQ(UpdaterState::FAIL, ret);
181
182    cmdstr = "flash updatertest updater.img";
183    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
184    payloadSize = cmdstr.size() + 1;
185    commander->DoCommand(payload, payloadSize);
186    EXPECT_EQ(UpdaterState::SUCCESS, ret);
187}
188
189HWTEST_F(FLashServiceUnitTest, GetFileName, TestSize.Level1)
190{
191    std::string testStr = "data/test/test.zip";
192    std::string res = GetFileName(testStr);
193    EXPECT_EQ("test.zip", res);
194
195    testStr = "D:\\test\\test.zip";
196    res = GetFileName(testStr);
197    EXPECT_EQ("test.zip", res);
198
199    testStr = "test.zip";
200    res = GetFileName(testStr);
201    EXPECT_EQ("", res);
202}
203
204HWTEST_F(FLashServiceUnitTest, GetWriter, TestSize.Level1)
205{
206    std::string partName = "";
207    std::string temp = "";
208    uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data());
209    int bufferSize = partName.size();
210    std::unique_ptr<FlashdWriter> writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
211    if (writer == nullptr) {
212        std::cout << "writer is nullptr";
213    }
214    EXPECT_NE(nullptr, writer);
215
216    partName = "test";
217    writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
218    EXPECT_NE(nullptr, writer);
219
220    int ret = writer->Write(partName, reinterpret_cast<uint8_t*>(temp.data()), temp.size());
221    EXPECT_EQ(-1, ret);
222}
223
224HWTEST_F(FLashServiceUnitTest, FlashdWriterRawWriter, TestSize.Level1)
225{
226    std::string partName = "updater_ramdisk.img";
227    std::string temp = "";
228    std::unique_ptr<FlashdWriterRaw> writer = std::make_unique<FlashdWriterRaw>();
229    if (writer == nullptr) {
230        std::cout << "writer is nullptr";
231    }
232    EXPECT_NE(nullptr, writer);
233
234    int ret = writer->Write(partName, reinterpret_cast<uint8_t*>(temp.data()), temp.size());
235    EXPECT_EQ(-1, ret);
236}
237
238bool IsTestImg(const std::string &partition, const uint8_t *data, size_t len)
239{
240    if (data == nullptr) {
241        return false;
242    }
243    std::cout << "IsTestImg " << partition << " len " << len;
244    return true;
245}
246
247std::unique_ptr<FlashdWriter> GetTestWriter()
248{
249    return std::make_unique<FlashdWriterRaw>();
250}
251
252HWTEST_F(FLashServiceUnitTest, PartitionDoErase, TestSize.Level1)
253{
254    std::string partitionName = "test";
255    Partition partTest(partitionName);
256    int ret = partTest.DoErase();
257    EXPECT_EQ(FLASHING_OPEN_PART_ERROR, ret);
258}
259
260HWTEST_F(FLashServiceUnitTest, PartitionDoFormat, TestSize.Level1)
261{
262    std::string partitionName = "test";
263    Partition partTest(partitionName);
264    int ret = partTest.DoFormat();
265    EXPECT_EQ(-1, ret);
266}
267
268HWTEST_F(FLashServiceUnitTest, PartitionDoFlash, TestSize.Level1)
269{
270    std::string temp = "test.img";
271    uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data());
272    int bufferSize = 0;
273    std::unique_ptr<FlashdWriter> writer = nullptr;
274    std::string partName = "updater";
275    std::string cmdstr = "flash updater updater.img";
276    uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
277    int payloadSize = cmdstr.size();
278    std::unique_ptr<Partition> partition_ = std::make_unique<Partition>(partName, std::move(writer));
279    EXPECT_NE(nullptr, partition_);
280    int ret = partition_->DoFlash(payload, payloadSize);
281    EXPECT_EQ(FLASHING_ARG_INVALID, ret);
282    writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
283    EXPECT_NE(nullptr, partition_);
284
285    payloadSize = 0;
286    partition_ = std::make_unique<Partition>(partName, std::move(writer));
287    ret = partition_->DoFlash(payload, payloadSize);
288    EXPECT_EQ(FLASHING_ARG_INVALID, ret);
289    payloadSize = cmdstr.size();
290    payload = nullptr;
291    ret = partition_->DoFlash(payload, payloadSize);
292    EXPECT_EQ(FLASHING_ARG_INVALID, ret);
293}
294
295HWTEST_F(FLashServiceUnitTest, UpdateProgress, TestSize.Level1)
296{
297    std::string partitionName = "test";
298    Partition partTest(partitionName);
299    int ret = partTest.DoFormat();
300    EXPECT_EQ(-1, ret);
301}
302
303HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand2, TestSize.Level1)
304{
305    LoadFstab();
306    std::unique_ptr<Flashd::Commander> commander = nullptr;
307    Flashd::UpdaterState ret = UpdaterState::DOING;
308    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
309        ret = state;
310    };
311    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail);
312    EXPECT_NE(nullptr, commander);
313    std::string cmd = "update";
314    size_t size = cmd.size();
315    commander->DoCommand(cmd, size);
316    EXPECT_EQ(UpdaterState::FAIL, ret);
317
318    cmd = "";
319    size = cmd.size();
320    commander->DoCommand(cmd, size);
321    EXPECT_EQ(UpdaterState::FAIL, ret);
322
323    cmd = "update test.zip";
324    commander->DoCommand(cmd, size);
325    EXPECT_EQ(UpdaterState::FAIL, ret);
326
327    LoadSpecificFstab("/data/updater/updater/etc/fstab.ut.updater");
328    cmd = "update test.zip";
329    commander->DoCommand(cmd, size);
330    EXPECT_EQ(UpdaterState::FAIL, ret);
331}
332
333HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand2, TestSize.Level1)
334{
335    LoadFstab();
336    std::unique_ptr<Flashd::Commander> commander = nullptr;
337    Flashd::UpdaterState ret = UpdaterState::DOING;
338    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
339        ret = state;
340    };
341    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
342    EXPECT_NE(nullptr, commander);
343    std::string cmd = "flash";
344    size_t size = cmd.size();
345    commander->DoCommand(cmd, size);
346    EXPECT_EQ(UpdaterState::FAIL, ret);
347
348    cmd = "flash test test.img";
349    size = 20;
350    commander->DoCommand(cmd, size);
351    EXPECT_EQ(UpdaterState::FAIL, ret);
352}
353
354HWTEST_F(FLashServiceUnitTest, PartitionEraseSuccessTest, TestSize.Level1)
355{
356    std::string partitionName = "misc";
357    Partition partTest(partitionName);
358    int ret = partTest.DoErase();
359    EXPECT_EQ(0, ret);
360
361    partitionName = "system";
362    ret = partTest.DoErase();
363    EXPECT_EQ(0, ret);
364
365    partitionName = "sys_prod";
366    ret = partTest.DoErase();
367    EXPECT_EQ(0, ret);
368
369    partitionName = "vendor";
370    ret = partTest.DoErase();
371    EXPECT_EQ(0, ret);
372
373    partitionName = "userdata";
374    ret = partTest.DoErase();
375    EXPECT_EQ(0, ret);
376}
377
378HWTEST_F(FLashServiceUnitTest, DoEraseCommanderSuccessTest, TestSize.Level1)
379{
380    LoadFstab();
381    std::unique_ptr<Flashd::Commander> commander = nullptr;
382    Flashd::UpdaterState ret = UpdaterState::DOING;
383    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
384        ret = state;
385    };
386    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_ERASE_PARTITION, callbackFail);
387    EXPECT_NE(nullptr, commander);
388    std::string cmdstr = "erase misc";
389    uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
390    int payloadSize = cmdstr.size() + 1;
391    commander->DoCommand(payload, payloadSize);
392    EXPECT_EQ(UpdaterState::SUCCESS, ret);
393
394    cmdstr = "erase vendor";
395    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
396    payloadSize = cmdstr.size() + 1;
397    commander->DoCommand(payload, payloadSize);
398    EXPECT_EQ(UpdaterState::SUCCESS, ret);
399
400    cmdstr = "erase userdata";
401    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
402    payloadSize = cmdstr.size() + 1;
403    commander->DoCommand(payload, payloadSize);
404    EXPECT_EQ(UpdaterState::SUCCESS, ret);
405}
406
407HWTEST_F(FLashServiceUnitTest, DoFlashSuccessTest, TestSize.Level1)
408{
409    LoadFstab();
410    std::unique_ptr<Flashd::Commander> commander = nullptr;
411    Flashd::UpdaterState ret = UpdaterState::DOING;
412    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
413        ret = state;
414    };
415    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
416    EXPECT_NE(nullptr, commander);
417    std::string cmdstr = "flash updatertest updater.fd";
418    uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
419    int payloadSize = cmdstr.size() + 1;
420    commander->DoCommand(payload, payloadSize);
421    EXPECT_EQ(UpdaterState::SUCCESS, ret);
422
423    cmdstr = "flash test test.img";
424    payload = reinterpret_cast<uint8_t*>(cmdstr.data());
425    payloadSize = cmdstr.size() + 1;
426    commander->DoCommand(payload, payloadSize);
427    EXPECT_EQ(UpdaterState::SUCCESS, ret);
428}
429
430HWTEST_F(FLashServiceUnitTest, CreateCommanderTest, TestSize.Level1)
431{
432    std::unique_ptr<Flashd::Commander> commander = nullptr;
433    Flashd::UpdaterState ret = UpdaterState::DOING;
434    auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
435        ret = state;
436    };
437    std::string cmd = "TEST";
438    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
439    EXPECT_EQ(nullptr, commander);
440
441    cmd = "";
442    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
443    EXPECT_EQ(nullptr, commander);
444
445    cmd = Hdc::CMDSTR_FLASH_PARTITION;
446    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
447    EXPECT_NE(nullptr, commander);
448
449    cmd = Hdc::CMDSTR_FORMAT_PARTITION;
450    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
451    EXPECT_NE(nullptr, commander);
452
453    cmd = Hdc::CMDSTR_ERASE_PARTITION;
454    commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
455    EXPECT_NE(nullptr, commander);
456}
457
458HWTEST_F(FLashServiceUnitTest, GetLockStatusTest, TestSize.Level1)
459{
460    bool isLocked = true;
461    if (auto ret = Updater::UpdateHdiClient::GetInstance().GetLockStatus(isLocked); ret != 0) {
462        std::cout << "get lock failed";
463    }
464    EXPECT_EQ(isLocked, false);
465}
466
467HWTEST_F(FLashServiceUnitTest, CommandDispatchrTest, TestSize.Level1)
468{
469    HTaskInfo hTaskInfo = nullptr;
470    std::shared_ptr<TaskInformation> task = std::make_shared<TaskInformation>();
471    if (task == nullptr) {
472        return;
473    }
474    hTaskInfo = task.get();
475    hTaskInfo->channelId = 1;
476    hTaskInfo->sessionId = 0;
477    hTaskInfo->runLoop = uv_default_loop();
478    hTaskInfo->serverOrDaemon = 0;
479    hTaskInfo->ownerSessionClass = nullptr;
480    std::string testString = "x";
481    std::unique_ptr<DaemonUpdater> testDaemonUpdater = std::make_unique<DaemonUpdater>(hTaskInfo);
482    bool ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_UPDATE_INIT,
483        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
484    EXPECT_EQ(ret, false);
485    ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_DATA,
486        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
487    EXPECT_EQ(ret, true);
488    ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_CHECK,
489        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 100); // 100 : test number
490    EXPECT_EQ(ret, true);
491    ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_DATA,
492        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
493    EXPECT_EQ(ret, true);
494    ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_ERASE,
495        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
496    EXPECT_EQ(ret, true);
497    ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_FORMAT,
498        reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
499    EXPECT_EQ(ret, true);
500}
501} // namespace
502