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 
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 
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 
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 
86 TEST_F(BtHandlerTest, sendContentsWithEmptyFile)
87 {
88     /* An empty file should return failure from the sendContents. */
89     int fd = 1;
90 
91     EXPECT_CALL(sysMock, open(Eq(filePath), _)).WillOnce(Return(fd));
92     EXPECT_CALL(sysMock, getSize(Eq(filePath))).WillOnce(Return(0));
93 
94     EXPECT_FALSE(handler->sendContents(filePath, session));
95 }
96 
97 TEST_F(BtHandlerTest, sendContentsFailsWhenBlobHandlerThrows)
98 {
99     /* The blob handler throws an exception which is caught, the file is closed,
100      * and false is returned.
101      */
102 
103     int fd = 1;
104     std::vector<std::uint8_t> bytes = {'1', '2', '3', '4'};
105     const int fakeFileSize = 100;
106 
107     EXPECT_CALL(sysMock, open(Eq(filePath), _)).WillOnce(Return(fd));
108     EXPECT_CALL(sysMock, getSize(Eq(filePath))).WillOnce(Return(fakeFileSize));
109 
110     EXPECT_CALL(progMock, start(fakeFileSize));
111 
112     EXPECT_CALL(sysMock, read(fd, NotNull(), _))
113         .WillOnce(Invoke([&](int, void* buf, std::size_t count) {
114             EXPECT_TRUE(count > bytes.size());
115             std::memcpy(buf, bytes.data(), bytes.size());
116             return bytes.size();
117         }));
118 
119     EXPECT_CALL(blobMock, writeBytes(session, 0, ContainerEq(bytes)))
120         .WillOnce(Throw(ipmiblob::BlobException("failure")));
121 
122     EXPECT_CALL(sysMock, close(fd)).WillOnce(Return(0));
123 
124     EXPECT_FALSE(handler->sendContents(filePath, session));
125 }
126 
127 } // namespace
128 } // namespace host_tool
129