1 /**
2  * The goal of these tests is to verify opening the ubi tarball changes state
3  * as expected and does not regress.
4  */
5 #include "firmware_handler.hpp"
6 #include "firmware_unittest.hpp"
7 
8 #include <memory>
9 #include <string>
10 #include <vector>
11 
12 #include <gtest/gtest.h>
13 
14 namespace ipmi_flash
15 {
16 namespace
17 {
18 
19 using ::testing::UnorderedElementsAreArray;
20 
21 class FirmwareHandlerNotYetStartedUbitTest : public ::testing::Test
22 {
23   protected:
24     void SetUp() override
25     {
26         std::unique_ptr<ImageHandlerInterface> image =
27             std::make_unique<ImageHandlerMock>();
28         hashImageMock = reinterpret_cast<ImageHandlerMock*>(image.get());
29         blobs.emplace_back(hashBlobId, std::move(image));
30 
31         image = std::make_unique<ImageHandlerMock>();
32         imageMock = reinterpret_cast<ImageHandlerMock*>(image.get());
33         blobs.emplace_back(ubiTarballBlobId, std::move(image));
34 
35         std::unique_ptr<TriggerableActionInterface> verifyMock =
36             std::make_unique<TriggerMock>();
37         verifyMockPtr = reinterpret_cast<TriggerMock*>(verifyMock.get());
38 
39         std::unique_ptr<TriggerableActionInterface> updateMock =
40             std::make_unique<TriggerMock>();
41         updateMockPtr = reinterpret_cast<TriggerMock*>(updateMock.get());
42 
43         std::unique_ptr<ActionPack> actionPack = std::make_unique<ActionPack>();
44         actionPack->preparation = CreateTriggerMock();
45         actionPack->verification = std::move(verifyMock);
46         actionPack->update = std::move(updateMock);
47 
48         ActionMap packs;
49         packs[ubiTarballBlobId] = std::move(actionPack);
50 
51         std::vector<DataHandlerPack> data;
52         data.emplace_back(FirmwareFlags::UpdateFlags::ipmi, nullptr);
53 
54         handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
55             std::move(blobs), std::move(data), std::move(packs));
56     }
57 
58     void expectedState(FirmwareBlobHandler::UpdateState state)
59     {
60         auto realHandler = dynamic_cast<FirmwareBlobHandler*>(handler.get());
61         EXPECT_EQ(state, realHandler->getCurrentState());
62     }
63 
64     void openToInProgress(const std::string& blobId)
65     {
66         if (blobId == hashBlobId)
67         {
68             EXPECT_CALL(*hashImageMock, open(blobId)).WillOnce(Return(true));
69         }
70         else
71         {
72             EXPECT_CALL(*imageMock, open(blobId)).WillOnce(Return(true));
73         }
74         EXPECT_TRUE(handler->open(session, flags, blobId));
75         expectedState(FirmwareBlobHandler::UpdateState::uploadInProgress);
76     }
77 
78     ImageHandlerMock *hashImageMock, *imageMock;
79     std::vector<HandlerPack> blobs;
80     std::unique_ptr<blobs::GenericBlobInterface> handler;
81     TriggerMock* verifyMockPtr;
82     TriggerMock* updateMockPtr;
83 
84     std::uint16_t session = 1;
85     std::uint16_t flags =
86         blobs::OpenFlags::write | FirmwareFlags::UpdateFlags::ipmi;
87 };
88 
89 TEST_F(FirmwareHandlerNotYetStartedUbitTest,
90        OpeningTarballMovesToUploadInProgress)
91 {
92     expectedState(FirmwareBlobHandler::UpdateState::notYetStarted);
93 
94     EXPECT_THAT(handler->getBlobIds(),
95                 UnorderedElementsAreArray({hashBlobId, ubiTarballBlobId}));
96 
97     openToInProgress(ubiTarballBlobId);
98     EXPECT_THAT(handler->getBlobIds(),
99                 UnorderedElementsAreArray(
100                     {hashBlobId, ubiTarballBlobId, activeImageBlobId}));
101 }
102 
103 } // namespace
104 } // namespace ipmi_flash
105