1 #include "data_interface_mock.hpp" 2 #include "flags.hpp" 3 #include "status.hpp" 4 #include "tool_errors.hpp" 5 #include "updater.hpp" 6 #include "updater_mock.hpp" 7 #include "util.hpp" 8 9 #include <ipmiblob/test/blob_interface_mock.hpp> 10 #include <string> 11 12 #include <gtest/gtest.h> 13 14 namespace host_tool 15 { 16 17 using ::testing::_; 18 using ::testing::Eq; 19 using ::testing::Return; 20 using ::testing::TypedEq; 21 22 class UpdateHandlerTest : public ::testing::Test 23 { 24 protected: 25 const std::uint16_t session = 0xbeef; 26 27 DataInterfaceMock handlerMock; 28 ipmiblob::BlobInterfaceMock blobMock; 29 UpdateHandler updater{&blobMock, &handlerMock}; 30 }; 31 32 TEST_F(UpdateHandlerTest, CheckAvailableSuccess) 33 { 34 ipmiblob::StatResponse statObj = {}; 35 statObj.blob_state = ipmi_flash::FirmwareFlags::UpdateFlags::ipmi | 36 ipmi_flash::FirmwareFlags::UpdateFlags::lpc; 37 38 EXPECT_CALL(blobMock, getBlobList()) 39 .WillOnce( 40 Return(std::vector<std::string>({ipmi_flash::staticLayoutBlobId}))); 41 EXPECT_CALL(blobMock, getStat(TypedEq<const std::string&>( 42 ipmi_flash::staticLayoutBlobId))) 43 .WillOnce(Return(statObj)); 44 45 EXPECT_CALL(handlerMock, supportedType()) 46 .WillOnce(Return(ipmi_flash::FirmwareFlags::UpdateFlags::lpc)); 47 48 EXPECT_TRUE(updater.checkAvailable(ipmi_flash::staticLayoutBlobId)); 49 } 50 51 TEST_F(UpdateHandlerTest, SendFileSuccess) 52 { 53 /* Call sendFile to verify it does what we expect. */ 54 std::string firmwareImage = "image.bin"; 55 56 std::uint16_t supported = 57 static_cast<std::uint16_t>( 58 ipmi_flash::FirmwareFlags::UpdateFlags::lpc) | 59 static_cast<std::uint16_t>( 60 ipmi_flash::FirmwareFlags::UpdateFlags::openWrite); 61 62 EXPECT_CALL(handlerMock, supportedType()) 63 .WillOnce(Return(ipmi_flash::FirmwareFlags::UpdateFlags::lpc)); 64 65 EXPECT_CALL(blobMock, openBlob(ipmi_flash::staticLayoutBlobId, supported)) 66 .WillOnce(Return(session)); 67 68 EXPECT_CALL(handlerMock, sendContents(firmwareImage, session)) 69 .WillOnce(Return(true)); 70 71 EXPECT_CALL(blobMock, closeBlob(session)).Times(1); 72 73 updater.sendFile(ipmi_flash::staticLayoutBlobId, firmwareImage); 74 } 75 76 TEST_F(UpdateHandlerTest, VerifyFileHandleReturnsTrueOnSuccess) 77 { 78 EXPECT_CALL(blobMock, openBlob(ipmi_flash::verifyBlobId, _)) 79 .WillOnce(Return(session)); 80 EXPECT_CALL(blobMock, commit(session, _)).WillOnce(Return()); 81 ipmiblob::StatResponse verificationResponse = {}; 82 /* the other details of the response are ignored, and should be. */ 83 verificationResponse.metadata.push_back( 84 static_cast<std::uint8_t>(ipmi_flash::ActionStatus::success)); 85 86 EXPECT_CALL(blobMock, getStat(TypedEq<std::uint16_t>(session))) 87 .WillOnce(Return(verificationResponse)); 88 EXPECT_CALL(blobMock, closeBlob(session)).WillOnce(Return()); 89 90 EXPECT_TRUE(updater.verifyFile(ipmi_flash::verifyBlobId, false)); 91 } 92 93 class UpdaterTest : public ::testing::Test 94 { 95 protected: 96 ipmiblob::BlobInterfaceMock blobMock; 97 std::uint16_t session = 0xbeef; 98 bool defaultIgnore = false; 99 }; 100 101 TEST_F(UpdaterTest, UpdateMainReturnsSuccessIfAllSuccess) 102 { 103 const std::string image = "image.bin"; 104 const std::string signature = "signature.bin"; 105 UpdateHandlerMock handler; 106 107 EXPECT_CALL(handler, checkAvailable(_)).WillOnce(Return(true)); 108 EXPECT_CALL(handler, sendFile(_, image)).WillOnce(Return()); 109 EXPECT_CALL(handler, sendFile(_, signature)).WillOnce(Return()); 110 EXPECT_CALL(handler, verifyFile(ipmi_flash::verifyBlobId, defaultIgnore)) 111 .WillOnce(Return(true)); 112 EXPECT_CALL(handler, verifyFile(ipmi_flash::updateBlobId, defaultIgnore)) 113 .WillOnce(Return(true)); 114 115 updaterMain(&handler, image, signature, "static", defaultIgnore); 116 } 117 118 TEST_F(UpdaterTest, UpdateMainReturnsSuccessWithIgnoreUpdate) 119 { 120 const std::string image = "image.bin"; 121 const std::string signature = "signature.bin"; 122 UpdateHandlerMock handler; 123 bool updateIgnore = true; 124 125 EXPECT_CALL(handler, checkAvailable(_)).WillOnce(Return(true)); 126 EXPECT_CALL(handler, sendFile(_, image)).WillOnce(Return()); 127 EXPECT_CALL(handler, sendFile(_, signature)).WillOnce(Return()); 128 EXPECT_CALL(handler, verifyFile(ipmi_flash::verifyBlobId, defaultIgnore)) 129 .WillOnce(Return(true)); 130 EXPECT_CALL(handler, verifyFile(ipmi_flash::updateBlobId, updateIgnore)) 131 .WillOnce(Return(true)); 132 133 updaterMain(&handler, image, signature, "static", updateIgnore); 134 } 135 136 TEST_F(UpdaterTest, UpdateMainCleansUpOnFailure) 137 { 138 const std::string image = "image.bin"; 139 const std::string signature = "signature.bin"; 140 UpdateHandlerMock handler; 141 142 EXPECT_CALL(handler, checkAvailable(_)).WillOnce(Return(true)); 143 EXPECT_CALL(handler, sendFile(_, image)).WillOnce(Return()); 144 EXPECT_CALL(handler, sendFile(_, signature)).WillOnce(Return()); 145 EXPECT_CALL(handler, verifyFile(ipmi_flash::verifyBlobId, defaultIgnore)) 146 .WillOnce(Return(false)); 147 EXPECT_CALL(handler, cleanArtifacts()).WillOnce(Return()); 148 149 EXPECT_THROW( 150 updaterMain(&handler, image, signature, "static", defaultIgnore), 151 ToolException); 152 } 153 154 } // namespace host_tool 155