diff --git a/.clang-tidy b/.clang-tidy
index 0c9cc0b..bdf15ab 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -96,7 +96,6 @@
 clang-analyzer-apiModeling.google.GTest,
 clang-analyzer-apiModeling.llvm.CastValue,
 clang-analyzer-apiModeling.llvm.ReturnValue,
-clang-analyzer-core.CallAndMessage,
 clang-analyzer-core.CallAndMessageModeling,
 clang-analyzer-core.DivideZero,
 clang-analyzer-core.DynamicTypePropagation,
diff --git a/include/estoraged.hpp b/include/estoraged.hpp
index 3a4fb6c..aa89bee 100644
--- a/include/estoraged.hpp
+++ b/include/estoraged.hpp
@@ -5,6 +5,7 @@
 
 #include <libcryptsetup.h>
 
+#include <sdbusplus/asio/object_server.hpp>
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/exception.hpp>
 #include <sdbusplus/server/object.hpp>
@@ -20,23 +21,19 @@
 
 namespace estoraged
 {
-using driveInherit = sdbusplus::server::object_t<
-    sdbusplus::xyz::openbmc_project::Inventory::Item::server::Drive>;
-using eStoragedInherit = sdbusplus::server::object_t<
-    sdbusplus::xyz::openbmc_project::Inventory::Item::server::Volume>;
 using estoraged::Cryptsetup;
 using estoraged::Filesystem;
+using sdbusplus::xyz::openbmc_project::Inventory::Item::server::Volume;
 
 /** @class eStoraged
  *  @brief eStoraged object to manage a LUKS encrypted storage device.
  */
-class EStoraged : private eStoragedInherit, private driveInherit
+class EStoraged
 {
   public:
     /** @brief Constructor for eStoraged
      *
-     *  @param[in] bus - sdbusplus dbus object
-     *  @param[in] path - DBus object path
+     *  @param[in] server - sdbusplus asio object server
      *  @param[in] devPath - path to device file, e.g. /dev/mmcblk0
      *  @param[in] luksName - name for the LUKS container
      *  @param[in] cryptInterface - (optional) pointer to CryptsetupInterface
@@ -44,52 +41,53 @@
      *  @param[in] fsInterface - (optional) pointer to FilesystemInterface
      *    object
      */
-    EStoraged(sdbusplus::bus::bus& bus, const char* path,
+    EStoraged(sdbusplus::asio::object_server& server,
               const std::string& devPath, const std::string& luksName,
               uint64_t size,
               std::unique_ptr<CryptsetupInterface> cryptInterface =
                   std::make_unique<Cryptsetup>(),
               std::unique_ptr<FilesystemInterface> fsInterface =
-                  std::make_unique<Filesystem>()) :
-        eStoragedInherit(bus, path),
-        driveInherit(bus, path), devPath(devPath), containerName(luksName),
-        mountPoint("/mnt/" + luksName + "_fs"),
-        cryptIface(std::move(cryptInterface)), fsIface(std::move(fsInterface))
-    {
-        capacity(size);
-    }
+                  std::make_unique<Filesystem>());
+
+    /** @brief Destructor for eStoraged. */
+    ~EStoraged();
+
+    EStoraged& operator=(const EStoraged&) = delete;
+    EStoraged(const EStoraged&) = delete;
+    EStoraged(EStoraged&&) = default;
+    EStoraged& operator=(EStoraged&&) = default;
 
     /** @brief Format the LUKS encrypted device and create empty filesystem.
      *
      *  @param[in] password - password to set for the LUKS device.
      *  @param[in] type - filesystem type, e.g. ext4
      */
-    void formatLuks(std::vector<uint8_t> password,
-                    FilesystemType type) override;
+    void formatLuks(const std::vector<uint8_t>& password,
+                    Volume::FilesystemType type);
 
     /** @brief Erase the contents of the storage device.
      *
      *  @param[in] eraseType - type of erase operation.
      */
-    void erase(EraseMethod eraseType) override;
+    void erase(Volume::EraseMethod eraseType);
 
     /** @brief Unmount filesystem and lock the LUKS device.
      */
-    void lock() override;
+    void lock();
 
     /** @brief Unlock device and mount the filesystem.
      *
      *  @param[in] password - password for the LUKS device.
      */
-    void unlock(std::vector<uint8_t> password) override;
+    void unlock(std::vector<uint8_t> password);
 
     /** @brief Change the password for the LUKS device.
      *
      *  @param[in] oldPassword - old password for the LUKS device.
      *  @param[in] newPassword - new password for the LUKS device.
      */
-    void changePassword(std::vector<uint8_t> oldPassword,
-                        std::vector<uint8_t> newPassword) override;
+    void changePassword(const std::vector<uint8_t>& oldPassword,
+                        const std::vector<uint8_t>& newPassword);
 
     /** @brief Check if the LUKS device is currently locked. */
     bool isLocked() const;
@@ -107,6 +105,9 @@
     /** @brief Mount point for the filesystem. */
     std::string mountPoint;
 
+    /** @brief Indicates whether the LUKS device is currently locked. */
+    bool lockedProperty;
+
     /** @brief Pointer to cryptsetup interface object.
      *  @details This is used to mock out the cryptsetup functions.
      */
@@ -117,6 +118,15 @@
      */
     std::unique_ptr<FilesystemInterface> fsIface;
 
+    /** @brief D-Bus object server. */
+    sdbusplus::asio::object_server& objectServer;
+
+    /** @brief D-Bus interface for the logical volume. */
+    std::shared_ptr<sdbusplus::asio::dbus_interface> volumeInterface;
+
+    /** @brief D-Bus interface for the physical drive. */
+    std::shared_ptr<sdbusplus::asio::dbus_interface> driveInterface;
+
     /** @brief Format LUKS encrypted device.
      *
      *  @param[in] cd - initialized crypt_device struct for the device.
@@ -150,6 +160,12 @@
 
     /** @brief Unmount the filesystem. */
     void unmountFilesystem();
+
+    /** @brief Set the locked property.
+     *
+     *  @param[in] isLocked - indicates whether the LUKS device is locked.
+     */
+    void locked(bool isLocked);
 };
 
 } // namespace estoraged
diff --git a/src/estoraged.cpp b/src/estoraged.cpp
index f6176e4..6225f91 100644
--- a/src/estoraged.cpp
+++ b/src/estoraged.cpp
@@ -12,12 +12,15 @@
 #include <openssl/rand.h>
 
 #include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/asio/object_server.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 
 #include <cstdlib>
 #include <filesystem>
 #include <iostream>
+#include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 namespace estoraged
@@ -26,13 +29,72 @@
 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
 using sdbusplus::xyz::openbmc_project::Common::Error::ResourceNotFound;
 using sdbusplus::xyz::openbmc_project::Common::Error::UnsupportedRequest;
+using sdbusplus::xyz::openbmc_project::Inventory::Item::server::Volume;
 
-void EStoraged::formatLuks(std::vector<uint8_t> password, FilesystemType type)
+EStoraged::EStoraged(sdbusplus::asio::object_server& server,
+                     const std::string& devPath, const std::string& luksName,
+                     uint64_t size,
+                     std::unique_ptr<CryptsetupInterface> cryptInterface,
+                     std::unique_ptr<FilesystemInterface> fsInterface) :
+    devPath(devPath),
+    containerName(luksName), mountPoint("/mnt/" + luksName + "_fs"),
+    lockedProperty(false), cryptIface(std::move(cryptInterface)),
+    fsIface(std::move(fsInterface)), objectServer(server)
+{
+    /* Get the filename of the device (without "/dev/"). */
+    std::string deviceName = std::filesystem::path(devPath).filename().string();
+    /* DBus object path */
+    std::string path = "/xyz/openbmc_project/inventory/storage/" + deviceName;
+
+    /* Add Volume interface. */
+    volumeInterface = objectServer.add_interface(
+        path, "xyz.openbmc_project.Inventory.Item.Volume");
+    volumeInterface->register_method(
+        "FormatLuks", [this](const std::vector<uint8_t>& password,
+                             Volume::FilesystemType type) {
+            this->formatLuks(password, type);
+        });
+    volumeInterface->register_method(
+        "Erase",
+        [this](Volume::EraseMethod eraseType) { this->erase(eraseType); });
+    volumeInterface->register_method("Lock", [this]() { this->lock(); });
+    volumeInterface->register_method(
+        "Unlock",
+        [this](std::vector<uint8_t>& password) { this->unlock(password); });
+    volumeInterface->register_method(
+        "ChangePassword", [this](const std::vector<uint8_t>& oldPassword,
+                                 const std::vector<uint8_t>& newPassword) {
+            this->changePassword(oldPassword, newPassword);
+        });
+    volumeInterface->register_property_r(
+        "Locked", lockedProperty, sdbusplus::vtable::property_::emits_change,
+        [this](bool& value) {
+            value = this->isLocked();
+            return value;
+        });
+
+    /* Add Drive interface. */
+    driveInterface = objectServer.add_interface(
+        path, "xyz.openbmc_project.Inventory.Item.Drive");
+    driveInterface->register_property("Capacity", size);
+
+    volumeInterface->initialize();
+    driveInterface->initialize();
+}
+
+EStoraged::~EStoraged()
+{
+    objectServer.remove_interface(volumeInterface);
+    objectServer.remove_interface(driveInterface);
+}
+
+void EStoraged::formatLuks(const std::vector<uint8_t>& password,
+                           Volume::FilesystemType type)
 {
     std::string msg = "OpenBMC.0.1.DriveFormat";
     lg2::info("Starting format", "REDFISH_MESSAGE_ID", msg);
 
-    if (type != FilesystemType::ext4)
+    if (type != Volume::FilesystemType::ext4)
     {
         lg2::error("Only ext4 filesystems are supported currently",
                    "REDFISH_MESSAGE_ID", std::string("OpenBMC.0.1.FormatFail"));
@@ -54,56 +116,56 @@
     mountFilesystem();
 }
 
-void EStoraged::erase(EraseMethod inEraseMethod)
+void EStoraged::erase(Volume::EraseMethod inEraseMethod)
 {
     std::cerr << "Erasing encrypted eMMC" << std::endl;
     lg2::info("Starting erase", "REDFISH_MESSAGE_ID",
               std::string("OpenBMC.0.1.DriveErase"));
     switch (inEraseMethod)
     {
-        case EraseMethod::CryptoErase:
+        case Volume::EraseMethod::CryptoErase:
         {
             CryptErase myCryptErase(devPath);
             myCryptErase.doErase();
             break;
         }
-        case EraseMethod::VerifyGeometry:
+        case Volume::EraseMethod::VerifyGeometry:
         {
             VerifyDriveGeometry myVerifyGeometry(devPath);
             myVerifyGeometry.geometryOkay();
             break;
         }
-        case EraseMethod::LogicalOverWrite:
+        case Volume::EraseMethod::LogicalOverWrite:
         {
             Pattern myErasePattern(devPath);
             myErasePattern.writePattern();
             break;
         }
-        case EraseMethod::LogicalVerify:
+        case Volume::EraseMethod::LogicalVerify:
         {
             Pattern myErasePattern(devPath);
             myErasePattern.verifyPattern();
             break;
         }
-        case EraseMethod::VendorSanitize:
+        case Volume::EraseMethod::VendorSanitize:
         {
             Sanitize mySanitize(devPath);
             mySanitize.doSanitize();
             break;
         }
-        case EraseMethod::ZeroOverWrite:
+        case Volume::EraseMethod::ZeroOverWrite:
         {
             Zero myZero(devPath);
             myZero.writeZero();
             break;
         }
-        case EraseMethod::ZeroVerify:
+        case Volume::EraseMethod::ZeroVerify:
         {
             Zero myZero(devPath);
             myZero.verifyZero();
             break;
         }
-        case EraseMethod::SecuredLocked:
+        case Volume::EraseMethod::SecuredLocked:
         {
             if (isLocked())
             {
@@ -138,12 +200,12 @@
         throw ResourceNotFound();
     }
 
-    activateLuksDev(cryptHandle.get(), password);
+    activateLuksDev(cryptHandle.get(), std::move(password));
     mountFilesystem();
 }
 
-void EStoraged::changePassword(std::vector<uint8_t> /*oldPassword*/,
-                               std::vector<uint8_t> /*newPassword*/)
+void EStoraged::changePassword(const std::vector<uint8_t>& /*oldPassword*/,
+                               const std::vector<uint8_t>& /*newPassword*/)
 {
     std::cerr << "Changing password for encrypted eMMC" << std::endl;
     lg2::info("Starting change password", "REDFISH_MESSAGE_ID",
@@ -152,7 +214,7 @@
 
 bool EStoraged::isLocked() const
 {
-    return locked();
+    return lockedProperty;
 }
 
 std::string_view EStoraged::getMountPoint() const
@@ -353,4 +415,9 @@
               std::string("OpenBMC.0.1.DeactivateLuksDevSuccess"));
 }
 
+void EStoraged::locked(bool isLocked)
+{
+    lockedProperty = isLocked;
+}
+
 } // namespace estoraged
diff --git a/src/main.cpp b/src/main.cpp
index 82ffcdd..aea7904 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,12 +3,16 @@
 
 #include <unistd.h>
 
+#include <boost/asio/io_context.hpp>
 #include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
 #include <sdbusplus/bus.hpp>
 #include <util.hpp>
 
 #include <filesystem>
 #include <iostream>
+#include <memory>
 #include <string>
 
 static void usage(std::string_view name)
@@ -24,7 +28,6 @@
 
 int main(int argc, char** argv)
 {
-
     std::string physicalBlockDev = "/dev/mmcblk0";
     std::string containerBlockDev;
     int opt = 0;
@@ -55,32 +58,22 @@
             containerBlockDev = "luks-" + deviceName;
         }
 
-        /* DBus path location to place the object. */
-        std::string path =
-            "/xyz/openbmc_project/inventory/storage/" + deviceName;
-        /*
-         * Create a new bus and affix an object manager for the subtree path we
-         * intend to place objects at.
-         */
-        auto b = sdbusplus::bus::new_default();
-        sdbusplus::server::manager_t m{b, path.c_str()};
-
-        /* Reserve the dbus service name. */
+        // setup connection to dbus
+        boost::asio::io_context io;
+        auto conn = std::make_shared<sdbusplus::asio::connection>(io);
+        // request D-Bus server name.
         std::string busName = "xyz.openbmc_project.eStoraged." + deviceName;
-        b.request_name(busName.c_str());
+        conn->request_name(busName.c_str());
+        auto server = sdbusplus::asio::object_server(conn);
 
-        /* Create an eStoraged object. */
         estoraged::EStoraged esObject{
-            b, path.c_str(), physicalBlockDev, containerBlockDev,
+            server, physicalBlockDev, containerBlockDev,
             estoraged::util::Util::findSizeOfBlockDevice(physicalBlockDev)};
         lg2::info("Storage management service is running", "REDFISH_MESSAGE_ID",
                   std::string("OpenBMC.1.0.ServiceStarted"));
 
-        while (true)
-        {
-            b.wait();
-            b.process_discard();
-        }
+        io.run();
+        return 0;
     }
     catch (const std::exception& e)
     {
diff --git a/src/meson.build b/src/meson.build
index ed28e88..d12786f 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -1,8 +1,23 @@
 phosphor_dbus_interfaces_dep = dependency('phosphor-dbus-interfaces')
 phosphor_logging_dep = dependency('phosphor-logging')
-sdbusplus_dep = dependency('sdbusplus')
+
+sdbusplus_dep = dependency('sdbusplus', required: false, include_type: 'system')
+if not sdbusplus_dep.found()
+  sdbusplus_proj = subproject('sdbusplus', required: true)
+  sdbusplus = sdbusplus_proj.get_variable('sdbusplus_dep')
+  sdbusplus = sdbusplus.as_system('system')
+endif
+
 stdplus_dep = dependency('stdplus')
 
+boost_dep = dependency('boost',version : '>=1.78.0', required : false, include_type: 'system')
+if not boost_dep.found()
+  subproject('boost', required: false)
+  boost_inc = include_directories('subprojects/boost_1_78_0/', is_system:true)
+  boost  = declare_dependency(include_directories : boost_inc)
+  boost = boost.as_system('system')
+endif
+
 subdir('erase')
 
 libeStoraged_deps = [
@@ -12,6 +27,7 @@
   phosphor_logging_dep,
   sdbusplus_dep,
   stdplus_dep,
+  boost_dep,
 ]
 
 libeStoraged_lib = static_library(
diff --git a/src/test/estoraged_test.cpp b/src/test/estoraged_test.cpp
index e7ad562..05f872f 100644
--- a/src/test/estoraged_test.cpp
+++ b/src/test/estoraged_test.cpp
@@ -4,7 +4,9 @@
 
 #include <unistd.h>
 
-#include <sdbusplus/test/sdbus_mock.hpp>
+#include <boost/asio/io_context.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/Inventory/Item/Volume/client.hpp>
 
@@ -12,6 +14,7 @@
 #include <filesystem>
 #include <fstream>
 #include <iterator>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -27,37 +30,31 @@
 using std::filesystem::path;
 using ::testing::_;
 using ::testing::ContainsRegex;
-using ::testing::IsNull;
 using ::testing::Return;
 using ::testing::StrEq;
 
-/*
- * This sdbus mock object gets used in the destructor of one of the parent
- * classes for the MockeStoraged object, so this can't be part of the
- * eStoragedTest class.
- */
-sdbusplus::SdBusMock sdbusMock;
-
 class EStoragedTest : public testing::Test
 {
   public:
     const char* testFileName = "testfile";
     const char* testLuksDevName = "testfile_luksDev";
-    uint64_t testSize = 24;
+    const uint64_t testSize = 24;
     std::ofstream testFile;
-    std::unique_ptr<estoraged::EStoraged> esObject;
     const char* testPath = "/test/openbmc_project/storage/test_dev";
     const char* estoragedInterface =
         "xyz.openbmc_project.Inventory.Item.Volume";
     const char* driveInterface = "xyz.openbmc_project.Inventory.Item.Drive";
-    sdbusplus::bus::bus bus;
     std::string passwordString;
     std::vector<uint8_t> password;
     MockCryptsetupInterface* mockCryptIface{};
     MockFilesystemInterface* mockFsIface{};
+    boost::asio::io_context io;
+    std::shared_ptr<sdbusplus::asio::connection> conn;
+    std::unique_ptr<sdbusplus::asio::object_server> objectServer;
+    std::unique_ptr<estoraged::EStoraged> esObject;
 
     EStoragedTest() :
-        bus(sdbusplus::get_mocked_new(&sdbusMock)), passwordString("password"),
+        passwordString("password"),
         password(passwordString.begin(), passwordString.end())
     {}
 
@@ -72,24 +69,6 @@
             throw std::runtime_error("Failed to open test file");
         }
 
-        EXPECT_CALL(sdbusMock,
-                    sd_bus_add_object_vtable(IsNull(), _, StrEq(testPath),
-                                             StrEq(estoragedInterface), _, _))
-            .WillRepeatedly(Return(0));
-
-        EXPECT_CALL(sdbusMock,
-                    sd_bus_add_object_vtable(IsNull(), _, StrEq(testPath),
-                                             StrEq(driveInterface), _, _))
-            .WillRepeatedly(Return(0));
-
-        EXPECT_CALL(sdbusMock,
-                    sd_bus_emit_object_added(IsNull(), StrEq(testPath)))
-            .WillRepeatedly(Return(0));
-
-        EXPECT_CALL(sdbusMock,
-                    sd_bus_emit_object_removed(IsNull(), StrEq(testPath)))
-            .WillRepeatedly(Return(0));
-
         std::unique_ptr<MockCryptsetupInterface> cryptIface =
             std::make_unique<MockCryptsetupInterface>();
         mockCryptIface = cryptIface.get();
@@ -97,8 +76,13 @@
             std::make_unique<MockFilesystemInterface>();
         mockFsIface = fsIface.get();
 
+        conn = std::make_shared<sdbusplus::asio::connection>(io);
+        // request D-Bus server name.
+        conn->request_name("xyz.openbmc_project.eStoraged.test");
+        objectServer = std::make_unique<sdbusplus::asio::object_server>(conn);
+
         esObject = std::make_unique<estoraged::EStoraged>(
-            bus, testPath, testFileName, testLuksDevName, testSize,
+            *objectServer, testFileName, testLuksDevName, testSize,
             std::move(cryptIface), std::move(fsIface));
     }
 
@@ -111,16 +95,6 @@
 /* Test case to format and then lock the LUKS device. */
 TEST_F(EStoragedTest, FormatPass)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -166,16 +140,6 @@
  */
 TEST_F(EStoragedTest, MountPointExistsPass)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -245,16 +209,6 @@
 /* Test case where we fail to set the password for the LUKS device. */
 TEST_F(EStoragedTest, AddKeyslotFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -268,16 +222,6 @@
 /* Test case where we fail to load the LUKS header. */
 TEST_F(EStoragedTest, LoadLuksHeaderFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -293,16 +237,6 @@
 /* Test case where we fail to activate the LUKS device. */
 TEST_F(EStoragedTest, ActivateFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -321,16 +255,6 @@
 /* Test case where we fail to create the filesystem. */
 TEST_F(EStoragedTest, CreateFilesystemFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -351,16 +275,6 @@
 /* Test case where we fail to create the mount point. */
 TEST_F(EStoragedTest, CreateMountPointFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -387,16 +301,6 @@
 /* Test case where we fail to mount the filesystem. */
 TEST_F(EStoragedTest, MountFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -431,16 +335,6 @@
 /* Test case where we fail to unmount the filesystem. */
 TEST_F(EStoragedTest, UnmountFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -477,16 +371,6 @@
 /* Test case where we fail to remove the mount point. */
 TEST_F(EStoragedTest, RemoveMountPointFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
@@ -527,16 +411,6 @@
 /* Test case where we fail to deactivate the LUKS device. */
 TEST_F(EStoragedTest, DeactivateFail)
 {
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(IsNull(), StrEq(testPath),
-                                                    StrEq(driveInterface), _))
-        .WillRepeatedly(Return(0));
-
-    EXPECT_CALL(sdbusMock,
-                sd_bus_emit_properties_changed_strv(
-                    IsNull(), StrEq(testPath), StrEq(estoragedInterface), _))
-        .WillRepeatedly(Return(0));
-
     EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
 
     EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
diff --git a/subprojects/boost.wrap b/subprojects/boost.wrap
new file mode 100644
index 0000000..2f7a22f
--- /dev/null
+++ b/subprojects/boost.wrap
@@ -0,0 +1,4 @@
+[wrap-file]
+source_url = https://downloads.yoctoproject.org/mirror/sources/boost_1_78_0.tar.bz2
+source_hash = 8681f175d4bdb26c52222665793eef08490d7758529330f98d3b29dd0735bccc
+source_filename = 1_78_0.tar.bz2