1 #include "bt.hpp"
2 #include "internal_sys_mock.hpp"
3 #include "progress_mock.hpp"
4
5 #include <ipmiblob/blob_errors.hpp>
6 #include <ipmiblob/test/blob_interface_mock.hpp>
7
8 #include <cstring>
9 #include <memory>
10 #include <string>
11 #include <vector>
12
13 #include <gmock/gmock.h>
14 #include <gtest/gtest.h>
15
16 namespace host_tool
17 {
18 namespace
19 {
20
21 using ::testing::_;
22 using ::testing::ContainerEq;
23 using ::testing::Eq;
24 using ::testing::Invoke;
25 using ::testing::NotNull;
26 using ::testing::Return;
27 using ::testing::Throw;
28
29 class BtHandlerTest : public ::testing::Test
30 {
31 protected:
32 static constexpr std::uint16_t session = 0xbeef;
33
BtHandlerTest()34 BtHandlerTest() :
35 handler(std::make_unique<BtDataHandler>(&blobMock, &progMock, &sysMock))
36 {}
37
38 internal::InternalSysMock sysMock;
39 ipmiblob::BlobInterfaceMock blobMock;
40 ProgressMock progMock;
41 std::unique_ptr<BtDataHandler> handler;
42 const std::string filePath = "/asdf";
43 };
44
TEST_F(BtHandlerTest,verifySendsFileContents)45 TEST_F(BtHandlerTest, verifySendsFileContents)
46 {
47 /* In this very basic test, we'll feed the bt handler data from the internal
48 * syscall mock and catch the writes via the blob mock.
49 */
50 int fd = 1;
51 std::vector<std::uint8_t> bytes = {'1', '2', '3', '4'};
52 const int fakeFileSize = 100;
53
54 EXPECT_CALL(sysMock, open(Eq(filePath), _)).WillOnce(Return(fd));
55 EXPECT_CALL(sysMock, getSize(Eq(filePath))).WillOnce(Return(fakeFileSize));
56
57 EXPECT_CALL(progMock, start(fakeFileSize));
58
59 EXPECT_CALL(sysMock, read(fd, NotNull(), _))
60 .WillOnce(Invoke([&](int, void* buf, std::size_t count) {
61 EXPECT_TRUE(count > bytes.size());
62 std::memcpy(buf, bytes.data(), bytes.size());
63 return bytes.size();
64 }))
65 .WillOnce(Return(0));
66
67 EXPECT_CALL(progMock, updateProgress(bytes.size()));
68
69 EXPECT_CALL(sysMock, close(fd)).WillOnce(Return(0));
70
71 EXPECT_CALL(blobMock, writeBytes(session, 0, ContainerEq(bytes)));
72
73 EXPECT_TRUE(handler->sendContents(filePath, session));
74 }
75
TEST_F(BtHandlerTest,sendContentsFailsToOpenFile)76 TEST_F(BtHandlerTest, sendContentsFailsToOpenFile)
77 {
78 /* If the file doesn't exist or the permissions are wrong, the sendContents
79 * will return failure.
80 */
81 EXPECT_CALL(sysMock, open(Eq(filePath), _)).WillOnce(Return(-1));
82
83 EXPECT_FALSE(handler->sendContents(filePath, session));
84 }
85
TEST_F(BtHandlerTest,sendContentsFailsWhenBlobHandlerThrows)86 TEST_F(BtHandlerTest, sendContentsFailsWhenBlobHandlerThrows)
87 {
88 /* The blob handler throws an exception which is caught, the file is closed,
89 * and false is returned.
90 */
91
92 int fd = 1;
93 std::vector<std::uint8_t> bytes = {'1', '2', '3', '4'};
94 const int fakeFileSize = 100;
95
96 EXPECT_CALL(sysMock, open(Eq(filePath), _)).WillOnce(Return(fd));
97 EXPECT_CALL(sysMock, getSize(Eq(filePath))).WillOnce(Return(fakeFileSize));
98
99 EXPECT_CALL(progMock, start(fakeFileSize));
100
101 EXPECT_CALL(sysMock, read(fd, NotNull(), _))
102 .WillOnce(Invoke([&](int, void* buf, std::size_t count) {
103 EXPECT_TRUE(count > bytes.size());
104 std::memcpy(buf, bytes.data(), bytes.size());
105 return bytes.size();
106 }));
107
108 EXPECT_CALL(blobMock, writeBytes(session, 0, ContainerEq(bytes)))
109 .WillOnce(Throw(ipmiblob::BlobException("failure")));
110
111 EXPECT_CALL(sysMock, close(fd)).WillOnce(Return(0));
112
113 EXPECT_FALSE(handler->sendContents(filePath, session));
114 }
115
116 } // namespace
117 } // namespace host_tool
118