diff --git a/test/Makefile.am b/test/Makefile.am
new file mode 100644
index 0000000..29586bf
--- /dev/null
+++ b/test/Makefile.am
@@ -0,0 +1,110 @@
+AM_CPPFLAGS = -I$(top_srcdir)/ \
+	$(GTEST_CFLAGS) \
+	$(GMOCK_CFLAGS)
+AM_CXXFLAGS = \
+	$(GTEST_MAIN_CFLAGS)
+AM_LDFLAGS = \
+	$(GMOCK_LIBS) \
+	$(GTEST_MAIN_LIBS) \
+	$(OESDK_TESTCASE_FLAGS)
+
+# Run all 'check' test programs
+check_PROGRAMS = \
+	ipmi_unittest \
+	ipmi_getcount_unittest \
+	ipmi_enumerate_unittest \
+	ipmi_open_unittest \
+	ipmi_close_unittest \
+	ipmi_delete_unittest \
+	ipmi_stat_unittest \
+	ipmi_sessionstat_unittest \
+	ipmi_commit_unittest \
+	ipmi_read_unittest \
+	ipmi_write_unittest \
+	ipmi_validate_unittest \
+	manager_unittest \
+	manager_getsession_unittest \
+	manager_open_unittest \
+	manager_stat_unittest \
+	manager_sessionstat_unittest \
+	manager_commit_unittest \
+	manager_close_unittest \
+	manager_delete_unittest \
+	manager_write_unittest \
+	manager_read_unittest \
+	process_unittest \
+	crc_unittest
+TESTS = $(check_PROGRAMS)
+
+ipmi_unittest_SOURCES = ipmi_unittest.cpp
+ipmi_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_getcount_unittest_SOURCES = ipmi_getcount_unittest.cpp
+ipmi_getcount_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_enumerate_unittest_SOURCES = ipmi_enumerate_unittest.cpp
+ipmi_enumerate_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_open_unittest_SOURCES = ipmi_open_unittest.cpp
+ipmi_open_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_close_unittest_SOURCES = ipmi_close_unittest.cpp
+ipmi_close_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_delete_unittest_SOURCES = ipmi_delete_unittest.cpp
+ipmi_delete_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_stat_unittest_SOURCES = ipmi_stat_unittest.cpp
+ipmi_stat_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_sessionstat_unittest_SOURCES = ipmi_sessionstat_unittest.cpp
+ipmi_sessionstat_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_commit_unittest_SOURCES = ipmi_commit_unittest.cpp
+ipmi_commit_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_read_unittest_SOURCES = ipmi_read_unittest.cpp
+ipmi_read_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_write_unittest_SOURCES = ipmi_write_unittest.cpp
+ipmi_write_unittest_LDADD = $(top_builddir)/ipmi.o
+
+ipmi_validate_unittest_SOURCES = ipmi_validate_unittest.cpp
+ipmi_validate_unittest_LDADD = $(top_builddir)/ipmi.o
+
+manager_unittest_SOURCES = manager_unittest.cpp
+manager_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_getsession_unittest_SOURCES = manager_getsession_unittest.cpp
+manager_getsession_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_open_unittest_SOURCES = manager_open_unittest.cpp
+manager_open_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_stat_unittest_SOURCES = manager_stat_unittest.cpp
+manager_stat_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_sessionstat_unittest_SOURCES = manager_sessionstat_unittest.cpp
+manager_sessionstat_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_commit_unittest_SOURCES = manager_commit_unittest.cpp
+manager_commit_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_close_unittest_SOURCES = manager_close_unittest.cpp
+manager_close_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_delete_unittest_SOURCES = manager_delete_unittest.cpp
+manager_delete_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_write_unittest_SOURCES = manager_write_unittest.cpp
+manager_write_unittest_LDADD = $(top_builddir)/manager.o
+
+manager_read_unittest_SOURCES = manager_read_unittest.cpp
+manager_read_unittest_LDADD = $(top_builddir)/manager.o
+
+process_unittest_SOURCES = process_unittest.cpp
+process_unittest_LDADD = $(top_builddir)/process.o $(top_builddir)/ipmi.o \
+	$(top_builddir)/crc.o
+
+crc_unittest_SOURCES = crc_unittest.cpp
+crc_unittest_LDADD = $(top_builddir)/crc.o
diff --git a/test/blob_mock.hpp b/test/blob_mock.hpp
new file mode 100644
index 0000000..6c21c65
--- /dev/null
+++ b/test/blob_mock.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "blobs.hpp"
+
+#include <gmock/gmock.h>
+
+namespace blobs
+{
+
+class BlobMock : public GenericBlobInterface
+{
+  public:
+    virtual ~BlobMock() = default;
+
+    MOCK_METHOD1(canHandleBlob, bool(const std::string&));
+    MOCK_METHOD0(getBlobIds, std::vector<std::string>());
+    MOCK_METHOD1(deleteBlob, bool(const std::string&));
+    MOCK_METHOD2(stat, bool(const std::string&, struct BlobMeta*));
+    MOCK_METHOD3(open, bool(uint16_t, uint16_t, const std::string&));
+    MOCK_METHOD3(read, std::vector<uint8_t>(uint16_t, uint32_t, uint32_t));
+    MOCK_METHOD3(write, bool(uint16_t, uint32_t, const std::vector<uint8_t>&));
+    MOCK_METHOD2(commit, bool(uint16_t, const std::vector<uint8_t>&));
+    MOCK_METHOD1(close, bool(uint16_t));
+    MOCK_METHOD2(stat, bool(uint16_t, struct BlobMeta*));
+    MOCK_METHOD1(expire, bool(uint16_t));
+};
+} // namespace blobs
diff --git a/test/crc_mock.hpp b/test/crc_mock.hpp
new file mode 100644
index 0000000..1562200
--- /dev/null
+++ b/test/crc_mock.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "crc.hpp"
+
+#include <gmock/gmock.h>
+
+namespace blobs
+{
+
+class CrcMock : public CrcInterface
+{
+  public:
+    virtual ~CrcMock() = default;
+
+    MOCK_METHOD0(clear, void());
+    MOCK_METHOD2(compute, void(const uint8_t*, uint32_t));
+    MOCK_CONST_METHOD0(get, uint16_t());
+};
+} // namespace blobs
diff --git a/test/crc_unittest.cpp b/test/crc_unittest.cpp
new file mode 100644
index 0000000..fb69cb4
--- /dev/null
+++ b/test/crc_unittest.cpp
@@ -0,0 +1,44 @@
+#include "crc.hpp"
+
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+TEST(Crc16Test, VerifyCrcValue)
+{
+    // Verify the crc16 is producing the value we expect.
+
+    // Origin: security/crypta/ipmi/portable/ipmi_utils_test.cc
+    struct CrcTestVector
+    {
+        std::string input;
+        uint16_t output;
+    };
+
+    std::string longString =
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        "AAAAAAAAAAAAAAAA";
+
+    std::vector<CrcTestVector> vectors({{"", 0x1D0F},
+                                        {"A", 0x9479},
+                                        {"123456789", 0xE5CC},
+                                        {longString, 0xE938}});
+
+    Crc16 crc;
+
+    for (const CrcTestVector& testVector : vectors)
+    {
+        crc.clear();
+        auto data = reinterpret_cast<const uint8_t*>(testVector.input.data());
+        crc.compute(data, testVector.input.size());
+        EXPECT_EQ(crc.get(), testVector.output);
+    }
+}
+} // namespace blobs
diff --git a/test/ipmi_close_unittest.cpp b/test/ipmi_close_unittest.cpp
new file mode 100644
index 0000000..e34f731
--- /dev/null
+++ b/test/ipmi_close_unittest.cpp
@@ -0,0 +1,66 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Invoke;
+using ::testing::NotNull;
+using ::testing::Return;
+using ::testing::StrEq;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobCloseTest, ManagerRejectsCloseReturnsFailure)
+{
+    // The session manager returned failure to close, which we need to pass on.
+
+    ManagerMock mgr;
+    uint16_t sessionId = 0x54;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobCloseTx req;
+
+    req.cmd = BlobOEMCommands::bmcBlobClose;
+    req.crc = 0;
+    req.sessionId = sessionId;
+
+    dataLen = sizeof(req);
+
+    std::memcpy(request, &req, sizeof(req));
+
+    EXPECT_CALL(mgr, close(sessionId)).WillOnce(Return(false));
+    EXPECT_EQ(IPMI_CC_INVALID, closeBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobCloseTest, BlobClosedReturnsSuccess)
+{
+    // Verify that if all goes right, success is returned.
+
+    ManagerMock mgr;
+    uint16_t sessionId = 0x54;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobCloseTx req;
+
+    req.cmd = BlobOEMCommands::bmcBlobClose;
+    req.crc = 0;
+    req.sessionId = sessionId;
+
+    dataLen = sizeof(req);
+
+    std::memcpy(request, &req, sizeof(req));
+
+    EXPECT_CALL(mgr, close(sessionId)).WillOnce(Return(true));
+    EXPECT_EQ(IPMI_CC_OK, closeBlob(&mgr, request, reply, &dataLen));
+}
+} // namespace blobs
diff --git a/test/ipmi_commit_unittest.cpp b/test/ipmi_commit_unittest.cpp
new file mode 100644
index 0000000..1cc47a4
--- /dev/null
+++ b/test/ipmi_commit_unittest.cpp
@@ -0,0 +1,112 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::ElementsAreArray;
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobCommitTest, InvalidCommitDataLengthReturnsFailure)
+{
+    // The commit command supports an optional commit blob.  This test verifies
+    // we sanity check the length of that blob.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobCommitTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobCommit;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->commitDataLen =
+        1; // It's one byte, but that's more than the packet size.
+
+    dataLen = sizeof(struct BmcBlobCommitTx);
+
+    EXPECT_EQ(IPMI_CC_INVALID, commitBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobCommitTest, ValidCommitNoDataHandlerRejectsReturnsFailure)
+{
+    // The commit packet is valid and the manager's commit call returns failure.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobCommitTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobCommit;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->commitDataLen = 0;
+
+    dataLen = sizeof(struct BmcBlobCommitTx);
+
+    EXPECT_CALL(mgr, commit(req->sessionId, _)).WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, commitBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobCommitTest, ValidCommitNoDataHandlerAcceptsReturnsSuccess)
+{
+    // Commit called with no data and everything returns success.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobCommitTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobCommit;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->commitDataLen = 0;
+
+    dataLen = sizeof(struct BmcBlobCommitTx);
+
+    EXPECT_CALL(mgr, commit(req->sessionId, _)).WillOnce(Return(true));
+
+    EXPECT_EQ(IPMI_CC_OK, commitBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobCommitTest, ValidCommitWithDataHandlerAcceptsReturnsSuccess)
+{
+    // Commit called with extra data and everything returns success.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobCommitTx*>(request);
+
+    uint8_t expectedBlob[4] = {0x25, 0x33, 0x45, 0x67};
+
+    req->cmd = BlobOEMCommands::bmcBlobCommit;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->commitDataLen = sizeof(expectedBlob);
+    std::memcpy(req->commitData, &expectedBlob[0], sizeof(expectedBlob));
+
+    dataLen = sizeof(struct BmcBlobCommitTx) + sizeof(expectedBlob);
+
+    EXPECT_CALL(mgr,
+                commit(req->sessionId,
+                       ElementsAreArray(expectedBlob, sizeof(expectedBlob))))
+        .WillOnce(Return(true));
+
+    EXPECT_EQ(IPMI_CC_OK, commitBlob(&mgr, request, reply, &dataLen));
+}
+} // namespace blobs
diff --git a/test/ipmi_delete_unittest.cpp b/test/ipmi_delete_unittest.cpp
new file mode 100644
index 0000000..25fb06b
--- /dev/null
+++ b/test/ipmi_delete_unittest.cpp
@@ -0,0 +1,89 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::StrEq;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobDeleteTest, InvalidRequestLengthReturnsFailure)
+{
+    // There is a minimum blobId length of one character, this test verifies
+    // we check that.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobDeleteTx*>(request);
+    std::string blobId = "abc";
+
+    req->cmd = BlobOEMCommands::bmcBlobDelete;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator.
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobDeleteTx) + blobId.length();
+
+    EXPECT_EQ(IPMI_CC_INVALID, deleteBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobDeleteTest, RequestRejectedReturnsFailure)
+{
+    // The blobId is rejected for any reason.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobDeleteTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobDelete;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobDeleteTx) + blobId.length() + 1;
+
+    EXPECT_CALL(mgr, deleteBlob(StrEq(blobId))).WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, deleteBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobDeleteTest, BlobDeleteReturnsOk)
+{
+    // The boring case where the blobId is deleted.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobDeleteTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobDelete;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobDeleteTx) + blobId.length() + 1;
+
+    EXPECT_CALL(mgr, deleteBlob(StrEq(blobId))).WillOnce(Return(true));
+
+    EXPECT_EQ(IPMI_CC_OK, deleteBlob(&mgr, request, reply, &dataLen));
+}
+} // namespace blobs
diff --git a/test/ipmi_enumerate_unittest.cpp b/test/ipmi_enumerate_unittest.cpp
new file mode 100644
index 0000000..232fe7a
--- /dev/null
+++ b/test/ipmi_enumerate_unittest.cpp
@@ -0,0 +1,65 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobEnumerateTest, VerifyIfRequestByIdInvalidReturnsFailure)
+{
+    // This tests to verify that if the index is invalid, it'll return failure.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobEnumerateTx req;
+    uint8_t* request = reinterpret_cast<uint8_t*>(&req);
+
+    req.cmd = BlobOEMCommands::bmcBlobEnumerate;
+    req.blobIdx = 0;
+    dataLen = sizeof(struct BmcBlobEnumerateTx);
+
+    EXPECT_CALL(mgr, getBlobId(req.blobIdx)).WillOnce(Return(""));
+
+    EXPECT_EQ(IPMI_CC_INVALID, enumerateBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobEnumerateTest, BoringRequestByIdAndReceive)
+{
+    // This tests that if an index into the blob_id cache is valid, the command
+    // will return the blobId.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobEnumerateTx req;
+    struct BmcBlobEnumerateRx* rep;
+    uint8_t* request = reinterpret_cast<uint8_t*>(&req);
+    std::string blobId = "/asdf";
+
+    req.cmd = BlobOEMCommands::bmcBlobEnumerate;
+    req.blobIdx = 0;
+    dataLen = sizeof(struct BmcBlobEnumerateTx);
+
+    EXPECT_CALL(mgr, getBlobId(req.blobIdx)).WillOnce(Return(blobId));
+
+    EXPECT_EQ(IPMI_CC_OK, enumerateBlob(&mgr, request, reply, &dataLen));
+
+    // We're expecting this as a response.
+    // blobId.length + 1 + sizeof(uint16_t);
+    EXPECT_EQ(blobId.length() + 1 + sizeof(uint16_t), dataLen);
+
+    rep = reinterpret_cast<struct BmcBlobEnumerateRx*>(reply);
+    EXPECT_EQ(0, std::memcmp(rep->blobId, blobId.c_str(), blobId.length() + 1));
+}
+} // namespace blobs
diff --git a/test/ipmi_getcount_unittest.cpp b/test/ipmi_getcount_unittest.cpp
new file mode 100644
index 0000000..c6d74e6
--- /dev/null
+++ b/test/ipmi_getcount_unittest.cpp
@@ -0,0 +1,72 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+// the request here is only the subcommand byte and therefore there's no invalid
+// length check, etc to handle within the method.
+
+TEST(BlobCountTest, ReturnsZeroBlobs)
+{
+    // Calling BmcBlobGetCount if there are no handlers registered should just
+    // return that there are 0 blobs.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobCountTx req;
+    struct BmcBlobCountRx rep;
+    uint8_t* request = reinterpret_cast<uint8_t*>(&req);
+
+    req.cmd = BlobOEMCommands::bmcBlobGetCount;
+    dataLen = sizeof(req);
+
+    rep.crc = 0;
+    rep.blobCount = 0;
+
+    EXPECT_CALL(mgr, buildBlobList()).WillOnce(Return(0));
+
+    EXPECT_EQ(IPMI_CC_OK, getBlobCount(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+}
+
+TEST(BlobCountTest, ReturnsTwoBlobs)
+{
+    // Calling BmcBlobGetCount with one handler registered that knows of two
+    // blobs will return that it found two blobs.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    struct BmcBlobCountTx req;
+    struct BmcBlobCountRx rep;
+    uint8_t* request = reinterpret_cast<uint8_t*>(&req);
+
+    req.cmd = BlobOEMCommands::bmcBlobGetCount;
+    dataLen = sizeof(req);
+
+    rep.crc = 0;
+    rep.blobCount = 2;
+
+    EXPECT_CALL(mgr, buildBlobList()).WillOnce(Return(2));
+
+    EXPECT_EQ(IPMI_CC_OK, getBlobCount(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+}
+} // namespace blobs
diff --git a/test/ipmi_open_unittest.cpp b/test/ipmi_open_unittest.cpp
new file mode 100644
index 0000000..db2a34f
--- /dev/null
+++ b/test/ipmi_open_unittest.cpp
@@ -0,0 +1,108 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::NotNull;
+using ::testing::Return;
+using ::testing::StrEq;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobOpenTest, InvalidRequestLengthReturnsFailure)
+{
+    // There is a minimum blobId length of one character, this test verifies
+    // we check that.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobOpenTx*>(request);
+    std::string blobId = "abc";
+
+    req->cmd = BlobOEMCommands::bmcBlobOpen;
+    req->crc = 0;
+    req->flags = 0;
+    // length() doesn't include the nul-terminator.
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobOpenTx) + blobId.length();
+
+    EXPECT_EQ(IPMI_CC_INVALID, openBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobOpenTest, RequestRejectedReturnsFailure)
+{
+    // The blobId is rejected for any reason.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobOpenTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobOpen;
+    req->crc = 0;
+    req->flags = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobOpenTx) + blobId.length() + 1;
+
+    EXPECT_CALL(mgr, open(req->flags, StrEq(blobId), _))
+        .WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, openBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobOpenTest, BlobOpenReturnsOk)
+{
+    // The boring case where the blobId opens.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobOpenTx*>(request);
+    struct BmcBlobOpenRx rep;
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobOpen;
+    req->crc = 0;
+    req->flags = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobOpenTx) + blobId.length() + 1;
+    uint16_t returnedSession = 0x54;
+
+    EXPECT_CALL(mgr, open(req->flags, StrEq(blobId), NotNull()))
+        .WillOnce(Invoke(
+            [&](uint16_t flags, const std::string& path, uint16_t* session) {
+                (*session) = returnedSession;
+                return true;
+            }));
+
+    EXPECT_EQ(IPMI_CC_OK, openBlob(&mgr, request, reply, &dataLen));
+
+    rep.crc = 0;
+    rep.sessionId = returnedSession;
+
+    EXPECT_EQ(sizeof(rep), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+}
+} // namespace blobs
diff --git a/test/ipmi_read_unittest.cpp b/test/ipmi_read_unittest.cpp
new file mode 100644
index 0000000..b6dab55
--- /dev/null
+++ b/test/ipmi_read_unittest.cpp
@@ -0,0 +1,78 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobReadTest, ManagerReturnsNoData)
+{
+    // Verify that if no data is returned the IPMI command reply has no
+    // payload.  The manager, in all failures, will just return 0 bytes.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobReadTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobRead;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+    req->requestedSize = 0x10;
+
+    dataLen = sizeof(struct BmcBlobReadTx);
+
+    std::vector<uint8_t> data;
+
+    EXPECT_CALL(mgr, read(req->sessionId, req->offset, req->requestedSize))
+        .WillOnce(Return(data));
+
+    EXPECT_EQ(IPMI_CC_OK, readBlob(&mgr, request, reply, &dataLen));
+    EXPECT_EQ(sizeof(struct BmcBlobReadRx), dataLen);
+}
+
+TEST(BlobReadTest, ManagerReturnsData)
+{
+    // Verify that if data is returned, it's placed in the expected location.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobReadTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobRead;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+    req->requestedSize = 0x10;
+
+    dataLen = sizeof(struct BmcBlobReadTx);
+
+    std::vector<uint8_t> data = {0x02, 0x03, 0x05, 0x06};
+
+    EXPECT_CALL(mgr, read(req->sessionId, req->offset, req->requestedSize))
+        .WillOnce(Return(data));
+
+    EXPECT_EQ(IPMI_CC_OK, readBlob(&mgr, request, reply, &dataLen));
+    EXPECT_EQ(sizeof(struct BmcBlobReadRx) + data.size(), dataLen);
+    EXPECT_EQ(0, std::memcmp(&reply[sizeof(struct BmcBlobReadRx)], data.data(),
+                             data.size()));
+}
+
+/* TODO(venture): We need a test that handles other checks such as if the size
+ * requested won't fit into a packet response.
+ */
+} // namespace blobs
diff --git a/test/ipmi_sessionstat_unittest.cpp b/test/ipmi_sessionstat_unittest.cpp
new file mode 100644
index 0000000..e1e1aad
--- /dev/null
+++ b/test/ipmi_sessionstat_unittest.cpp
@@ -0,0 +1,121 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Matcher;
+using ::testing::NotNull;
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobSessionStatTest, RequestRejectedByManagerReturnsFailure)
+{
+    // If the session ID is invalid, the request must fail.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobSessionStatTx*>(request);
+    req->cmd = BlobOEMCommands::bmcBlobSessionStat;
+    req->crc = 0;
+    req->sessionId = 0x54;
+
+    dataLen = sizeof(struct BmcBlobSessionStatTx);
+
+    EXPECT_CALL(mgr, stat(Matcher<uint16_t>(req->sessionId),
+                          Matcher<struct BlobMeta*>(_)))
+        .WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, sessionStatBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobSessionStatTest, RequestSucceedsNoMetadata)
+{
+    // Stat request succeeeds but there were no metadata bytes.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobSessionStatTx*>(request);
+    req->cmd = BlobOEMCommands::bmcBlobSessionStat;
+    req->crc = 0;
+    req->sessionId = 0x54;
+
+    dataLen = sizeof(struct BmcBlobSessionStatTx);
+
+    struct BmcBlobStatRx rep;
+    rep.crc = 0x00;
+    rep.blobState = 0x01;
+    rep.size = 0x100;
+    rep.metadataLen = 0x00;
+
+    EXPECT_CALL(mgr, stat(Matcher<uint16_t>(req->sessionId),
+                          Matcher<struct BlobMeta*>(NotNull())))
+        .WillOnce(Invoke([&](uint16_t session, struct BlobMeta* meta) {
+            meta->blobState = rep.blobState;
+            meta->size = rep.size;
+            return true;
+        }));
+
+    EXPECT_EQ(IPMI_CC_OK, sessionStatBlob(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+}
+
+TEST(BlobSessionStatTest, RequestSucceedsWithMetadata)
+{
+    // Stat request succeeds and there were metadata bytes.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobSessionStatTx*>(request);
+    req->cmd = BlobOEMCommands::bmcBlobSessionStat;
+    req->crc = 0;
+    req->sessionId = 0x54;
+
+    dataLen = sizeof(struct BmcBlobSessionStatTx);
+
+    struct BlobMeta lmeta;
+    lmeta.blobState = 0x01;
+    lmeta.size = 0x100;
+    lmeta.metadata.push_back(0x01);
+    lmeta.metadata.push_back(0x02);
+    lmeta.metadata.push_back(0x03);
+    lmeta.metadata.push_back(0x04);
+
+    struct BmcBlobStatRx rep;
+    rep.crc = 0x00;
+    rep.blobState = lmeta.blobState;
+    rep.size = lmeta.size;
+    rep.metadataLen = lmeta.metadata.size();
+
+    EXPECT_CALL(mgr, stat(Matcher<uint16_t>(req->sessionId),
+                          Matcher<struct BlobMeta*>(NotNull())))
+        .WillOnce(Invoke([&](uint16_t session, struct BlobMeta* meta) {
+            (*meta) = lmeta;
+            return true;
+        }));
+
+    EXPECT_EQ(IPMI_CC_OK, sessionStatBlob(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep) + lmeta.metadata.size(), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+    EXPECT_EQ(0, std::memcmp(reply + sizeof(rep), lmeta.metadata.data(),
+                             lmeta.metadata.size()));
+}
+} // namespace blobs
diff --git a/test/ipmi_stat_unittest.cpp b/test/ipmi_stat_unittest.cpp
new file mode 100644
index 0000000..a6f1dfe
--- /dev/null
+++ b/test/ipmi_stat_unittest.cpp
@@ -0,0 +1,157 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Matcher;
+using ::testing::NotNull;
+using ::testing::Return;
+using ::testing::StrEq;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobStatTest, InvalidRequestLengthReturnsFailure)
+{
+    // There is a minimum blobId length of one character, this test verifies
+    // we check that.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobStatTx*>(request);
+    std::string blobId = "abc";
+
+    req->cmd = BlobOEMCommands::bmcBlobStat;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator.
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobStatTx) + blobId.length();
+
+    EXPECT_EQ(IPMI_CC_INVALID, statBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobStatTest, RequestRejectedReturnsFailure)
+{
+    // The blobId is rejected for any reason.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobStatTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobStat;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobStatTx) + blobId.length() + 1;
+
+    EXPECT_CALL(mgr, stat(Matcher<const std::string&>(StrEq(blobId)),
+                          Matcher<struct BlobMeta*>(_)))
+        .WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, statBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobStatTest, RequestSucceedsNoMetadata)
+{
+    // Stat request succeeeds but there were no metadata bytes.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobStatTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobStat;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobStatTx) + blobId.length() + 1;
+
+    struct BmcBlobStatRx rep;
+    rep.crc = 0x00;
+    rep.blobState = 0x01;
+    rep.size = 0x100;
+    rep.metadataLen = 0x00;
+
+    EXPECT_CALL(mgr, stat(Matcher<const std::string&>(StrEq(blobId)),
+                          Matcher<struct BlobMeta*>(NotNull())))
+        .WillOnce(Invoke([&](const std::string& path, struct BlobMeta* meta) {
+            meta->blobState = rep.blobState;
+            meta->size = rep.size;
+            return true;
+        }));
+
+    EXPECT_EQ(IPMI_CC_OK, statBlob(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+}
+
+TEST(BlobStatTest, RequestSucceedsWithMetadata)
+{
+    // Stat request succeeds and there were metadata bytes.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobStatTx*>(request);
+    std::string blobId = "a";
+
+    req->cmd = BlobOEMCommands::bmcBlobStat;
+    req->crc = 0;
+    // length() doesn't include the nul-terminator, request buff is initialized
+    // to 0s
+    std::memcpy(req->blobId, blobId.c_str(), blobId.length());
+
+    dataLen = sizeof(struct BmcBlobStatTx) + blobId.length() + 1;
+
+    struct BlobMeta lmeta;
+    lmeta.blobState = 0x01;
+    lmeta.size = 0x100;
+    lmeta.metadata.push_back(0x01);
+    lmeta.metadata.push_back(0x02);
+    lmeta.metadata.push_back(0x03);
+    lmeta.metadata.push_back(0x04);
+
+    struct BmcBlobStatRx rep;
+    rep.crc = 0x00;
+    rep.blobState = lmeta.blobState;
+    rep.size = lmeta.size;
+    rep.metadataLen = lmeta.metadata.size();
+
+    EXPECT_CALL(mgr, stat(Matcher<const std::string&>(StrEq(blobId)),
+                          Matcher<struct BlobMeta*>(NotNull())))
+        .WillOnce(Invoke([&](const std::string& path, struct BlobMeta* meta) {
+            (*meta) = lmeta;
+            return true;
+        }));
+
+    EXPECT_EQ(IPMI_CC_OK, statBlob(&mgr, request, reply, &dataLen));
+
+    EXPECT_EQ(sizeof(rep) + lmeta.metadata.size(), dataLen);
+    EXPECT_EQ(0, std::memcmp(reply, &rep, sizeof(rep)));
+    EXPECT_EQ(0, std::memcmp(reply + sizeof(rep), lmeta.metadata.data(),
+                             lmeta.metadata.size()));
+}
+} // namespace blobs
diff --git a/test/ipmi_unittest.cpp b/test/ipmi_unittest.cpp
new file mode 100644
index 0000000..8f27ed7
--- /dev/null
+++ b/test/ipmi_unittest.cpp
@@ -0,0 +1,60 @@
+#include "ipmi.hpp"
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(StringInputTest, NullPointerInput)
+{
+    // The method should verify it did receive a non-null input pointer.
+
+    EXPECT_STREQ("", stringFromBuffer(NULL, 5).c_str());
+}
+
+TEST(StringInputTest, ZeroBytesInput)
+{
+    // Verify that if the input length is 0 that it'll return the empty string.
+
+    const char* request = "asdf";
+    EXPECT_STREQ("", stringFromBuffer(request, 0).c_str());
+}
+
+TEST(StringInputTest, NulTerminatorNotFound)
+{
+    // Verify that if there isn't a nul-terminator found in an otherwise valid
+    // string, it'll return the emptry string.
+
+    char request[MAX_IPMI_BUFFER];
+    std::memset(request, 'a', sizeof(request));
+    EXPECT_STREQ("", stringFromBuffer(request, sizeof(request)).c_str());
+}
+
+TEST(StringInputTest, TwoNulsFound)
+{
+    // Verify it makes you use the entire data region for the string.
+    char request[MAX_IPMI_BUFFER];
+    request[0] = 'a';
+    request[1] = 0;
+    std::memset(&request[2], 'b', sizeof(request) - 2);
+    request[MAX_IPMI_BUFFER - 1] = 0;
+
+    // This case has two strings, and the last character is a nul-terminator.
+    EXPECT_STREQ("", stringFromBuffer(request, sizeof(request)).c_str());
+}
+
+TEST(StringInputTest, NulTerminatorFound)
+{
+    // Verify that if it's provided a valid nul-terminated string, it'll
+    // return it.
+
+    const char* request = "asdf";
+    EXPECT_STREQ("asdf", stringFromBuffer(request, 5).c_str());
+}
+} // namespace blobs
diff --git a/test/ipmi_validate_unittest.cpp b/test/ipmi_validate_unittest.cpp
new file mode 100644
index 0000000..6bf4200
--- /dev/null
+++ b/test/ipmi_validate_unittest.cpp
@@ -0,0 +1,44 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+TEST(IpmiValidateTest, VerifyCommandMinimumLengths)
+{
+
+    struct TestCase
+    {
+        BlobOEMCommands cmd;
+        size_t len;
+        bool expect;
+    };
+
+    std::vector<TestCase> tests = {
+        {BlobOEMCommands::bmcBlobClose, sizeof(struct BmcBlobCloseTx) - 1,
+         false},
+        {BlobOEMCommands::bmcBlobCommit, sizeof(struct BmcBlobCommitTx) - 1,
+         false},
+        {BlobOEMCommands::bmcBlobDelete, sizeof(struct BmcBlobDeleteTx) + 1,
+         false},
+        {BlobOEMCommands::bmcBlobEnumerate,
+         sizeof(struct BmcBlobEnumerateTx) - 1, false},
+        {BlobOEMCommands::bmcBlobOpen, sizeof(struct BmcBlobOpenTx) + 1, false},
+        {BlobOEMCommands::bmcBlobRead, sizeof(struct BmcBlobReadTx) - 1, false},
+        {BlobOEMCommands::bmcBlobSessionStat,
+         sizeof(struct BmcBlobSessionStatTx) - 1, false},
+        {BlobOEMCommands::bmcBlobStat, sizeof(struct BmcBlobStatTx) + 1, false},
+        {BlobOEMCommands::bmcBlobWrite, sizeof(struct BmcBlobWriteTx), false},
+    };
+
+    for (const auto& test : tests)
+    {
+        bool result = validateRequestLength(test.cmd, test.len);
+        EXPECT_EQ(result, test.expect);
+    }
+}
+} // namespace blobs
diff --git a/test/ipmi_write_unittest.cpp b/test/ipmi_write_unittest.cpp
new file mode 100644
index 0000000..55a1e3b
--- /dev/null
+++ b/test/ipmi_write_unittest.cpp
@@ -0,0 +1,73 @@
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::ElementsAreArray;
+using ::testing::Return;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+TEST(BlobWriteTest, ManagerReturnsFailureReturnsFailure)
+{
+    // This verifies a failure from the manager is passed back.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobWriteTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobWrite;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+
+    uint8_t expectedBytes[2] = {0x66, 0x67};
+    std::memcpy(req->data, &expectedBytes[0], sizeof(expectedBytes));
+
+    dataLen = sizeof(struct BmcBlobWriteTx) + sizeof(expectedBytes);
+
+    EXPECT_CALL(mgr,
+                write(req->sessionId, req->offset,
+                      ElementsAreArray(expectedBytes, sizeof(expectedBytes))))
+        .WillOnce(Return(false));
+
+    EXPECT_EQ(IPMI_CC_INVALID, writeBlob(&mgr, request, reply, &dataLen));
+}
+
+TEST(BlobWriteTest, ManagerReturnsTrueWriteSucceeds)
+{
+    // The case where everything works.
+
+    ManagerMock mgr;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    auto req = reinterpret_cast<struct BmcBlobWriteTx*>(request);
+
+    req->cmd = BlobOEMCommands::bmcBlobWrite;
+    req->crc = 0;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+
+    uint8_t expectedBytes[2] = {0x66, 0x67};
+    std::memcpy(req->data, &expectedBytes[0], sizeof(expectedBytes));
+
+    dataLen = sizeof(struct BmcBlobWriteTx) + sizeof(expectedBytes);
+
+    EXPECT_CALL(mgr,
+                write(req->sessionId, req->offset,
+                      ElementsAreArray(expectedBytes, sizeof(expectedBytes))))
+        .WillOnce(Return(true));
+
+    EXPECT_EQ(IPMI_CC_OK, writeBlob(&mgr, request, reply, &dataLen));
+}
+} // namespace blobs
diff --git a/test/manager_close_unittest.cpp b/test/manager_close_unittest.cpp
new file mode 100644
index 0000000..47c9264
--- /dev/null
+++ b/test/manager_close_unittest.cpp
@@ -0,0 +1,66 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerCloseTest, CloseNoSessionReturnsFalse)
+{
+    // Calling Close on a session that doesn't exist should return false.
+
+    BlobManager mgr;
+    uint16_t sess = 1;
+
+    EXPECT_FALSE(mgr.close(sess));
+}
+
+TEST(ManagerCloseTest, CloseSessionFoundButHandlerReturnsFalse)
+{
+    // The handler was found but it returned failure.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_CALL(*m1ptr, close(sess)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.close(sess));
+
+    // TODO(venture): The session wasn't closed, need to verify.  Could call
+    // public GetHandler method.
+}
+
+TEST(ManagerCloseTest, CloseSessionFoundAndHandlerReturnsSuccess)
+{
+    // The handler was found and returned success.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_CALL(*m1ptr, close(sess)).WillOnce(Return(true));
+
+    EXPECT_TRUE(mgr.close(sess));
+}
+} // namespace blobs
diff --git a/test/manager_commit_unittest.cpp b/test/manager_commit_unittest.cpp
new file mode 100644
index 0000000..b1b3c8c
--- /dev/null
+++ b/test/manager_commit_unittest.cpp
@@ -0,0 +1,68 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerCommitTest, CommitNoSessionReturnsFalse)
+{
+    // Calling Commit on a session that doesn't exist should return false.
+
+    BlobManager mgr;
+    uint16_t sess = 1;
+    std::vector<uint8_t> data;
+
+    EXPECT_FALSE(mgr.commit(sess, data));
+}
+
+TEST(ManagerCommitTest, CommitSessionFoundButHandlerReturnsFalse)
+{
+    // The handler was found but it returned failure.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::write, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    std::vector<uint8_t> data;
+    EXPECT_CALL(*m1ptr, commit(sess, data)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.commit(sess, data));
+}
+
+TEST(ManagerCommitTest, CommitSessionFoundAndHandlerReturnsSuccess)
+{
+    // The handler was found and returned success.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::write, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    std::vector<uint8_t> data;
+    EXPECT_CALL(*m1ptr, commit(sess, data)).WillOnce(Return(true));
+
+    EXPECT_TRUE(mgr.commit(sess, data));
+}
+} // namespace blobs
diff --git a/test/manager_delete_unittest.cpp b/test/manager_delete_unittest.cpp
new file mode 100644
index 0000000..9ad3afd
--- /dev/null
+++ b/test/manager_delete_unittest.cpp
@@ -0,0 +1,87 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerDeleteTest, FileIsOpenReturnsFailure)
+{
+    // The blob manager maintains a naive list of open files and will
+    // return failure if you try to delete an open file.
+
+    // Open the file.
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillRepeatedly(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    // Try to delete the file.
+    EXPECT_FALSE(mgr.deleteBlob(path));
+}
+
+TEST(ManagerDeleteTest, FileHasNoHandler)
+{
+    // The blob manager cannot find any handler.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(false));
+
+    // Try to delete the file.
+    EXPECT_FALSE(mgr.deleteBlob(path));
+}
+
+TEST(ManagerDeleteTest, FileIsNotOpenButHandlerDeleteFails)
+{
+    // The Blob manager finds the handler but the handler returns failure
+    // on delete.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, deleteBlob(path)).WillOnce(Return(false));
+
+    // Try to delete the file.
+    EXPECT_FALSE(mgr.deleteBlob(path));
+}
+
+TEST(ManagerDeleteTest, FileIsNotOpenAndHandlerSucceeds)
+{
+    // The Blob manager finds the handler and the handler returns success.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, deleteBlob(path)).WillOnce(Return(true));
+
+    // Try to delete the file.
+    EXPECT_TRUE(mgr.deleteBlob(path));
+}
+} // namespace blobs
diff --git a/test/manager_getsession_unittest.cpp b/test/manager_getsession_unittest.cpp
new file mode 100644
index 0000000..e66729a
--- /dev/null
+++ b/test/manager_getsession_unittest.cpp
@@ -0,0 +1,24 @@
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+TEST(ManagerGetSessionTest, NextSessionReturned)
+{
+    // This test verifies the next session ID is returned.
+    BlobManager mgr;
+
+    uint16_t first, second;
+    EXPECT_TRUE(mgr.getSession(&first));
+    EXPECT_TRUE(mgr.getSession(&second));
+    EXPECT_FALSE(first == second);
+}
+
+TEST(ManagerGetSessionTest, SessionsCheckedAgainstList)
+{
+    // TODO(venture): Need a test that verifies the session ids are checked
+    // against open sessions.
+}
+} // namespace blobs
diff --git a/test/manager_mock.hpp b/test/manager_mock.hpp
new file mode 100644
index 0000000..41979ac
--- /dev/null
+++ b/test/manager_mock.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "blobs.hpp"
+#include "manager.hpp"
+
+#include <memory>
+#include <string>
+
+#include <gmock/gmock.h>
+
+namespace blobs
+{
+
+class ManagerMock : public ManagerInterface
+{
+  public:
+    virtual ~ManagerMock() = default;
+
+    MOCK_METHOD1(registerHandler, bool(std::unique_ptr<GenericBlobInterface>));
+    MOCK_METHOD0(buildBlobList, uint32_t());
+    MOCK_METHOD1(getBlobId, std::string(uint32_t));
+    MOCK_METHOD3(open, bool(uint16_t, const std::string&, uint16_t*));
+    MOCK_METHOD2(stat, bool(const std::string&, struct BlobMeta*));
+    MOCK_METHOD2(stat, bool(uint16_t, struct BlobMeta*));
+    MOCK_METHOD2(commit, bool(uint16_t, const std::vector<uint8_t>&));
+    MOCK_METHOD1(close, bool(uint16_t));
+    MOCK_METHOD3(read, std::vector<uint8_t>(uint16_t, uint32_t, uint32_t));
+    MOCK_METHOD3(write, bool(uint16_t, uint32_t, const std::vector<uint8_t>&));
+    MOCK_METHOD1(deleteBlob, bool(const std::string&));
+};
+} // namespace blobs
diff --git a/test/manager_open_unittest.cpp b/test/manager_open_unittest.cpp
new file mode 100644
index 0000000..309d3f6
--- /dev/null
+++ b/test/manager_open_unittest.cpp
@@ -0,0 +1,85 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerOpenTest, OpenButNoHandler)
+{
+    // No handler claims to be able to open the file.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(false));
+    EXPECT_FALSE(mgr.open(flags, path, &sess));
+}
+
+TEST(ManagerOpenTest, OpenButHandlerFailsOpen)
+{
+    // The handler is found but Open fails.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(false));
+    EXPECT_FALSE(mgr.open(flags, path, &sess));
+}
+
+TEST(ManagerOpenTest, OpenFailsMustSupplyAtLeastReadOrWriteFlag)
+{
+    // One must supply either read or write in the flags for the session to
+    // open.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = 0, sess;
+    std::string path = "/asdf/asdf";
+
+    /* It checks if someone can handle the blob before it checks the flags. */
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+
+    EXPECT_FALSE(mgr.open(flags, path, &sess));
+}
+
+TEST(ManagerOpenTest, OpenSucceeds)
+{
+    // The handler is found and Open succeeds.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    // TODO(venture): Need a way to verify the session is associated with it,
+    // maybe just call Read() or SessionStat()
+}
+} // namespace blobs
diff --git a/test/manager_read_unittest.cpp b/test/manager_read_unittest.cpp
new file mode 100644
index 0000000..1d40f5d
--- /dev/null
+++ b/test/manager_read_unittest.cpp
@@ -0,0 +1,78 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerReadTest, ReadNoSessionReturnsFalse)
+{
+    // Calling Read on a session that doesn't exist should return false.
+
+    BlobManager mgr;
+    uint16_t sess = 1;
+    uint32_t ofs = 0x54;
+    uint32_t requested = 0x100;
+
+    std::vector<uint8_t> result = mgr.read(sess, ofs, requested);
+    EXPECT_EQ(0, result.size());
+}
+
+TEST(ManagerReadTest, ReadFromWriteOnlyFails)
+{
+    // The session manager will not route a Read call to a blob if the session
+    // was opened as write-only.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t sess = 1;
+    uint32_t ofs = 0x54;
+    uint32_t requested = 0x100;
+    uint16_t flags = OpenFlags::write;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    std::vector<uint8_t> result = mgr.read(sess, ofs, requested);
+    EXPECT_EQ(0, result.size());
+}
+
+TEST(ManagerReadTest, ReadFromHandlerReturnsData)
+{
+    // There is no logic in this as it's just as a pass-thru command, however
+    // we want to verify this behavior doesn't change.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t sess = 1;
+    uint32_t ofs = 0x54;
+    uint32_t requested = 0x100;
+    uint16_t flags = OpenFlags::read;
+    std::string path = "/asdf/asdf";
+    std::vector<uint8_t> data = {0x12, 0x14, 0x15, 0x16};
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_CALL(*m1ptr, read(sess, ofs, requested)).WillOnce(Return(data));
+
+    std::vector<uint8_t> result = mgr.read(sess, ofs, requested);
+    EXPECT_EQ(data.size(), result.size());
+    EXPECT_EQ(result, data);
+}
+} // namespace blobs
diff --git a/test/manager_sessionstat_unittest.cpp b/test/manager_sessionstat_unittest.cpp
new file mode 100644
index 0000000..6ae27d3
--- /dev/null
+++ b/test/manager_sessionstat_unittest.cpp
@@ -0,0 +1,66 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST(ManagerSessionStatTest, StatNoSessionReturnsFalse)
+{
+    // Calling Stat on a session that doesn't exist should return false.
+
+    BlobManager mgr;
+    struct BlobMeta meta;
+    uint16_t sess = 1;
+
+    EXPECT_FALSE(mgr.stat(sess, &meta));
+}
+
+TEST(ManagerSessionStatTest, StatSessionFoundButHandlerReturnsFalse)
+{
+    // The handler was found but it returned failure.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    struct BlobMeta meta;
+    EXPECT_CALL(*m1ptr, stat(sess, &meta)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.stat(sess, &meta));
+}
+
+TEST(ManagerSessionStatTest, StatSessionFoundAndHandlerReturnsSuccess)
+{
+    // The handler was found and returned success.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    struct BlobMeta meta;
+    EXPECT_CALL(*m1ptr, stat(sess, &meta)).WillOnce(Return(true));
+
+    EXPECT_TRUE(mgr.stat(sess, &meta));
+}
+} // namespace blobs
diff --git a/test/manager_stat_unittest.cpp b/test/manager_stat_unittest.cpp
new file mode 100644
index 0000000..a13a66d
--- /dev/null
+++ b/test/manager_stat_unittest.cpp
@@ -0,0 +1,60 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Return;
+
+TEST(ManagerStatTest, StatNoHandler)
+{
+    // There is no handler for this path.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    struct BlobMeta meta;
+    std::string path = "/asdf/asdf";
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.stat(path, &meta));
+}
+
+TEST(ManagerStatTest, StatHandlerFoundButFails)
+{
+    // There is a handler for this path but Stat fails.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    struct BlobMeta meta;
+    std::string path = "/asdf/asdf";
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, stat(path, &meta)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.stat(path, &meta));
+}
+
+TEST(ManagerStatTest, StatHandlerFoundAndSucceeds)
+{
+    // There is a handler and Stat succeeds.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    struct BlobMeta meta;
+    std::string path = "/asdf/asdf";
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, stat(path, &meta)).WillOnce(Return(true));
+
+    EXPECT_TRUE(mgr.stat(path, &meta));
+}
+} // namespace blobs
diff --git a/test/manager_unittest.cpp b/test/manager_unittest.cpp
new file mode 100644
index 0000000..7d4d49e
--- /dev/null
+++ b/test/manager_unittest.cpp
@@ -0,0 +1,172 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::Return;
+
+TEST(BlobsTest, RegisterNullPointerFails)
+{
+    // The only invalid pointer really is a null one.
+
+    BlobManager mgr;
+    EXPECT_FALSE(mgr.registerHandler(nullptr));
+}
+
+TEST(BlobsTest, RegisterNonNullPointerPasses)
+{
+    // Test that the valid pointer is boringly registered.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+}
+
+TEST(BlobsTest, GetCountNoBlobsRegistered)
+{
+    // Request the Blob Count when there are no blobs.
+
+    BlobManager mgr;
+    EXPECT_EQ(0, mgr.buildBlobList());
+}
+
+TEST(BlobsTest, GetCountBlobRegisteredReturnsOne)
+{
+    // Request the blob count and verify the list is of length one.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    std::vector<std::string> v = {"item"};
+
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    // We expect it to ask for the list.
+    EXPECT_CALL(*m1ptr, getBlobIds()).WillOnce(Return(v));
+
+    EXPECT_EQ(1, mgr.buildBlobList());
+}
+
+TEST(BlobsTest, GetCountBlobsRegisteredEachReturnsOne)
+{
+    // Request the blob count and verify the list is of length two.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    std::unique_ptr<BlobMock> m2 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    auto m2ptr = m2.get();
+    std::vector<std::string> v1, v2;
+
+    v1.push_back("asdf");
+    v2.push_back("ghjk");
+
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+    EXPECT_TRUE(mgr.registerHandler(std::move(m2)));
+
+    // We expect it to ask for the list.
+    EXPECT_CALL(*m1ptr, getBlobIds()).WillOnce(Return(v1));
+    EXPECT_CALL(*m2ptr, getBlobIds()).WillOnce(Return(v2));
+
+    EXPECT_EQ(2, mgr.buildBlobList());
+}
+
+TEST(BlobsTest, EnumerateBlobZerothEntry)
+{
+    // Validate that you can read back the 0th blobId.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    std::unique_ptr<BlobMock> m2 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    auto m2ptr = m2.get();
+    std::vector<std::string> v1, v2;
+
+    v1.push_back("asdf");
+    v2.push_back("ghjk");
+
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+    EXPECT_TRUE(mgr.registerHandler(std::move(m2)));
+
+    // We expect it to ask for the list.
+    EXPECT_CALL(*m1ptr, getBlobIds()).WillOnce(Return(v1));
+    EXPECT_CALL(*m2ptr, getBlobIds()).WillOnce(Return(v2));
+
+    EXPECT_EQ(2, mgr.buildBlobList());
+
+    std::string result = mgr.getBlobId(0);
+    // The exact order the blobIds is returned is not guaranteed to never
+    // change.
+    EXPECT_TRUE("asdf" == result || "ghjk" == result);
+}
+
+TEST(BlobsTest, EnumerateBlobFirstEntry)
+{
+    // Validate you can read back the two real entries.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    std::unique_ptr<BlobMock> m2 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    auto m2ptr = m2.get();
+    std::vector<std::string> v1, v2;
+
+    v1.push_back("asdf");
+    v2.push_back("ghjk");
+
+    // Presently the list of blobs is read and appended in a specific order,
+    // but I don't want to rely on that.
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+    EXPECT_TRUE(mgr.registerHandler(std::move(m2)));
+
+    // We expect it to ask for the list.
+    EXPECT_CALL(*m1ptr, getBlobIds()).WillOnce(Return(v1));
+    EXPECT_CALL(*m2ptr, getBlobIds()).WillOnce(Return(v2));
+
+    EXPECT_EQ(2, mgr.buildBlobList());
+
+    // Try to grab the two blobIds and verify they're in the list.
+    std::vector<std::string> results;
+    results.push_back(mgr.getBlobId(0));
+    results.push_back(mgr.getBlobId(1));
+    EXPECT_EQ(2, results.size());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "asdf") !=
+                results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "ghjk") !=
+                results.end());
+}
+
+TEST(BlobTest, EnumerateBlobInvalidEntry)
+{
+    // Validate trying to read an invalid entry fails expectedly.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    std::unique_ptr<BlobMock> m2 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    auto m2ptr = m2.get();
+    std::vector<std::string> v1, v2;
+
+    v1.push_back("asdf");
+    v2.push_back("ghjk");
+
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+    EXPECT_TRUE(mgr.registerHandler(std::move(m2)));
+
+    // We expect it to ask for the list.
+    EXPECT_CALL(*m1ptr, getBlobIds()).WillOnce(Return(v1));
+    EXPECT_CALL(*m2ptr, getBlobIds()).WillOnce(Return(v2));
+
+    EXPECT_EQ(2, mgr.buildBlobList());
+
+    // Grabs the third entry which isn't valid.
+    EXPECT_STREQ("", mgr.getBlobId(2).c_str());
+}
+} // namespace blobs
diff --git a/test/manager_write_unittest.cpp b/test/manager_write_unittest.cpp
new file mode 100644
index 0000000..33c6d5a
--- /dev/null
+++ b/test/manager_write_unittest.cpp
@@ -0,0 +1,90 @@
+#include "blob_mock.hpp"
+#include "manager.hpp"
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::Return;
+
+namespace blobs
+{
+
+TEST(ManagerWriteTest, WriteNoSessionReturnsFalse)
+{
+    // Calling Write on a session that doesn't exist should return false.
+
+    BlobManager mgr;
+    uint16_t sess = 1;
+    uint32_t ofs = 0x54;
+    std::vector<uint8_t> data = {0x11, 0x22};
+
+    EXPECT_FALSE(mgr.write(sess, ofs, data));
+}
+
+TEST(ManagerWriteTest, WriteSessionFoundButHandlerReturnsFalse)
+{
+    // The handler was found but it returned failure.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::write, sess;
+    std::string path = "/asdf/asdf";
+    uint32_t ofs = 0x54;
+    std::vector<uint8_t> data = {0x11, 0x22};
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_CALL(*m1ptr, write(sess, ofs, data)).WillOnce(Return(false));
+
+    EXPECT_FALSE(mgr.write(sess, ofs, data));
+}
+
+TEST(ManagerWriteTest, WriteFailsBecauseFileOpenedReadOnly)
+{
+    // The manager will not route a write call to a file opened read-only.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::read, sess;
+    std::string path = "/asdf/asdf";
+    uint32_t ofs = 0x54;
+    std::vector<uint8_t> data = {0x11, 0x22};
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_FALSE(mgr.write(sess, ofs, data));
+}
+
+TEST(ManagerWriteTest, WriteSessionFoundAndHandlerReturnsSuccess)
+{
+    // The handler was found and returned success.
+
+    BlobManager mgr;
+    std::unique_ptr<BlobMock> m1 = std::make_unique<BlobMock>();
+    auto m1ptr = m1.get();
+    EXPECT_TRUE(mgr.registerHandler(std::move(m1)));
+
+    uint16_t flags = OpenFlags::write, sess;
+    std::string path = "/asdf/asdf";
+    uint32_t ofs = 0x54;
+    std::vector<uint8_t> data = {0x11, 0x22};
+
+    EXPECT_CALL(*m1ptr, canHandleBlob(path)).WillOnce(Return(true));
+    EXPECT_CALL(*m1ptr, open(_, flags, path)).WillOnce(Return(true));
+    EXPECT_TRUE(mgr.open(flags, path, &sess));
+
+    EXPECT_CALL(*m1ptr, write(sess, ofs, data)).WillOnce(Return(true));
+
+    EXPECT_TRUE(mgr.write(sess, ofs, data));
+}
+} // namespace blobs
diff --git a/test/process_unittest.cpp b/test/process_unittest.cpp
new file mode 100644
index 0000000..2ffb023
--- /dev/null
+++ b/test/process_unittest.cpp
@@ -0,0 +1,290 @@
+#include "crc.hpp"
+#include "crc_mock.hpp"
+#include "ipmi.hpp"
+#include "manager_mock.hpp"
+#include "process.hpp"
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+namespace blobs
+{
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::StrictMock;
+
+// ipmid.hpp isn't installed where we can grab it and this value is per BMC
+// SoC.
+#define MAX_IPMI_BUFFER 64
+
+namespace
+{
+
+void EqualFunctions(IpmiBlobHandler lhs, IpmiBlobHandler rhs)
+{
+    EXPECT_FALSE(lhs == nullptr);
+    EXPECT_FALSE(rhs == nullptr);
+
+    ipmi_ret_t (*const* lPtr)(ManagerInterface*, const uint8_t*, uint8_t*,
+                              size_t*) =
+        lhs.target<ipmi_ret_t (*)(ManagerInterface*, const uint8_t*, uint8_t*,
+                                  size_t*)>();
+
+    ipmi_ret_t (*const* rPtr)(ManagerInterface*, const uint8_t*, uint8_t*,
+                              size_t*) =
+        rhs.target<ipmi_ret_t (*)(ManagerInterface*, const uint8_t*, uint8_t*,
+                                  size_t*)>();
+
+    EXPECT_TRUE(lPtr);
+    EXPECT_TRUE(rPtr);
+    EXPECT_EQ(*lPtr, *rPtr);
+    return;
+}
+
+} // namespace
+
+TEST(ValidateBlobCommandTest, InvalidCommandReturnsFailure)
+{
+    // Verify we handle an invalid command.
+
+    StrictMock<CrcMock> crc;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    request[0] = 0xff;         // There is no command 0xff.
+    dataLen = sizeof(uint8_t); // There is no payload for CRC.
+
+    EXPECT_EQ(nullptr, validateBlobCommand(&crc, request, reply, &dataLen));
+}
+
+TEST(ValidateBlobCommandTest, ValidCommandWithoutPayload)
+{
+    // Verify we handle a valid command that doesn't have a payload.
+
+    StrictMock<CrcMock> crc;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    request[0] = BlobOEMCommands::bmcBlobGetCount;
+    dataLen = sizeof(uint8_t); // There is no payload for CRC.
+
+    IpmiBlobHandler res = validateBlobCommand(&crc, request, reply, &dataLen);
+    EXPECT_FALSE(res == nullptr);
+    EqualFunctions(getBlobCount, res);
+}
+
+TEST(ValidateBlobCommandTest, WithPayloadMinimumLengthIs3VerifyChecks)
+{
+    // Verify that if there's a payload, it's at least one command byte and
+    // two bytes for the crc16 and then one data byte.
+
+    StrictMock<CrcMock> crc;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    request[0] = BlobOEMCommands::bmcBlobGetCount;
+    dataLen = sizeof(uint8_t) + sizeof(uint16_t);
+    // There is a payload, but there are insufficient bytes.
+
+    EXPECT_EQ(nullptr, validateBlobCommand(&crc, request, reply, &dataLen));
+}
+
+TEST(ValidateBlobCommandTest, WithPayloadAndInvalidCrc)
+{
+    // Verify that the CRC is checked, and failure is reported.
+
+    StrictMock<CrcMock> crc;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    auto req = reinterpret_cast<struct BmcBlobWriteTx*>(request);
+    req->cmd = BlobOEMCommands::bmcBlobWrite;
+    req->crc = 0x34;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+
+    uint8_t expectedBytes[2] = {0x66, 0x67};
+    std::memcpy(req->data, &expectedBytes[0], sizeof(expectedBytes));
+
+    dataLen = sizeof(struct BmcBlobWriteTx) + sizeof(expectedBytes);
+
+    // skip over cmd and crc.
+    size_t expectedLen = dataLen - 3;
+
+    EXPECT_CALL(crc, clear());
+    EXPECT_CALL(crc, compute(_, expectedLen))
+        .WillOnce(Invoke([&](const uint8_t* bytes, uint32_t length) {
+            EXPECT_EQ(0, std::memcmp(&request[3], bytes, length));
+        }));
+    EXPECT_CALL(crc, get()).WillOnce(Return(0x1234));
+
+    EXPECT_EQ(nullptr, validateBlobCommand(&crc, request, reply, &dataLen));
+}
+
+TEST(ValidateBlobCommandTest, WithPayloadAndValidCrc)
+{
+    // Verify the CRC is checked and if it matches, return the handler.
+
+    StrictMock<CrcMock> crc;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    auto req = reinterpret_cast<struct BmcBlobWriteTx*>(request);
+    req->cmd = BlobOEMCommands::bmcBlobWrite;
+    req->crc = 0x3412;
+    req->sessionId = 0x54;
+    req->offset = 0x100;
+
+    uint8_t expectedBytes[2] = {0x66, 0x67};
+    std::memcpy(req->data, &expectedBytes[0], sizeof(expectedBytes));
+
+    dataLen = sizeof(struct BmcBlobWriteTx) + sizeof(expectedBytes);
+
+    // skip over cmd and crc.
+    size_t expectedLen = dataLen - 3;
+
+    EXPECT_CALL(crc, clear());
+    EXPECT_CALL(crc, compute(_, expectedLen))
+        .WillOnce(Invoke([&](const uint8_t* bytes, uint32_t length) {
+            EXPECT_EQ(0, std::memcmp(&request[3], bytes, length));
+        }));
+    EXPECT_CALL(crc, get()).WillOnce(Return(0x3412));
+
+    IpmiBlobHandler res = validateBlobCommand(&crc, request, reply, &dataLen);
+    EXPECT_FALSE(res == nullptr);
+    EqualFunctions(writeBlob, res);
+}
+
+TEST(ValidateBlobCommandTest, InputIntegrationTest)
+{
+    // Given a request buffer generated by the host-side utility, verify it is
+    // properly routed.
+
+    Crc16 crc;
+    size_t dataLen;
+    uint8_t request[] = {0x02, 0x88, 0x21, 0x03, 0x00, 0x2f, 0x64, 0x65, 0x76,
+                         0x2f, 0x68, 0x61, 0x76, 0x65, 0x6e, 0x2f, 0x63, 0x6f,
+                         0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x70, 0x61, 0x73,
+                         0x73, 0x74, 0x68, 0x72, 0x75, 0x00};
+
+    // The above request to open a file for reading & writing named:
+    // "/dev/haven/command_passthru"
+
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    dataLen = sizeof(request);
+
+    IpmiBlobHandler res = validateBlobCommand(&crc, request, reply, &dataLen);
+    EXPECT_FALSE(res == nullptr);
+    EqualFunctions(openBlob, res);
+}
+
+TEST(ProcessBlobCommandTest, CommandReturnsNotOk)
+{
+    // Verify that if the IPMI command handler returns not OK that this is
+    // noticed and returned.
+
+    StrictMock<CrcMock> crc;
+    StrictMock<ManagerMock> manager;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    IpmiBlobHandler h = [](ManagerInterface* mgr, const uint8_t* reqBuf,
+                           uint8_t* replyCmdBuf,
+                           size_t* dataLen) { return IPMI_CC_INVALID; };
+
+    dataLen = sizeof(request);
+
+    EXPECT_EQ(IPMI_CC_INVALID,
+              processBlobCommand(h, &manager, &crc, request, reply, &dataLen));
+}
+
+TEST(ProcessBlobCommandTest, CommandReturnsOkWithNoPayload)
+{
+    // Verify that if the IPMI command handler returns OK but without a payload
+    // it doesn't try to compute a CRC.
+
+    StrictMock<CrcMock> crc;
+    StrictMock<ManagerMock> manager;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    IpmiBlobHandler h = [](ManagerInterface* mgr, const uint8_t* reqBuf,
+                           uint8_t* replyCmdBuf, size_t* dataLen) {
+        (*dataLen) = 0;
+        return IPMI_CC_OK;
+    };
+
+    dataLen = sizeof(request);
+
+    EXPECT_EQ(IPMI_CC_OK,
+              processBlobCommand(h, &manager, &crc, request, reply, &dataLen));
+}
+
+TEST(ProcessBlobCommandTest, CommandReturnsOkWithInvalidPayloadLength)
+{
+    // There is a minimum payload length of 3 bytes, this command returns a
+    // payload of 2 bytes.
+
+    StrictMock<CrcMock> crc;
+    StrictMock<ManagerMock> manager;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+
+    IpmiBlobHandler h = [](ManagerInterface* mgr, const uint8_t* reqBuf,
+                           uint8_t* replyCmdBuf, size_t* dataLen) {
+        (*dataLen) = sizeof(uint16_t);
+        return IPMI_CC_OK;
+    };
+
+    dataLen = sizeof(request);
+
+    EXPECT_EQ(IPMI_CC_INVALID,
+              processBlobCommand(h, &manager, &crc, request, reply, &dataLen));
+}
+
+TEST(ProcessBlobCommandTest, CommandReturnsOkWithValidPayloadLength)
+{
+    // There is a minimum payload length of 3 bytes, this command returns a
+    // payload of 3 bytes and the crc code is called to process the payload.
+
+    StrictMock<CrcMock> crc;
+    StrictMock<ManagerMock> manager;
+    size_t dataLen;
+    uint8_t request[MAX_IPMI_BUFFER] = {0};
+    uint8_t reply[MAX_IPMI_BUFFER] = {0};
+    uint32_t payloadLen = sizeof(uint16_t) + sizeof(uint8_t);
+
+    IpmiBlobHandler h = [payloadLen](ManagerInterface* mgr,
+                                     const uint8_t* reqBuf,
+                                     uint8_t* replyCmdBuf, size_t* dataLen) {
+        (*dataLen) = payloadLen;
+        replyCmdBuf[2] = 0x56;
+        return IPMI_CC_OK;
+    };
+
+    dataLen = sizeof(request);
+
+    EXPECT_CALL(crc, clear());
+    EXPECT_CALL(crc, compute(_, payloadLen));
+    EXPECT_CALL(crc, get()).WillOnce(Return(0x3412));
+
+    EXPECT_EQ(IPMI_CC_OK,
+              processBlobCommand(h, &manager, &crc, request, reply, &dataLen));
+    EXPECT_EQ(dataLen, payloadLen);
+
+    uint8_t expectedBytes[3] = {0x12, 0x34, 0x56};
+    EXPECT_EQ(0, std::memcmp(expectedBytes, reply, sizeof(expectedBytes)));
+}
+} // namespace blobs