1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#include "firmware_handler.hpp"
#include "flags.hpp"
#include "image_mock.hpp"
#include "triggerable_mock.hpp"
#include "util.hpp"
#include <algorithm>
#include <memory>
#include <vector>
#include <gtest/gtest.h>
namespace ipmi_flash
{
namespace
{
using ::testing::UnorderedElementsAreArray;
TEST(FirmwareHandlerTest, CreateEmptyHandlerListVerifyFails)
{
std::vector<DataHandlerPack> data = {
{FirmwareFlags::UpdateFlags::ipmi, nullptr},
};
auto handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
{}, data, std::move(CreateActionMap("abcd")));
EXPECT_EQ(handler, nullptr);
}
TEST(FirmwareHandlerTest, CreateEmptyDataHandlerListFails)
{
ImageHandlerMock imageMock;
std::vector<HandlerPack> blobs;
blobs.push_back(std::move(
HandlerPack(hashBlobId, std::make_unique<ImageHandlerMock>())));
blobs.push_back(
std::move(HandlerPack("asdf", std::make_unique<ImageHandlerMock>())));
auto handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs), {}, std::move(CreateActionMap("asdf")));
EXPECT_EQ(handler, nullptr);
}
TEST(FirmwareHandlerTest, CreateEmptyActionPackVerifyFails)
{
/* The ActionPack map corresponds to the firmware list passed in, but
* they're not checked against each other yet.
*/
std::vector<DataHandlerPack> data = {
{FirmwareFlags::UpdateFlags::ipmi, nullptr},
};
std::vector<HandlerPack> blobs;
blobs.push_back(
std::move(HandlerPack("asdf", std::make_unique<ImageHandlerMock>())));
blobs.push_back(std::move(
HandlerPack(hashBlobId, std::make_unique<ImageHandlerMock>())));
ActionMap emptyMap;
auto handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs), data, std::move(emptyMap));
EXPECT_EQ(handler, nullptr);
}
TEST(FirmwareHandlerTest, FirmwareHandlerListRequiresAtLeastTwoEntries)
{
/* The hashblob handler must be one of the entries, but it cannot be the
* only entry.
*/
std::vector<DataHandlerPack> data = {
{FirmwareFlags::UpdateFlags::ipmi, nullptr},
};
/* Provide a firmware list that has the hash blob, which is the required one
* -- tested in a different test.
*/
std::vector<HandlerPack> blobs;
blobs.push_back(std::move(
HandlerPack(hashBlobId, std::make_unique<ImageHandlerMock>())));
auto handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs), data, std::move(CreateActionMap("asdf")));
EXPECT_EQ(handler, nullptr);
/* Add second firmware and it'll now work. */
std::vector<HandlerPack> blobs2;
blobs2.push_back(std::move(
HandlerPack(hashBlobId, std::make_unique<ImageHandlerMock>())));
blobs2.push_back(
std::move(HandlerPack("asdf", std::make_unique<ImageHandlerMock>())));
handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs2), data, std::move(CreateActionMap("asdf")));
auto result = handler->getBlobIds();
std::vector<std::string> expectedBlobs = {"asdf", hashBlobId};
EXPECT_THAT(result, UnorderedElementsAreArray(expectedBlobs));
}
TEST(FirmwareHandlerTest, VerifyHashRequiredForHappiness)
{
std::vector<DataHandlerPack> data = {
{FirmwareFlags::UpdateFlags::ipmi, nullptr},
};
/* This works fine only if you also pass in the hash handler. */
std::vector<HandlerPack> blobs;
blobs.push_back(
std::move(HandlerPack("asdf", std::make_unique<ImageHandlerMock>())));
auto handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs), data, std::move(CreateActionMap("asdf")));
EXPECT_EQ(handler, nullptr);
std::vector<HandlerPack> blobs2;
blobs2.push_back(
std::move(HandlerPack("asdf", std::make_unique<ImageHandlerMock>())));
blobs2.push_back(std::move(
HandlerPack(hashBlobId, std::make_unique<ImageHandlerMock>())));
handler = FirmwareBlobHandler::CreateFirmwareBlobHandler(
std::move(blobs2), data, std::move(CreateActionMap("asdf")));
auto result = handler->getBlobIds();
std::vector<std::string> expectedBlobs = {"asdf", hashBlobId};
EXPECT_THAT(result, UnorderedElementsAreArray(expectedBlobs));
}
} // namespace
} // namespace ipmi_flash
|
