diff --git a/test/handler_unittest.cpp b/test/handler_unittest.cpp
index 124a3ff..d96fc41 100644
--- a/test/handler_unittest.cpp
+++ b/test/handler_unittest.cpp
@@ -1,12 +1,106 @@
 #include "handler_unittest.hpp"
 
+using ::testing::_;
+using ::testing::Return;
+using ::testing::StrEq;
+using ::testing::StrNe;
+using namespace std::string_literals;
+using namespace binstore;
+
 namespace blobs
 {
 
+class BinaryStoreBlobHandlerBasicTest : public BinaryStoreBlobHandlerTest
+{
+  protected:
+    static inline std::string basicTestBaseId = "/test/"s;
+    static inline std::string basicTestBlobId = "/test/blob0"s;
+    static inline std::string basicTestInvalidBlobId = "/invalid/blob0"s;
+};
+
+TEST_F(BinaryStoreBlobHandlerBasicTest, CanHandleBlobZeroStoreFail)
+{
+    // Cannot handle since there is no store. Shouldn't crash.
+    EXPECT_FALSE(handler.canHandleBlob(basicTestInvalidBlobId));
+}
+
 TEST_F(BinaryStoreBlobHandlerBasicTest, CanHandleBlobChecksNameInvalid)
 {
+    auto bstore = std::make_unique<MockBinaryStore>();
+
+    handler.addNewBinaryStore(std::move(bstore));
+
     // Verify canHandleBlob checks and returns false on an invalid name.
-    EXPECT_FALSE(bstore.canHandleBlob("asdf"));
+    EXPECT_FALSE(handler.canHandleBlob(basicTestInvalidBlobId));
+}
+
+TEST_F(BinaryStoreBlobHandlerBasicTest, CanHandleBlobCanOpenValidBlob)
+{
+    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));
+    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));
+}
+
+TEST_F(BinaryStoreBlobHandlerBasicTest, CanHandleBlobCanOpenValidBlobMultiple)
+{
+    auto bstore = std::make_unique<MockBinaryStore>();
+    auto bstore1 = std::make_unique<MockBinaryStore>();
+    const std::string anotherBaseId = "/another/"s;
+    const std::string anotherBlobId = "/another/blob/id"s;
+
+    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));
+    handler.addNewBinaryStore(std::move(bstore));
+
+    EXPECT_CALL(*bstore1, getBaseBlobId())
+        .WillRepeatedly(Return(anotherBaseId));
+    EXPECT_CALL(*bstore1, canHandleBlob(StrNe(anotherBlobId)))
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*bstore1, canHandleBlob(StrEq(anotherBlobId)))
+        .WillRepeatedly(Return(true));
+    handler.addNewBinaryStore(std::move(bstore1));
+
+    // Verify canHandleBlob return true for a blob id that it can handle
+    EXPECT_FALSE(handler.canHandleBlob(basicTestInvalidBlobId));
+    EXPECT_TRUE(handler.canHandleBlob(basicTestBlobId));
+    EXPECT_TRUE(handler.canHandleBlob(anotherBlobId));
+}
+
+TEST_F(BinaryStoreBlobHandlerBasicTest, GetBlobIdEqualsConcatenationsOfIds)
+{
+    std::string baseId0 = "/test/"s;
+    std::string baseId1 = "/test1/"s;
+    std::vector<std::string> idList0 = {"/test/"s, "/test/0"s};
+    std::vector<std::string> idList1 = {"/test1/"s, "/test1/2"s};
+    auto expectedIdList = idList0;
+    expectedIdList.insert(expectedIdList.end(), idList1.begin(), idList1.end());
+
+    auto bstore0 = std::make_unique<MockBinaryStore>();
+    EXPECT_CALL(*bstore0, getBaseBlobId()).WillOnce(Return(baseId0));
+    EXPECT_CALL(*bstore0, getBlobIds()).WillOnce(Return(idList0));
+    handler.addNewBinaryStore(std::move(bstore0));
+
+    auto bstore1 = std::make_unique<MockBinaryStore>();
+    EXPECT_CALL(*bstore1, getBaseBlobId()).WillOnce(Return(baseId1));
+    EXPECT_CALL(*bstore1, getBlobIds()).WillOnce(Return(idList1));
+    handler.addNewBinaryStore(std::move(bstore1));
+
+    // Verify canHandleBlob return true for a blob id that it can handle
+    EXPECT_EQ(expectedIdList, handler.getBlobIds());
 }
 
 } // namespace blobs
diff --git a/test/handler_unittest.hpp b/test/handler_unittest.hpp
index fd93de4..f6390fc 100644
--- a/test/handler_unittest.hpp
+++ b/test/handler_unittest.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "binarystore_mock.hpp"
 #include "handler.hpp"
 
 #include <gtest/gtest.h>
@@ -11,12 +12,7 @@
 {
   protected:
     BinaryStoreBlobHandlerTest() = default;
-
-    BinaryStoreBlobHandler bstore;
-};
-
-class BinaryStoreBlobHandlerBasicTest : public BinaryStoreBlobHandlerTest
-{
+    BinaryStoreBlobHandler handler;
 };
 
 } // namespace blobs