Rearrange stuff

test/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.31)
+
+project(unittests)
+
+find_package(GTest REQUIRED)
+include_directories(${GTEST_INCLUDE_DIRS})
+
+add_executable(spf_test tests/spf_test.cpp ../src/Spf.cpp)   # Your test file
+target_include_directories(spf_test PRIVATE ../include mocks)
+target_link_libraries(spf_test ${GTEST_LIBRARIES} pthread)
+
+add_executable(proxy_test tests/proxy_test.cpp ../src/Proxy.cpp)   # Your test file
+target_include_directories(proxy_test PRIVATE ../include mocks)
+target_link_libraries(proxy_test ${GTEST_LIBRARIES} pthread)

test/mocks/libspf2_mock.h

@@ -0,0 +1,96 @@
+#ifndef LIBSPF2_MOCK_H
+#define LIBSPF2_MOCK_H
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <spf2/spf.h>
+
+// Control variables to adjust behavior of mocked functions
+extern "C" {
+    static SPF_errcode_t spf_set_ipv4_result = SPF_E_SUCCESS;
+    static SPF_errcode_t spf_set_helo_result = SPF_E_SUCCESS;
+    static int spf_set_from_result;
+    static SPF_response_t* spf_mock_response = nullptr;
+    static SPF_errcode_t spf_request_query_result = SPF_E_SUCCESS;
+    
+    // New control variables for SPF_server mocking
+    static SPF_server_t* spf_mock_server = nullptr;
+    static bool spf_server_new_should_fail = false;
+
+    SPF_server_t* SPF_server_new(SPF_server_dnstype_t dnstype,int debug)
+    {
+        if (spf_server_new_should_fail) {
+            return nullptr;
+        }
+        return spf_mock_server ? spf_mock_server : new SPF_server_t();
+    }
+
+    void SPF_server_free(SPF_server_t* server) {
+        delete server;
+    }
+
+    SPF_request_t* SPF_request_new(SPF_server_t *server) {
+        return new SPF_request_t(); // Simply allocate and return new request
+    }
+
+    void SPF_request_free(SPF_request_t* request) {
+        delete request; // Deallocate request
+    }
+
+    SPF_errcode_t SPF_request_set_ipv4_str(SPF_request_t* request, const char* ip) {
+        return spf_set_ipv4_result; // Use controllable result
+    }
+
+    SPF_errcode_t SPF_request_set_helo_dom(SPF_request_t* request, const char* helo) {
+        return spf_set_helo_result; // Use controllable result
+    }
+
+    int SPF_request_set_env_from(SPF_request_t* request, const char* from) {
+        return spf_set_from_result; // Use controllable result
+    }
+
+    SPF_errcode_t SPF_request_query_mailfrom(SPF_request_t* request, SPF_response_t** response) {
+        *response = spf_mock_response;
+        return spf_request_query_result;
+    }
+
+    SPF_result_t SPF_response_result(SPF_response_t* response) {
+        return response->result; // Return the result
+    }
+
+    void SPF_response_free(SPF_response_t* response) {
+        delete response; // Deallocate response
+    }
+}
+
+// Functions to set return values for mocked functions
+void SetSpfMockReturnIPv4Value(SPF_errcode_t value) {
+    spf_set_ipv4_result = value;
+}
+
+void SetSpfMockReturnHeloValue(SPF_errcode_t value) {
+    spf_set_helo_result = value;
+}
+
+void SetSpfMockReturnFromValue(int value) {
+    spf_set_from_result = value;
+}
+
+void SetSpfRequestQueryResult(SPF_errcode_t value) {
+    spf_request_query_result = value;
+}
+
+void SetSpfMockResponse(SPF_response_t* mockResponse) {
+    spf_mock_response = mockResponse;
+}
+
+// New functions for SPF_server mocking
+void SetSpfMockServer(SPF_server_t* mockServer) {
+    spf_mock_server = mockServer;
+}
+
+void SetSpfServerNewShouldFail(bool shouldFail) {
+    spf_server_new_should_fail = shouldFail;
+}
+
+#endif // LIBSPF2_MOCK_H

test/mocks/socket_mock.h

@@ -0,0 +1,15 @@
+// MockSocket.h
+#include "SocketInterface.h"
+#include <gmock/gmock.h>
+
+class MockSocket : public SocketInterface {
+public:
+    MOCK_METHOD(void, connect, (const std::string& host, unsigned short port), (override));
+    MOCK_METHOD(void, writeLine, (const std::string& data), (override));
+    MOCK_METHOD(std::string, readLine, (), (override));
+    MOCK_METHOD(bool, canRead, (double timeout), (override));
+    MOCK_METHOD(bool, isClosed, (), (override));
+    MOCK_METHOD(void, close, (), (override));
+    MOCK_METHOD(void, prepareSSL, (bool incoming), (override));
+    MOCK_METHOD(void, startSSL, (bool incoming), (override));
+};

test/tests/proxy_test.cpp

@@ -0,0 +1,63 @@
+// ProxyTest.cpp
+#include <gtest/gtest.h>
+#include "Proxy.h"
+#include "socket_mock.h"
+
+class ProxyTest : public ::testing::Test {
+protected:
+    MockSocket mock_socket;
+    Proxy* proxy;
+
+    void SetUp() override {
+        proxy = new Proxy(&mock_socket);
+    }
+
+    void TearDown() override {
+        delete proxy;
+    }
+};
+
+TEST_F(ProxyTest, HandlesMailFromCommand) {
+    std::string peer_address = "127.0.0.1";
+
+    EXPECT_CALL(mock_socket, connect("server-host", 25));
+    EXPECT_CALL(mock_socket, canRead(0.2)).WillOnce(testing::Return(true));
+    EXPECT_CALL(mock_socket, readLine()).WillOnce(testing::Return("MAIL FROM:<test@example.com>"));
+    EXPECT_CALL(mock_socket, writeLine("MAIL FROM:<test@example.com>"));
+    EXPECT_CALL(mock_socket, writeLine("250 OK"));
+
+    proxy->run(peer_address);
+}
+
+TEST_F(ProxyTest, HandlesRcptToCommand) {
+    std::string peer_address = "127.0.0.1";
+
+    EXPECT_CALL(mock_socket, connect("server-host", 25));
+    EXPECT_CALL(mock_socket, canRead(0.2)).WillRepeatedly(testing::Return(true));
+    EXPECT_CALL(mock_socket, readLine())
+        .WillOnce(testing::Return("MAIL FROM:<test@example.com>"))
+        .WillOnce(testing::Return("RCPT TO:<receiver@example.com>"))
+        .WillOnce(testing::Return(""));
+
+    EXPECT_CALL(mock_socket, writeLine("MAIL FROM:<test@example.com>"));
+    EXPECT_CALL(mock_socket, writeLine("RCPT TO:<receiver@example.com>"));
+    EXPECT_CALL(mock_socket, writeLine("250 OK"));
+
+    proxy->run(peer_address);
+}
+
+TEST_F(ProxyTest, HandlesEmptyLine) {
+    std::string peer_address = "127.0.0.1";
+
+    EXPECT_CALL(mock_socket, connect("server-host", 25));
+    EXPECT_CALL(mock_socket, canRead(0.2)).WillOnce(testing::Return(true));
+    EXPECT_CALL(mock_socket, readLine()).WillOnce(testing::Return(""));
+
+    proxy->run(peer_address);
+    // Expect no further actions to occur
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleMock(&argc, argv);
+    return RUN_ALL_TESTS();
+}

test/tests/spf_test.cpp

@@ -0,0 +1,98 @@
+#include <gtest/gtest.h>
+#include "Spf.h"
+
+#include "libspf2_mock.h"
+
+// Mock the SPF server responses for unit testing
+class MockSPFServer {
+public:
+    static void initialize() {
+        // Initialize any mock data here
+    }
+    
+    static void cleanup() {
+        // Cleanup if needed
+    }
+
+    static SPF_response_t* mockResponse(SPF_result_t result) {
+        SPF_response_t* response = new SPF_response_t; // Replace with actual allocation
+        response->result = result; // Set the desired mock result
+        return response;
+    }
+};
+
+// Test Fixture for SPF tests
+class SpfTest : public ::testing::Test {
+protected:
+    Spf* spf;
+
+    void SetUp() override {
+        // Create a new Spf instance before each test
+        spf = new Spf();
+    }
+
+    void TearDown() override {
+        // Clean up after each test
+        delete spf;
+        spf->deinitialize();
+    }
+};
+
+// Test the construction of the Spf object
+TEST_F(SpfTest, Construction) {
+    EXPECT_NO_THROW({
+        Spf testSpf;
+    });
+}
+
+// Test SPF querying with valid parameters
+TEST_F(SpfTest, QueryValidParameters) {
+    // Assuming the mocked SPF server is set up to return a valid response
+    MockSPFServer::initialize();
+    
+    bool result = spf->query("192.0.2.1", "mail.example.com", "test@example.com");
+    EXPECT_TRUE(result);
+
+    MockSPFServer::cleanup();
+}
+
+// Test SPF querying with failed result
+TEST_F(SpfTest, QueryFailResult) {
+    // Mock the response to return a fail result here
+    SPF_response_t* response = MockSPFServer::mockResponse(SPF_RESULT_FAIL);
+    
+    bool result = spf->query("198.51.100.1", "fail.example.com", "test@fail.com");
+    EXPECT_FALSE(result);
+
+    delete response; // Clean up mocked response
+}
+
+// Test SPF querying with an empty HELO string
+TEST_F(SpfTest, QueryEmptyHelo) {
+    EXPECT_THROW({
+        spf->query("192.0.2.1", "", "test@example.com");
+    }, std::runtime_error);
+}
+
+// Test SPF querying with invalid IP format
+TEST_F(SpfTest, QueryInvalidIPAddress) {
+    EXPECT_THROW({
+        spf->query("invalid_ip", "mail.example.com", "test@example.com");
+    }, std::runtime_error);
+}
+
+// Test SPF request failure
+TEST_F(SpfTest, QueryRequestFailure) {
+    // Here you might want to simulate a situation 
+    // where the request cannot be created or fails due to some other reason.
+    spf->deinitialize(); // Ensure the server is cleaned up before running this.
+    
+    EXPECT_THROW({
+        spf->query("192.0.2.1", "mail.example.com", "test@example.com");
+    }, std::runtime_error);
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}