diff --git a/test/Makefile.am b/test/Makefile.am
index e5ea1ff..568b361 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -33,12 +33,9 @@
 	firmware_sessionstat_unittest \
 	firmware_commit_unittest \
 	file_handler_unittest \
-	tools_blob_unittest \
 	tools_bt_unittest \
 	tools_lpc_unittest \
-	tools_updater_unittest \
-	tools_ipmi_unittest \
-	tools_ipmi_error_unittest
+	tools_updater_unittest
 
 TESTS = $(check_PROGRAMS)
 
@@ -78,9 +75,6 @@
 file_handler_unittest_SOURCES = file_handler_unittest.cpp
 file_handler_unittest_LDADD = $(top_builddir)/file_handler.o -lstdc++fs
 
-tools_blob_unittest_SOURCES = tools_blob_unittest.cpp
-tools_blob_unittest_LDADD = $(top_builddir)/tools/blob_handler.o
-
 tools_bt_unittest_SOURCES = tools_bt_unittest.cpp
 tools_bt_unittest_LDADD = $(top_builddir)/tools/bt.o
 
@@ -89,9 +83,3 @@
 
 tools_updater_unittest_SOURCES = tools_updater_unittest.cpp
 tools_updater_unittest_LDADD = $(top_builddir)/tools/updater.o
-
-tools_ipmi_unittest_SOURCES = tools_ipmi_unittest.cpp
-tools_ipmi_unittest_LDADD = $(top_builddir)/tools/ipmi_handler.o
-
-tools_ipmi_error_unittest_SOURCES = tools_ipmi_error_unittest.cpp
-tools_ipmi_error_unittest_LDADD =
diff --git a/test/blob_interface_mock.hpp b/test/blob_interface_mock.hpp
deleted file mode 100644
index 845d7c1..0000000
--- a/test/blob_interface_mock.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "blob_interface.hpp"
-
-#include <gmock/gmock.h>
-
-namespace host_tool
-{
-
-class BlobInterfaceMock : public BlobInterface
-{
-  public:
-    virtual ~BlobInterfaceMock() = default;
-    MOCK_METHOD3(writeMeta, void(std::uint16_t, std::uint32_t,
-                                 const std::vector<std::uint8_t>&));
-    MOCK_METHOD3(writeBytes, void(std::uint16_t, std::uint32_t,
-                                  const std::vector<std::uint8_t>&));
-    MOCK_METHOD0(getBlobList, std::vector<std::string>());
-    MOCK_METHOD1(getStat, StatResponse(const std::string&));
-    MOCK_METHOD2(openBlob,
-                 std::uint16_t(const std::string&,
-                               blobs::FirmwareBlobHandler::UpdateFlags));
-    MOCK_METHOD1(closeBlob, void(std::uint16_t));
-    MOCK_METHOD3(readBytes,
-                 std::vector<std::uint8_t>(std::uint16_t, std::uint32_t,
-                                           std::uint32_t));
-};
-
-} // namespace host_tool
diff --git a/test/ipmi_interface_mock.hpp b/test/ipmi_interface_mock.hpp
deleted file mode 100644
index 374dc93..0000000
--- a/test/ipmi_interface_mock.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "ipmi_interface.hpp"
-
-#include <gmock/gmock.h>
-
-namespace host_tool
-{
-
-class IpmiInterfaceMock : public IpmiInterface
-{
-  public:
-    virtual ~IpmiInterfaceMock() = default;
-    MOCK_METHOD1(sendPacket,
-                 std::vector<std::uint8_t>(std::vector<std::uint8_t>&));
-};
-
-} // namespace host_tool
diff --git a/test/tools_blob_unittest.cpp b/test/tools_blob_unittest.cpp
deleted file mode 100644
index a51eb25..0000000
--- a/test/tools_blob_unittest.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-#include "blob_handler.hpp"
-#include "crc_mock.hpp"
-#include "ipmi_interface_mock.hpp"
-
-#include <gtest/gtest.h>
-
-namespace host_tool
-{
-CrcInterface* crcIntf = nullptr;
-
-std::uint16_t generateCrc(const std::vector<std::uint8_t>& data)
-{
-    return (crcIntf) ? crcIntf->generateCrc(data) : 0x00;
-}
-
-using ::testing::Eq;
-using ::testing::Return;
-
-class BlobHandlerTest : public ::testing::Test
-{
-  protected:
-    void SetUp() override
-    {
-        crcIntf = &crcMock;
-    }
-
-    CrcMock crcMock;
-};
-
-TEST_F(BlobHandlerTest, getCountIpmiHappy)
-{
-    /* Verify returns the value specified by the IPMI response. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobGetCount};
-
-    /* return 1 blob count. */
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00,
-                                      0x01, 0x00, 0x00, 0x00};
-
-    std::vector<std::uint8_t> bytes = {0x01, 0x00, 0x00, 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(bytes))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-    EXPECT_EQ(1, blob.getBlobCount());
-}
-
-TEST_F(BlobHandlerTest, enumerateBlobIpmiHappy)
-{
-    /* Verify returns the name specified by the IPMI response. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobEnumerate,
-        0x00, 0x00, 0x01, 0x00,
-        0x00, 0x00};
-
-    /* return value. */
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00,
-                                      'a',  'b',  'c',  'd',  0x00};
-
-    std::vector<std::uint8_t> bytes = {'a', 'b', 'c', 'd', 0x00};
-    std::vector<std::uint8_t> reqCrc = {0x01, 0x00, 0x00, 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(bytes))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-    EXPECT_STREQ("abcd", blob.enumerateBlob(1).c_str());
-}
-
-TEST_F(BlobHandlerTest, enumerateBlobIpmiNoBytes)
-{
-    /* Simulate a case where the IPMI command returns no data. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobEnumerate,
-        0x00, 0x00, 0x01, 0x00,
-        0x00, 0x00};
-
-    /* return value. */
-    std::vector<std::uint8_t> resp = {};
-
-    std::vector<std::uint8_t> reqCrc = {0x01, 0x00, 0x00, 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-    EXPECT_STREQ("", blob.enumerateBlob(1).c_str());
-}
-
-TEST_F(BlobHandlerTest, getBlobListIpmiHappy)
-{
-    /* Verify returns the list built via the above two commands. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-
-    std::vector<std::uint8_t> request1 = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobGetCount};
-
-    /* return 1 blob count. */
-    std::vector<std::uint8_t> resp1 = {0xcf, 0xc2, 0x00, 0x00, 0x00,
-                                       0x01, 0x00, 0x00, 0x00};
-
-    std::vector<std::uint8_t> bytes1 = {0x01, 0x00, 0x00, 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(bytes1))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request1))).WillOnce(Return(resp1));
-
-    std::vector<std::uint8_t> request2 = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobEnumerate,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00};
-
-    /* return value. */
-    std::vector<std::uint8_t> resp2 = {0xcf, 0xc2, 0x00, 0x00, 0x00,
-                                       'a',  'b',  'c',  'd',  0x00};
-
-    std::vector<std::uint8_t> reqCrc = {0x00, 0x00, 0x00, 0x00};
-    std::vector<std::uint8_t> bytes2 = {'a', 'b', 'c', 'd', 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(bytes2))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request2))).WillOnce(Return(resp2));
-
-    /* A std::string is not nul-terminated by default. */
-    std::vector<std::string> expectedList = {std::string{"abcd"}};
-
-    EXPECT_EQ(expectedList, blob.getBlobList());
-}
-
-TEST_F(BlobHandlerTest, getStatWithMetadata)
-{
-    /* Stat received metadata. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobStat,
-        0x00, 0x00, 'a',  'b',
-        'c',  'd',  0x00};
-
-    /* return blob_state: 0xffff, size: 0x00, metadata 0x3445 */
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00, 0xff, 0xff,
-                                      0x00, 0x00, 0x00, 0x00, 0x02, 0x34, 0x45};
-
-    std::vector<std::uint8_t> reqCrc = {'a', 'b', 'c', 'd', 0x00};
-    std::vector<std::uint8_t> respCrc = {0xff, 0xff, 0x00, 0x00, 0x00,
-                                         0x00, 0x02, 0x34, 0x45};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(respCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    auto meta = blob.getStat("abcd");
-    EXPECT_EQ(meta.blob_state, 0xffff);
-    EXPECT_EQ(meta.size, 0x00);
-    std::vector<std::uint8_t> metadata = {0x34, 0x45};
-    EXPECT_EQ(metadata, meta.metadata);
-}
-
-TEST_F(BlobHandlerTest, getStatNoMetadata)
-{
-    /* Stat received no metadata. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobStat,
-        0x00, 0x00, 'a',  'b',
-        'c',  'd',  0x00};
-
-    /* return blob_state: 0xffff, size: 0x00, metadata 0x3445 */
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00, 0xff,
-                                      0xff, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-    std::vector<std::uint8_t> reqCrc = {'a', 'b', 'c', 'd', 0x00};
-    std::vector<std::uint8_t> respCrc = {0xff, 0xff, 0x00, 0x00,
-                                         0x00, 0x00, 0x00};
-
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(respCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    auto meta = blob.getStat("abcd");
-    EXPECT_EQ(meta.blob_state, 0xffff);
-    EXPECT_EQ(meta.size, 0x00);
-    std::vector<std::uint8_t> metadata = {};
-    EXPECT_EQ(metadata, meta.metadata);
-}
-
-TEST_F(BlobHandlerTest, openBlobSucceeds)
-{
-    /* The open blob succeeds. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobOpen,
-        0x00, 0x00, 0x02, 0x04,
-        'a',  'b',  'c',  'd',
-        0x00};
-
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00, 0xfe, 0xed};
-
-    std::vector<std::uint8_t> reqCrc = {0x02, 0x04, 'a', 'b', 'c', 'd', 0x00};
-    std::vector<std::uint8_t> respCrc = {0xfe, 0xed};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(respCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    auto session =
-        blob.openBlob("abcd", blobs::FirmwareBlobHandler::UpdateFlags::lpc);
-    EXPECT_EQ(0xedfe, session);
-}
-
-TEST_F(BlobHandlerTest, closeBlobSucceeds)
-{
-    /* The close succeeds. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobClose,
-        0x00, 0x00, 0x01, 0x00};
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00};
-    std::vector<std::uint8_t> reqCrc = {0x01, 0x00};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    blob.closeBlob(0x0001);
-}
-
-TEST_F(BlobHandlerTest, writeBytesSucceeds)
-{
-    /* The write bytes succeeds. */
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobWrite,
-        0x00, 0x00, 0x01, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        'a',  'b',  'c',  'd'};
-
-    std::vector<std::uint8_t> bytes = {'a', 'b', 'c', 'd'};
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00};
-    std::vector<std::uint8_t> reqCrc = {0x01, 0x00, 0x00, 0x00, 0x00,
-                                        0x00, 'a',  'b',  'c',  'd'};
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    blob.writeBytes(0x0001, 0, bytes);
-}
-
-TEST_F(BlobHandlerTest, readBytesSucceeds)
-{
-    /* The reading of bytes succeeds. */
-
-    IpmiInterfaceMock ipmiMock;
-    BlobHandler blob(&ipmiMock);
-
-    std::vector<std::uint8_t> request = {
-        0xcf, 0xc2, 0x00, BlobHandler::BlobOEMCommands::bmcBlobRead,
-        0x00, 0x00, 0x01, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x04, 0x00, 0x00, 0x00};
-
-    std::vector<std::uint8_t> expectedBytes = {'a', 'b', 'c', 'd'};
-    std::vector<std::uint8_t> resp = {0xcf, 0xc2, 0x00, 0x00, 0x00,
-                                      'a',  'b',  'c',  'd'};
-    std::vector<std::uint8_t> reqCrc = {0x01, 0x00, 0x00, 0x00, 0x00,
-                                        0x00, 0x04, 0x00, 0x00, 0x00};
-    std::vector<std::uint8_t> respCrc = {'a', 'b', 'c', 'd'};
-
-    EXPECT_CALL(crcMock, generateCrc(Eq(reqCrc))).WillOnce(Return(0x00));
-    EXPECT_CALL(crcMock, generateCrc(Eq(respCrc))).WillOnce(Return(0x00));
-
-    EXPECT_CALL(ipmiMock, sendPacket(Eq(request))).WillOnce(Return(resp));
-
-    EXPECT_EQ(blob.readBytes(0x0001, 0, 4), expectedBytes);
-}
-
-} // namespace host_tool
diff --git a/test/tools_bt_unittest.cpp b/test/tools_bt_unittest.cpp
index 24511c3..1a364d3 100644
--- a/test/tools_bt_unittest.cpp
+++ b/test/tools_bt_unittest.cpp
@@ -1,8 +1,8 @@
-#include "blob_interface_mock.hpp"
 #include "bt.hpp"
 #include "internal_sys_mock.hpp"
 
 #include <cstring>
+#include <ipmiblob/test/blob_interface_mock.hpp>
 
 #include <gtest/gtest.h>
 
@@ -22,7 +22,7 @@
      * syscall mock and catch the writes via the blob mock.
      */
     internal::InternalSysMock sysMock;
-    BlobInterfaceMock blobMock;
+    ipmiblob::BlobInterfaceMock blobMock;
 
     BtDataHandler handler(&blobMock, &sysMock);
     std::string filePath = "/asdf";
diff --git a/test/tools_ipmi_error_unittest.cpp b/test/tools_ipmi_error_unittest.cpp
deleted file mode 100644
index 86264a1..0000000
--- a/test/tools_ipmi_error_unittest.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "ipmi_errors.hpp"
-
-#include <gtest/gtest.h>
-
-namespace host_tool
-{
-
-TEST(IpmiExceptionTest, VerifyTimedOutIsString)
-{
-    /* Verify that throwing the exception with the cc code for timed out gets
-     * converted to the human readable string.
-     */
-    bool verified = false;
-
-    try
-    {
-        throw IpmiException(0xc3);
-    }
-    catch (const IpmiException& i)
-    {
-        EXPECT_STREQ("Received IPMI_CC: timeout", i.what());
-        verified = true;
-    }
-
-    EXPECT_TRUE(verified);
-}
-
-} // namespace host_tool
diff --git a/test/tools_ipmi_unittest.cpp b/test/tools_ipmi_unittest.cpp
deleted file mode 100644
index d0c9911..0000000
--- a/test/tools_ipmi_unittest.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "internal_sys_mock.hpp"
-#include "ipmi_errors.hpp"
-#include "ipmi_handler.hpp"
-
-namespace host_tool
-{
-
-using ::testing::_;
-using ::testing::Return;
-
-TEST(IpmiHandlerTest, OpenAllFails)
-{
-    /* Open against all device files fail. */
-    internal::InternalSysMock sysMock;
-    IpmiHandler ipmi(&sysMock);
-
-    EXPECT_CALL(sysMock, open(_, _)).WillRepeatedly(Return(-1));
-    EXPECT_THROW(ipmi.open(), IpmiException);
-}
-
-} // namespace host_tool
diff --git a/test/tools_lpc_unittest.cpp b/test/tools_lpc_unittest.cpp
index 3a9d80e..1645ea5 100644
--- a/test/tools_lpc_unittest.cpp
+++ b/test/tools_lpc_unittest.cpp
@@ -1,9 +1,9 @@
-#include "blob_interface_mock.hpp"
 #include "internal_sys_mock.hpp"
 #include "io_mock.hpp"
 #include "lpc.hpp"
 
 #include <cstring>
+#include <ipmiblob/test/blob_interface_mock.hpp>
 
 #include <gtest/gtest.h>
 
@@ -15,7 +15,7 @@
 TEST(LpcHandleTest, verifySendsFileContents)
 {
     internal::InternalSysMock sysMock;
-    BlobInterfaceMock blobMock;
+    ipmiblob::BlobInterfaceMock blobMock;
     HostIoInterfaceMock ioMock;
 
     LpcDataHandler handler(&blobMock, &ioMock, &sysMock);
diff --git a/test/tools_updater_unittest.cpp b/test/tools_updater_unittest.cpp
index 0f49494..158ce47 100644
--- a/test/tools_updater_unittest.cpp
+++ b/test/tools_updater_unittest.cpp
@@ -1,7 +1,8 @@
-#include "blob_interface_mock.hpp"
 #include "data_interface_mock.hpp"
 #include "updater.hpp"
 
+#include <blobs-ipmid/blobs.hpp>
+#include <ipmiblob/test/blob_interface_mock.hpp>
 #include <string>
 
 #include <gtest/gtest.h>
@@ -17,25 +18,28 @@
 {
     /* Call updaterMain and have everything respond happily. */
     DataInterfaceMock handlerMock;
-    BlobInterfaceMock blobMock;
+    ipmiblob::BlobInterfaceMock blobMock;
     std::string firmwareImage = "image.bin";
     std::string signatureFile = "image.sig";
     std::string expectedBlob = "/flash/image";
 
     std::vector<std::string> blobList = {expectedBlob};
-    StatResponse statObj;
+    ipmiblob::StatResponse statObj;
     statObj.blob_state = blobs::FirmwareBlobHandler::UpdateFlags::ipmi |
                          blobs::FirmwareBlobHandler::UpdateFlags::lpc;
     statObj.size = 0;
-    blobs::FirmwareBlobHandler::UpdateFlags supported =
-        blobs::FirmwareBlobHandler::UpdateFlags::lpc;
+    std::uint16_t supported =
+        static_cast<std::uint16_t>(
+            blobs::FirmwareBlobHandler::UpdateFlags::lpc) |
+        static_cast<std::uint16_t>(blobs::OpenFlags::write);
     std::uint16_t session = 0xbeef;
 
     EXPECT_CALL(blobMock, getBlobList()).WillOnce(Return(blobList));
 
     EXPECT_CALL(blobMock, getStat(Eq(expectedBlob))).WillOnce(Return(statObj));
 
-    EXPECT_CALL(handlerMock, supportedType()).WillOnce(Return(supported));
+    EXPECT_CALL(handlerMock, supportedType())
+        .WillOnce(Return(blobs::FirmwareBlobHandler::UpdateFlags::lpc));
 
     EXPECT_CALL(blobMock, openBlob(StrEq(expectedBlob.c_str()), Eq(supported)))
         .WillOnce(Return(session));