Mock sdbus lib, add unit tests of Connection class.

Introduce mock of sdbus library through extracting its interface. Set up unit tests of Connection class through injection of sdbusMock to constructor. Clients of Connections class should use fabrics instead.

src/Connection.cpp

@@ -24,6 +24,7 @@
  */
 
 #include "Connection.h"
+#include "SdBus.h"
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
 #include "ScopeGuard.h"
@@ -34,8 +35,9 @@
 
 namespace sdbus { namespace internal {
 
-Connection::Connection(Connection::BusType type)
-    : busType_(type)
+Connection::Connection(Connection::BusType type, std::unique_ptr<ISdBus>&& interface)
+    : busType_(type),
+      iface_(std::move(interface))
 {
     auto bus = openBus(busType_);
     bus_.reset(bus);
@@ -53,13 +55,13 @@ Connection::~Connection()
 
 void Connection::requestName(const std::string& name)
 {
-    auto r = sd_bus_request_name(bus_.get(), name.c_str(), 0);
+    auto r = iface_->sd_bus_request_name(bus_.get(), name.c_str(), 0);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to request bus name", -r);
 }
 
 void Connection::releaseName(const std::string& name)
 {
-    auto r = sd_bus_release_name(bus_.get(), name.c_str());
+    auto r = iface_->sd_bus_release_name(bus_.get(), name.c_str());
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to release bus name", -r);
 }
 
@@ -97,7 +99,7 @@ void* Connection::addObjectVTable( const std::string& objectPath
 {
     sd_bus_slot *slot{};
 
-    auto r = sd_bus_add_object_vtable( bus_.get()
+    auto r = iface_->sd_bus_add_object_vtable( bus_.get()
                                      , &slot
                                      , objectPath.c_str()
                                      , interfaceName.c_str()
@@ -111,7 +113,7 @@ void* Connection::addObjectVTable( const std::string& objectPath
 
 void Connection::removeObjectVTable(void* vtableHandle)
 {
-    sd_bus_slot_unref((sd_bus_slot *)vtableHandle);
+    iface_->sd_bus_slot_unref((sd_bus_slot *)vtableHandle);
 }
 
 sdbus::MethodCall Connection::createMethodCall( const std::string& destination
@@ -122,9 +124,9 @@ sdbus::MethodCall Connection::createMethodCall( const std::string& destination
     sd_bus_message *sdbusMsg{};
 
     // Returned message will become an owner of sdbusMsg
-    SCOPE_EXIT{ sd_bus_message_unref(sdbusMsg); };
+    SCOPE_EXIT{ iface_->sd_bus_message_unref(sdbusMsg); };
 
-    auto r = sd_bus_message_new_method_call( bus_.get()
+    auto r = iface_->sd_bus_message_new_method_call( bus_.get()
                                            , &sdbusMsg
                                            , destination.c_str()
                                            , objectPath.c_str()
@@ -145,7 +147,7 @@ sdbus::Signal Connection::createSignal( const std::string& objectPath
     // Returned message will become an owner of sdbusSignal
     SCOPE_EXIT{ sd_bus_message_unref(sdbusSignal); };
 
-    auto r = sd_bus_message_new_signal( bus_.get()
+    auto r = iface_->sd_bus_message_new_signal( bus_.get()
                                       , &sdbusSignal
                                       , objectPath.c_str()
                                       , interfaceName.c_str()
@@ -165,7 +167,7 @@ void* Connection::registerSignalHandler( const std::string& objectPath
     sd_bus_slot *slot{};
 
     auto filter = composeSignalMatchFilter(objectPath, interfaceName, signalName);
-    auto r = sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
+    auto r = iface_->sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to register signal handler", -r);
 
@@ -174,7 +176,7 @@ void* Connection::registerSignalHandler( const std::string& objectPath
 
 void Connection::unregisterSignalHandler(void* handlerCookie)
 {
-    sd_bus_slot_unref((sd_bus_slot *)handlerCookie);
+    iface_->sd_bus_slot_unref((sd_bus_slot *)handlerCookie);
 }
 
 void Connection::sendReplyAsynchronously(const sdbus::MethodReply& reply)
@@ -186,20 +188,21 @@ void Connection::sendReplyAsynchronously(const sdbus::MethodReply& reply)
 
 std::unique_ptr<sdbus::internal::IConnection> Connection::clone() const
 {
-    return std::make_unique<sdbus::internal::Connection>(busType_);
+    auto interface = std::make_unique<SdBus>(SdBus());
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(busType_, std::move(interface));
 }
 
 sd_bus* Connection::openBus(Connection::BusType type)
 {
-    static std::map<sdbus::internal::Connection::BusType, int(*)(sd_bus **)> busTypeToFactory
-    {
-        {sdbus::internal::Connection::BusType::eSystem, &sd_bus_open_system},
-        {sdbus::internal::Connection::BusType::eSession, &sd_bus_open_user}
-    };
-
     sd_bus* bus{};
-
-    auto r = busTypeToFactory[type](&bus);
+    int r = 0;
+    if (type == BusType::eSystem)
+        r = iface_->sd_bus_open_system(&bus);
+    else if (type == BusType::eSession)
+        r = iface_->sd_bus_open_user(&bus);
+    else
+        assert(false);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to open bus", -r);
     assert(bus != nullptr);
@@ -215,7 +218,7 @@ void Connection::finishHandshake(sd_bus* bus)
 
     assert(bus != nullptr);
 
-    auto r = sd_bus_flush(bus);
+    auto r = iface_->sd_bus_flush(bus);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }
@@ -263,7 +266,7 @@ bool Connection::processPendingRequest()
 
     assert(bus != nullptr);
 
-    int r = sd_bus_process(bus, nullptr);
+    int r = iface_->sd_bus_process(bus, nullptr);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to process bus requests", -r);
 
@@ -288,16 +291,16 @@ Connection::WaitResult Connection::waitForNextRequest()
     assert(bus != nullptr);
     assert(notificationFd_ != 0);
 
-    auto r = sd_bus_get_fd(bus);
+    auto r = iface_->sd_bus_get_fd(bus);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus descriptor", -r);
     auto sdbusFd = r;
 
-    r = sd_bus_get_events(bus);
+    r = iface_->sd_bus_get_events(bus);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus events", -r);
     short int sdbusEvents = r;
 
     uint64_t usec;
-    sd_bus_get_timeout(bus, &usec);
+    iface_->sd_bus_get_timeout(bus, &usec);
 
     struct pollfd fds[] = {{sdbusFd, sdbusEvents, 0}, {notificationFd_, POLLIN, 0}};
     auto fdsCount = sizeof(fds)/sizeof(fds[0]);
@@ -356,7 +359,10 @@ std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
-    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSystem);
+    auto interface = std::make_unique<SdBus>(SdBus());
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSystem,
+                                                         std::move(interface));
 }
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
@@ -368,7 +374,10 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string&
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
-    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSession);
+    auto interface = std::make_unique<SdBus>(SdBus());
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSession,
+                                                         std::move(interface));
 }
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)

src/Connection.h

@@ -29,6 +29,8 @@
 #include <sdbus-c++/IConnection.h>
 #include <sdbus-c++/Message.h>
 #include "IConnection.h"
+#include "ISdBus.h"
+
 #include <systemd/sd-bus.h>
 #include <memory>
 #include <thread>
@@ -49,7 +51,7 @@ namespace sdbus { namespace internal {
             eSession
         };
 
-        Connection(BusType type);
+        Connection(BusType type, std::unique_ptr<ISdBus>&& interface);
         ~Connection();
 
         void requestName(const std::string& name) override;
@@ -93,8 +95,8 @@ namespace sdbus { namespace internal {
                 return msgsToProcess || asyncMsgsToProcess;
             }
         };
-        static sd_bus* openBus(Connection::BusType type);
-        static void finishHandshake(sd_bus* bus);
+        sd_bus* openBus(Connection::BusType type);
+        void finishHandshake(sd_bus* bus);
         static int createLoopNotificationDescriptor();
         static void closeLoopNotificationDescriptor(int fd);
         bool processPendingRequest();
@@ -108,7 +110,11 @@ namespace sdbus { namespace internal {
         void joinWithProcessingLoop();
 
     private:
-        std::unique_ptr<sd_bus, decltype(&sd_bus_flush_close_unref)> bus_{nullptr, &sd_bus_flush_close_unref};
+        std::unique_ptr<ISdBus> iface_;
+        std::unique_ptr<sd_bus, std::function<sd_bus*(sd_bus*)>> bus_ {nullptr, [this](sd_bus* bus)
+                                                                                {
+                                                                                    return iface_->sd_bus_flush_close_unref(bus);
+                                                                                }};
         std::thread asyncLoopThread_;
         std::mutex mutex_;
         std::queue<MethodReply> asyncReplies_;

src/ISdBus.h

@@ -0,0 +1,55 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ISdBus.h
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 12, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_ISDBUS_H
+#define SDBUS_CXX_ISDBUS_H
+
+#include <systemd/sd-bus.h>
+
+class ISdBus
+{
+public:
+    virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) = 0;
+    virtual int sd_bus_release_name(sd_bus *bus, const char *name) = 0;
+    virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) = 0;
+    virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;
+    virtual int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member) = 0;
+    virtual sd_bus_message* sd_bus_message_unref(sd_bus_message *m) = 0;
+    virtual int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member) = 0;
+    virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) = 0;
+    virtual int sd_bus_open_user(sd_bus **ret) = 0;
+    virtual int sd_bus_open_system(sd_bus **ret) = 0;
+    virtual int sd_bus_flush(sd_bus *bus) = 0;
+    virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
+    virtual int sd_bus_get_fd(sd_bus *bus) = 0;
+    virtual int sd_bus_get_events(sd_bus *bus) = 0;
+    virtual int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) = 0;
+    virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
+
+    virtual ~ISdBus() = default;
+};
+
+#endif //SDBUS_CXX_ISDBUS_H

src/SdBus.cpp

@@ -0,0 +1,107 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file SdBus.cpp
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 3, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SdBus.h"
+
+int SdBus::sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
+{
+    return ::sd_bus_request_name(bus, name, flags);
+}
+
+int SdBus::sd_bus_release_name(sd_bus *bus, const char *name)
+{
+    return ::sd_bus_release_name(bus, name);
+}
+
+int SdBus::sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata)
+{
+    return ::sd_bus_add_object_vtable(bus, slot, path, interface,  vtable, userdata);
+}
+
+sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
+{
+    return ::sd_bus_slot_unref(slot);
+}
+
+int SdBus::sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member)
+{
+    return ::sd_bus_message_new_method_call(bus, m, destination, path, interface, member);
+}
+
+sd_bus_message* SdBus::sd_bus_message_unref(sd_bus_message *m)
+{
+    return ::sd_bus_message_unref(m);
+}
+
+int SdBus::sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member)
+{
+    return ::sd_bus_message_new_signal(bus, m, path, interface, member);
+}
+
+int SdBus::sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata)
+{
+    return :: sd_bus_add_match(bus, slot, match, callback, userdata);
+}
+
+int SdBus::sd_bus_open_user(sd_bus **ret)
+{
+    return ::sd_bus_open_user(ret);
+}
+
+int SdBus::sd_bus_open_system(sd_bus **ret)
+{
+    return ::sd_bus_open_system(ret);
+}
+
+int SdBus::sd_bus_flush(sd_bus *bus)
+{
+    return ::sd_bus_flush(bus);
+}
+
+int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
+{
+    return ::sd_bus_process(bus, r);
+}
+
+int SdBus::sd_bus_get_fd(sd_bus *bus)
+{
+    return ::sd_bus_get_fd(bus);
+}
+
+int SdBus::sd_bus_get_events(sd_bus *bus)
+{
+    return ::sd_bus_get_events(bus);
+}
+
+int SdBus::sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec)
+{
+    return ::sd_bus_get_timeout(bus, timeout_usec);
+}
+
+sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
+{
+    return ::sd_bus_flush_close_unref(bus);
+}

src/SdBus.h

@@ -0,0 +1,53 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file SdBus.h
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 3, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_SDBUS_H
+#define SDBUS_CXX_SDBUS_H
+
+#include "ISdBus.h"
+
+class SdBus : public ISdBus
+{
+public:
+    int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) override;
+    int sd_bus_release_name(sd_bus *bus, const char *name) override;
+    int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) override;
+    sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;
+    int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member) override;
+    sd_bus_message* sd_bus_message_unref(sd_bus_message *m) override;
+    int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member) override;
+    int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;
+    int sd_bus_open_user(sd_bus **ret) override;
+    int sd_bus_open_system(sd_bus **ret) override;
+    int sd_bus_flush(sd_bus *bus) override;
+    int sd_bus_process(sd_bus *bus, sd_bus_message **r) override;
+    int sd_bus_get_fd(sd_bus *bus) override;
+    int sd_bus_get_events(sd_bus *bus) override;
+    int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) override;
+    sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;
+};
+
+#endif //SDBUS_C_SDBUS_H