diff --git a/test/Makefile.am b/test/Makefile.am
index 5b3fe6c..5ce51f2 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -11,6 +11,7 @@
 # Run all 'check' test programs
 check_PROGRAMS = \
 	handler_open_unittest \
+	handler_readwrite_unittest \
 	handler_unittest
 TESTS = $(check_PROGRAMS)
 
@@ -23,3 +24,8 @@
 handler_open_unittest_LDADD = $(PHOSPHOR_LOGGING_LIBS) \
 	$(top_builddir)/handler.o
 handler_open_unittest_CXXFLAGS = $(PHOSPHOR_LOGGING_CFLAGS)
+
+handler_readwrite_unittest_SOURCES = handler_readwrite_unittest.cpp
+handler_readwrite_unittest_LDADD = $(PHOSPHOR_LOGGING_LIBS) \
+	$(top_builddir)/handler.o
+handler_readwrite_unittest_CXXFLAGS = $(PHOSPHOR_LOGGING_CFLAGS)
diff --git a/test/handler_open_unittest.cpp b/test/handler_open_unittest.cpp
index 1d69f24..83053ad 100644
--- a/test/handler_open_unittest.cpp
+++ b/test/handler_open_unittest.cpp
@@ -50,4 +50,68 @@
     EXPECT_TRUE(handler.open(sessionId, flags, testBlobId));
 }
 
+TEST_F(BinaryStoreBlobHandlerOpenTest, CloseFailForInvalidSession)
+{
+    uint16_t invalidSessionId = 1;
+    EXPECT_FALSE(handler.close(invalidSessionId));
+}
+
+TEST_F(BinaryStoreBlobHandlerOpenTest, CloseFailWhenStoreCloseFails)
+{
+    auto testBaseId = "/test/"s;
+    auto testBlobId = "/test/blob0"s;
+    uint16_t flags = OpenFlags::read, sessionId = 0;
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    EXPECT_CALL(*bstore, getBaseBlobId()).WillRepeatedly(Return(testBaseId));
+    EXPECT_CALL(*bstore, canHandleBlob(StartsWith(testBaseId)))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*bstore, openOrCreateBlob(_, flags)).WillOnce(Return(true));
+    EXPECT_CALL(*bstore, close()).WillOnce(Return(false));
+
+    handler.addNewBinaryStore(std::move(bstore));
+
+    EXPECT_TRUE(handler.open(sessionId, flags, testBlobId));
+    EXPECT_FALSE(handler.close(sessionId));
+}
+
+TEST_F(BinaryStoreBlobHandlerOpenTest, CloseSucceedWhenStoreCloseSucceeds)
+{
+    auto testBaseId = "/test/"s;
+    auto testBlobId = "/test/blob0"s;
+    uint16_t flags = OpenFlags::read, sessionId = 0;
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    EXPECT_CALL(*bstore, getBaseBlobId()).WillRepeatedly(Return(testBaseId));
+    EXPECT_CALL(*bstore, canHandleBlob(StartsWith(testBaseId)))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*bstore, openOrCreateBlob(_, flags)).WillOnce(Return(true));
+    EXPECT_CALL(*bstore, close()).WillOnce(Return(true));
+
+    handler.addNewBinaryStore(std::move(bstore));
+
+    EXPECT_TRUE(handler.open(sessionId, flags, testBlobId));
+    EXPECT_TRUE(handler.close(sessionId));
+}
+
+TEST_F(BinaryStoreBlobHandlerOpenTest, ClosedSessionCannotBeReclosed)
+{
+    auto testBaseId = "/test/"s;
+    auto testBlobId = "/test/blob0"s;
+    uint16_t flags = OpenFlags::read, sessionId = 0;
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    EXPECT_CALL(*bstore, getBaseBlobId()).WillRepeatedly(Return(testBaseId));
+    EXPECT_CALL(*bstore, canHandleBlob(StartsWith(testBaseId)))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*bstore, openOrCreateBlob(_, flags)).WillOnce(Return(true));
+    EXPECT_CALL(*bstore, close()).WillRepeatedly(Return(true));
+
+    handler.addNewBinaryStore(std::move(bstore));
+
+    EXPECT_TRUE(handler.open(sessionId, flags, testBlobId));
+    EXPECT_TRUE(handler.close(sessionId));
+    EXPECT_FALSE(handler.close(sessionId));
+}
+
 } // namespace blobs
diff --git a/test/handler_readwrite_unittest.cpp b/test/handler_readwrite_unittest.cpp
new file mode 100644
index 0000000..b335596
--- /dev/null
+++ b/test/handler_readwrite_unittest.cpp
@@ -0,0 +1,54 @@
+#include "handler_unittest.hpp"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::StartsWith;
+
+using namespace std::string_literals;
+using namespace binstore;
+
+namespace blobs
+{
+
+class BinaryStoreBlobHandlerReadWriteTest : public BinaryStoreBlobHandlerTest
+{
+  protected:
+    static inline std::string rwTestBaseId = "/test/"s;
+    static inline std::string rwTestBlobId = "/test/blob0"s;
+    static inline std::vector<uint8_t> rwTestData = {0, 1, 2, 3, 4,
+                                                     5, 6, 7, 8, 9};
+    static inline uint16_t rwTestSessionId = 0;
+    static inline uint32_t rwTestOffset = 0;
+};
+
+TEST_F(BinaryStoreBlobHandlerReadWriteTest, ReadWriteReturnsWhatStoreReturns)
+{
+    auto testBaseId = "/test/"s;
+    auto testBlobId = "/test/blob0"s;
+    uint16_t flags = OpenFlags::read;
+    const std::vector<uint8_t> emptyData;
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    EXPECT_CALL(*bstore, getBaseBlobId()).WillRepeatedly(Return(testBaseId));
+    EXPECT_CALL(*bstore, canHandleBlob(StartsWith(testBaseId)))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*bstore, openOrCreateBlob(_, flags)).WillOnce(Return(true));
+    EXPECT_CALL(*bstore, read(rwTestOffset, _))
+        .WillOnce(Return(emptyData))
+        .WillOnce(Return(rwTestData));
+
+    EXPECT_CALL(*bstore, write(rwTestOffset, emptyData))
+        .WillOnce(Return(false));
+    EXPECT_CALL(*bstore, write(rwTestOffset, rwTestData))
+        .WillOnce(Return(true));
+
+    handler.addNewBinaryStore(std::move(bstore));
+
+    EXPECT_TRUE(handler.open(rwTestSessionId, flags, testBlobId));
+    EXPECT_EQ(emptyData, handler.read(rwTestSessionId, rwTestOffset, 1));
+    EXPECT_EQ(rwTestData, handler.read(rwTestSessionId, rwTestOffset, 1));
+    EXPECT_FALSE(handler.write(rwTestSessionId, rwTestOffset, emptyData));
+    EXPECT_TRUE(handler.write(rwTestSessionId, rwTestOffset, rwTestData));
+}
+
+} // namespace blobs
diff --git a/test/handler_unittest.cpp b/test/handler_unittest.cpp
index d96fc41..d51818e 100644
--- a/test/handler_unittest.cpp
+++ b/test/handler_unittest.cpp
@@ -103,4 +103,27 @@
     EXPECT_EQ(expectedIdList, handler.getBlobIds());
 }
 
+TEST_F(BinaryStoreBlobHandlerBasicTest, DeleteReturnsWhatStoreReturns)
+{
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    EXPECT_CALL(*bstore, getBaseBlobId())
+        .WillRepeatedly(Return(basicTestBaseId));
+    EXPECT_CALL(*bstore, canHandleBlob(StrNe(basicTestBlobId)))
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*bstore, canHandleBlob(StrEq(basicTestBlobId)))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*bstore, deleteBlob(StrEq(basicTestBlobId)))
+        .WillOnce(Return(false))
+        .WillOnce(Return(true));
+    handler.addNewBinaryStore(std::move(bstore));
+
+    // Verify canHandleBlob return true for a blob id that it can handle
+    EXPECT_FALSE(handler.canHandleBlob(basicTestInvalidBlobId));
+    EXPECT_TRUE(handler.canHandleBlob(basicTestBlobId));
+    EXPECT_FALSE(handler.deleteBlob(basicTestInvalidBlobId));
+    EXPECT_FALSE(handler.deleteBlob(basicTestBlobId));
+    EXPECT_TRUE(handler.deleteBlob(basicTestBlobId));
+}
+
 } // namespace blobs