diff --git a/test/Makefile.am b/test/Makefile.am
index 742e7e2..2e07b58 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -19,7 +19,8 @@
 	handler_stat_unittest \
 	handler_open_unittest \
 	handler_readwrite_unittest \
-	handler_unittest
+	handler_unittest \
+	binarystore_unittest
 TESTS = $(check_PROGRAMS)
 
 parse_config_unittest_SOURCES = parse_config_unittest.cpp
@@ -71,3 +72,10 @@
 	$(top_builddir)/libbinarystore_la-binaryblob.pb.o \
 	-lprotobuf
 handler_readwrite_unittest_CXXFLAGS = $(PHOSPHOR_LOGGING_CFLAGS)
+
+binarystore_unittest_SOURCES = binarystore_unittest.cpp
+binarystore_unittest_LDADD = $(PHOSPHOR_LOGGING_LIBS) \
+	$(top_builddir)/binarystore.o \
+	$(top_builddir)/libbinarystore_la-binaryblob.pb.o \
+	-lprotobuf
+binarystore_unittest_CXXFLAGS = $(PHOSPHOR_LOGGING_CFLAGS)
diff --git a/test/binarystore_unittest.cpp b/test/binarystore_unittest.cpp
new file mode 100644
index 0000000..f0e8048
--- /dev/null
+++ b/test/binarystore_unittest.cpp
@@ -0,0 +1,169 @@
+#include "binarystore.hpp"
+#include "binarystore_interface.hpp"
+#include "sys_file.hpp"
+
+#include <google/protobuf/text_format.h>
+
+#include <iostream>
+#include <ipmid/handler.hpp>
+#include <iterator>
+#include <memory>
+#include <sstream>
+
+#include <gmock/gmock.h>
+
+const std::string blobData = "jW7jiID}kD&gm&Azi:^]JT]'Ov4"
+                             "Y.Oey]mw}yak9Wf3[S`+$!g]@[0}gikis^";
+const std::string inputProto = "blob_base_id: \"/blob/my-test\""
+                               "blobs: [{ "
+                               "    blob_id: \"/blob/my-test/0\""
+                               "    data:\"" +
+                               blobData +
+                               "\""
+                               "}, { "
+                               "    blob_id: \"/blob/my-test/1\""
+                               "    data:\"" +
+                               blobData +
+                               "\""
+                               "}, { "
+                               "    blob_id: \"/blob/my-test/2\""
+                               "    data:\"" +
+                               blobData +
+                               "\""
+                               "}, {"
+                               "    blob_id: \"/blob/my-test/3\""
+                               "    data:\"" +
+                               blobData +
+                               "\""
+                               "}] "
+                               "max_size_bytes: 64";
+
+class SysFileBuf : public binstore::SysFile
+{
+  public:
+    SysFileBuf(std::string* storage) : data_{storage}
+    {
+    }
+
+    size_t readToBuf(size_t pos, size_t count, char* buf) const override
+    {
+        std::cout << "Read " << count << " bytes at " << pos << std::endl;
+        return data_->copy(buf, count, pos);
+    }
+
+    std::string readAsStr(size_t pos, size_t count) const override
+    {
+        std::cout << "Read as str " << count << " bytes at " << pos
+                  << std::endl;
+        return data_->substr(pos, count);
+    }
+
+    std::string readRemainingAsStr(size_t pos) const override
+    {
+        return data_->substr(pos);
+    }
+
+    void writeStr(const std::string& data, size_t pos) override
+    {
+        data_->replace(pos, data.size(), data);
+    }
+
+    std::string* data_;
+};
+
+using binstore::binaryblobproto::BinaryBlobBase;
+using google::protobuf::TextFormat;
+
+using testing::ElementsAreArray;
+using testing::UnorderedElementsAre;
+
+class BinaryStoreTest : public testing::Test
+{
+  public:
+    std::unique_ptr<SysFileBuf> createBlobStorage(const std::string& textProto)
+    {
+        BinaryBlobBase storeProto;
+        TextFormat::ParseFromString(textProto, &storeProto);
+
+        std::stringstream storage;
+        std::string data;
+        storeProto.SerializeToString(&data);
+
+        const uint64_t dataSize = data.size();
+        storage.write(reinterpret_cast<const char*>(&dataSize),
+                      sizeof(dataSize));
+        storage << data;
+
+        blobDataStorage = storage.str();
+        return std::make_unique<SysFileBuf>(&blobDataStorage);
+    }
+
+    std::string blobDataStorage;
+};
+
+TEST_F(BinaryStoreTest, SimpleLoad)
+{
+    auto testDataFile = createBlobStorage(inputProto);
+    auto initialData = blobDataStorage;
+    auto store = binstore::BinaryStore::createFromConfig(
+        "/blob/my-test", std::move(testDataFile));
+    EXPECT_THAT(store->getBlobIds(),
+                UnorderedElementsAre("/blob/my-test", "/blob/my-test/0",
+                                     "/blob/my-test/1", "/blob/my-test/2",
+                                     "/blob/my-test/3"));
+    EXPECT_EQ(initialData, blobDataStorage);
+}
+
+TEST_F(BinaryStoreTest, TestCreateFromFile)
+{
+    auto testDataFile = createBlobStorage(inputProto);
+    auto initialData = blobDataStorage;
+    auto store =
+        binstore::BinaryStore::createFromFile(std::move(testDataFile), true);
+    ASSERT_TRUE(store);
+    EXPECT_EQ("/blob/my-test", store->getBaseBlobId());
+    EXPECT_THAT(store->getBlobIds(),
+                UnorderedElementsAre("/blob/my-test", "/blob/my-test/0",
+                                     "/blob/my-test/1", "/blob/my-test/2",
+                                     "/blob/my-test/3"));
+    // Check that the storage has not changed
+    EXPECT_EQ(initialData, blobDataStorage);
+}
+
+TEST_F(BinaryStoreTest, TestReadBlob)
+{
+    auto testDataFile = createBlobStorage(inputProto);
+    auto store =
+        binstore::BinaryStore::createFromFile(std::move(testDataFile), true);
+    ASSERT_TRUE(store);
+
+    const auto blobStoredData = store->readBlob("/blob/my-test/1");
+    EXPECT_FALSE(blobStoredData.empty());
+
+    decltype(blobStoredData) origData(blobData.begin(), blobData.end());
+
+    EXPECT_THAT(blobStoredData, ElementsAreArray(origData));
+}
+
+TEST_F(BinaryStoreTest, TestReadBlobError)
+{
+    auto testDataFile = createBlobStorage(inputProto);
+    auto store =
+        binstore::BinaryStore::createFromFile(std::move(testDataFile), true);
+    ASSERT_TRUE(store);
+
+    EXPECT_THROW(store->readBlob("/nonexistent/1"), ipmi::HandlerCompletion);
+}
+
+TEST_F(BinaryStoreTest, TestOpenReadOnlyBlob)
+{
+    auto testDataFile = createBlobStorage(inputProto);
+    auto store =
+        binstore::BinaryStore::createFromFile(std::move(testDataFile), true);
+    ASSERT_TRUE(store);
+
+    EXPECT_TRUE(
+        store->openOrCreateBlob("/blob/my-test/2", blobs::OpenFlags::read));
+    EXPECT_FALSE(store->openOrCreateBlob(
+        "/blob/my-test/2", blobs::OpenFlags::read & blobs::OpenFlags::write));
+}