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 
33 using namespace std;
34 using namespace Flashd;
35 using namespace testing::ext;
36 using namespace Hdc;
37 
38 namespace {
39 
40 class FLashServiceUnitTest : public testing::Test {
41 public:
FLashServiceUnitTest()42     FLashServiceUnitTest()
43     {
44         std::cout<<"FLashServiceUnitTest()";
45     }
~FLashServiceUnitTest()46     ~FLashServiceUnitTest() {}
47 
SetUpTestCase(void)48     static void SetUpTestCase(void)
49     {
50         InitUpdaterLogger("FLASHD", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH);
51     }
TearDownTestCase(void)52     static void TearDownTestCase(void) {}
SetUp()53     void SetUp() {}
TearDown()54     void TearDown() {}
TestBody()55     void TestBody() {}
56     std::unique_ptr<Flashd::Commander> commander_ = nullptr;
57 };
58 
59 HWTEST_F(FLashServiceUnitTest, FormatCommanderDoCommand, TestSize.Level1)
60 {
61     LoadFstab();
62     std::unique_ptr<Flashd::Commander> commander = nullptr;
63     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10202(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
93 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand, TestSize.Level1)
94 {
95     LoadFstab();
96     std::unique_ptr<Flashd::Commander> commander = nullptr;
97     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10302(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
127 HWTEST_F(FLashServiceUnitTest, EraseCommanderDoCommand, TestSize.Level1)
128 {
129     LoadFstab();
130     std::unique_ptr<Flashd::Commander> commander = nullptr;
131     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10402(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
161 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand, TestSize.Level1)
162 {
163     LoadFstab();
164     std::unique_ptr<Flashd::Commander> commander = nullptr;
165     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10502(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
189 HWTEST_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 
204 HWTEST_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 
224 HWTEST_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 
IsTestImg(const std::string & partition,const uint8_t * data,size_t len)238 bool 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 
GetTestWriter()247 std::unique_ptr<FlashdWriter> GetTestWriter()
248 {
249     return std::make_unique<FlashdWriterRaw>();
250 }
251 
252 HWTEST_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 
260 HWTEST_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 
268 HWTEST_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 
295 HWTEST_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 
303 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand2, TestSize.Level1)
304 {
305     LoadFstab();
306     std::unique_ptr<Flashd::Commander> commander = nullptr;
307     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10602(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
333 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand2, TestSize.Level1)
334 {
335     LoadFstab();
336     std::unique_ptr<Flashd::Commander> commander = nullptr;
337     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10702(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
354 HWTEST_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 
378 HWTEST_F(FLashServiceUnitTest, DoEraseCommanderSuccessTest, TestSize.Level1)
379 {
380     LoadFstab();
381     std::unique_ptr<Flashd::Commander> commander = nullptr;
382     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10802(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
407 HWTEST_F(FLashServiceUnitTest, DoFlashSuccessTest, TestSize.Level1)
408 {
409     LoadFstab();
410     std::unique_ptr<Flashd::Commander> commander = nullptr;
411     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10902(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
430 HWTEST_F(FLashServiceUnitTest, CreateCommanderTest, TestSize.Level1)
431 {
432     std::unique_ptr<Flashd::Commander> commander = nullptr;
433     Flashd::UpdaterState ret = UpdaterState::DOING;
__anon43aa4ae10a02(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 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 
458 HWTEST_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 
467 HWTEST_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