Adding tests

Author: Rui Rocha

BUILD

@@ -21,5 +21,6 @@ test_suite(
     name = "unit_tests",
     tests = [
         "//examples:unit_tests",
+        "//mq:test",
     ],
 )

mq/BUILD

@@ -12,8 +12,12 @@ cc_library(
 cc_test(
     name = "test",
     srcs = glob(["test/*.cpp"]),
+    linkopts = [
+        "-lzmq",
+    ],
     deps = [
         ":mq",
+        "@cppzmq",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

mq/src/IMQSocket.hpp

@@ -20,6 +20,7 @@ class IMQSocket {
 
    public:
     virtual ~IMQSocket() = default;
+    virtual auto connect(const std::string& endpoint) -> bool = 0;
     virtual auto bind(const std::string& endpoint) -> bool = 0;
     virtual auto send(const std::vector<uint8_t>& data) -> bool = 0;
     virtual auto receive() -> std::vector<uint8_t> = 0;

mq/src/ZeroMQSocket.cpp

@@ -10,8 +10,24 @@ void ZeroMQSocket::close() {
 
 auto ZeroMQSocket::bind(const std::string& endpoint) -> bool {
     std::cout << "Binding to " << endpoint << "\n";
-    m_socket.bind(endpoint);
-    return true;
+    try {
+        m_socket.bind(endpoint);
+        return true;
+    } catch (const zmq::error_t& e) {
+        std::cout << "Error binding to " << endpoint << "\n";
+        return false;
+    }
+}
+
+auto ZeroMQSocket::connect(const std::string& endpoint) -> bool {
+    std::cout << "Connecting to " << endpoint << "\n";
+    try {
+        m_socket.connect(endpoint);
+        return true;
+    } catch (const zmq::error_t& e) {
+        std::cout << "Error connecting to " << endpoint << "\n";
+        return false;
+    }
 }
 
 auto ZeroMQSocket::send(const std::vector<uint8_t>& data) -> bool {

mq/src/ZeroMQSocket.hpp

@@ -10,6 +10,7 @@ class ZeroMQSocket : public IMQSocket {
     ZeroMQSocket(zmq::context_t& context, zmq::socket_type type) : m_socket(context, type) {}
     ~ZeroMQSocket() override = default;
 
+    auto connect(const std::string& endpoint) -> bool override;
     auto bind(const std::string& endpoint) -> bool override;
     auto send(const std::vector<uint8_t>& data) -> bool override;
     auto receive() -> std::vector<uint8_t> override;

mq/test/ZeroMQSocketTest.cpp

@@ -0,0 +1,42 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <vector>
+#include <zmq.hpp>
+
+#include "mq/src/ZeroMQSocket.hpp"
+
+TEST(ZeroMQSocketTest, SendAndReceive) {
+    zmq::context_t context(1);
+    MQ::ZeroMQSocket sender(context, zmq::socket_type::push);
+    MQ::ZeroMQSocket receiver(context, zmq::socket_type::pull);
+
+    ASSERT_TRUE(sender.bind("inproc://test_socket"));
+    ASSERT_TRUE(receiver.connect("inproc://test_socket"));
+
+    std::vector<uint8_t> data{1, 2, 3};
+    ASSERT_TRUE(sender.send(data));
+
+    std::vector<uint8_t> received_message = receiver.receive();
+    ASSERT_EQ(data, received_message);
+
+    sender.close();
+    receiver.close();
+}
+
+TEST(ZeroMQSocketTest, ConnectFailure) {
+    zmq::context_t context(1);
+    MQ::ZeroMQSocket socket(context, zmq::socket_type::pub);
+    ASSERT_FALSE(socket.connect("invalid_endpoint"));  // Expect connection failure
+}
+
+TEST(ZeroMQSocketTest, BindFailure) {
+    zmq::context_t context(1);
+    MQ::ZeroMQSocket socket1(context, zmq::socket_type::pub);
+    MQ::ZeroMQSocket socket2(context, zmq::socket_type::pub);  // Bind to the same endpoint
+
+    ASSERT_TRUE(socket1.bind("inproc://test_bind"));
+    ASSERT_FALSE(socket2.bind("inproc://test_bind"));  // Should fail because already bound
+
+    socket1.close();
+}

mq/test/ZeroMQWorkerTest.cpp

@@ -11,6 +11,8 @@ class MockMQSocket : public MQ::IMQSocket {  // Create a Mock Class
     // NOLINTNEXTLINE(modernize-use-trailing-return-type)
     MOCK_METHOD(bool, bind, (const std::string &), (override));
     // NOLINTNEXTLINE(modernize-use-trailing-return-type)
+    MOCK_METHOD(bool, connect, (const std::string &), (override));
+    // NOLINTNEXTLINE(modernize-use-trailing-return-type)
     MOCK_METHOD(bool, send, (const std::vector<uint8_t> &), (override));
     // NOLINTNEXTLINE(modernize-use-trailing-return-type)
     MOCK_METHOD(std::vector<uint8_t>, receive, (), (override));