Refactor Spf

src/Spf.cpp

@@ -4,11 +4,11 @@
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License
+ * the Free Software Foundation; version 2 of the License.
  *
  * This program 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along
@@ -17,83 +17,90 @@
  *
  * @author Juan José Gutiérrez de Quevedo <juanjo@gutierrezdequevedo.com>
  */
+
 #include "Spf.h"
+#include <stdexcept>    
+#include <string>
+#include <mutex>
 
-SPF_server_t *Spf::spfserver=NULL;
+SPF_server_t *Spf::spfserver = nullptr;
 
 /**
- * constructor
- *
- * it will create a spfserver if this is the first created object of the class.
- * if it isn't, then we just create an spfrequest
+ * Constructor
+ * 
+ * Initializes the SPF server if this is the first created object of the class.
  */
-Spf::Spf():spfrequest(NULL),spfresponse(NULL)
-{
-  pthread_mutex_init(&mutex,NULL);
-  if(NULL==spfserver)
-    if(NULL==(spfserver=SPF_server_new(SPF_DNS_CACHE,0)))
-      throw Exception(_("Can't initialize SPF library"),__FILE__,__LINE__);
-
-  if(NULL==(spfrequest=SPF_request_new(spfserver)))
-    throw Exception(_("Can't initialize SPF request"),__FILE__,__LINE__);
+Spf::Spf() {
+    static std::once_flag initFlag; // To ensure thread-safe initialization
+    std::call_once(initFlag, []() {
+        spfserver = SPF_server_new(SPF_DNS_CACHE, 0);
+        if (!spfserver) {
+            throw std::runtime_error("Can't initialize SPF library");
+        }
+    });
 }
 
 /**
- * destructor
- *
- * frees the memory of the spfrequest
+ * Destructor
+ * 
+ * Frees the memory of the SPF server.
  */
-Spf::~Spf()
-{
-  pthread_mutex_destroy(&mutex);
-  if(NULL!=spfrequest) SPF_request_free(spfrequest);
+Spf::~Spf() {
+    deinitialize(); // Clean up resources
 }
 
 /**
- * frees all memory related to the spf class
+ * Frees all memory related to the SPF class.
  *
- * this is needed because the common things are only initialized
- * once (and are static), and when we close the program we need
- * to deinitialize them
+ * This is needed because common resources are only initialized once (and are static).
  */
-void Spf::deinitialize()
-{
-  if(NULL!=spfserver)
-    SPF_server_free(spfserver);
+void Spf::deinitialize() {
+    if (spfserver) {
+        SPF_server_free(spfserver);
+        spfserver = nullptr; // Optional: Avoid dangling pointer
+    }
 }
 
 /**
- * make a query to the dns system for an spf record
+ * Makes a query to the DNS system for an SPF record.
  *
- * highly inspired from fakehermes' source
+ * @param ip    The IP of the remote server
+ * @param helo  The HELO string of the remote server
+ * @param from  The envelope from address
  *
- * @param ip    the ip of the remote server
- * @param helo  the hello string of the remote server
- * @param from  the envelope from address
- *
- * @returns true if it is not incorrect
+ * @returns true if the query is not incorrect
  */
-bool Spf::query(string ip,string helo,string from)
-{
-  bool retval=false;
+bool Spf::query(const std::string& ip, const std::string& helo, const std::string& from) {
+    SPF_request_t* spfrequest = SPF_request_new(spfserver); // Create request here
+    if (!spfrequest) {
+        throw std::runtime_error("Can't initialize SPF request");
+    }
 
-  if(SPF_request_set_ipv4_str(spfrequest,ip.c_str()))
-    throw Exception(_("Error configuring IP for SPF request"),__FILE__,__LINE__);
-  if(SPF_request_set_helo_dom(spfrequest,helo.c_str()))
-    throw Exception(_("Error configuring HELO for SPF request"),__FILE__,__LINE__);
-  if(SPF_request_set_env_from(spfrequest,from.c_str()))
-    throw Exception(_("Error configuring FROM for SPF request"),__FILE__,__LINE__);
+    // Set the values for the SPF request
+    if (SPF_request_set_ipv4_str(spfrequest, ip.c_str())) {
+        SPF_request_free(spfrequest); // Clean up on failure
+        throw std::runtime_error("Error configuring IP for SPF request");
+    }
+    if (SPF_request_set_helo_dom(spfrequest, helo.c_str())) {
+        SPF_request_free(spfrequest); // Clean up on failure
+        throw std::runtime_error("Error configuring HELO for SPF request");
+    }
+    if (SPF_request_set_env_from(spfrequest, from.c_str())) {
+        SPF_request_free(spfrequest); // Clean up on failure
+        throw std::runtime_error("Error configuring FROM for SPF request");
+    }
 
-  //make the actual query
-  pthread_mutex_lock(&mutex);
-  SPF_request_query_mailfrom(spfrequest,&spfresponse);
-  pthread_mutex_unlock(&mutex);
+    // Make the actual query
+    SPF_response_t* spfresponse = nullptr; // Local response variable
+    SPF_request_query_mailfrom(spfrequest, &spfresponse);
 
-  if(NULL!=spfresponse)
-  {
-    retval=(SPF_RESULT_FAIL==SPF_response_result(spfresponse)||SPF_RESULT_SOFTFAIL==SPF_response_result(spfresponse))?false:true;
-    SPF_response_free(spfresponse);
-  }
+    bool retval = false;
+    if (spfresponse) {
+        retval = !(SPF_response_result(spfresponse) == SPF_RESULT_FAIL ||
+                    SPF_response_result(spfresponse) == SPF_RESULT_SOFTFAIL);
+        SPF_response_free(spfresponse); // Free the response
+    }
 
-  return retval;
+    SPF_request_free(spfrequest); // Free the request
+    return retval;
 }

src/Spf.h

@@ -38,7 +38,7 @@ class Spf
     Spf();
     ~Spf();
     static void deinitialize();
-    bool query(string,string,string);
+    bool query(const string&, const string&, const string&);
 };
 
 #endif //SPF_H

src/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

src/test/tests/proxy_test.cpp

@@ -1,7 +1,7 @@
 // ProxyTest.cpp
 #include <gtest/gtest.h>
 #include "Proxy.h"
-#include "MockSocket.h"
+#include "socket_mock.h"
 
 class ProxyTest : public ::testing::Test {
 protected:
@@ -60,4 +60,4 @@ TEST_F(ProxyTest, HandlesEmptyLine) {
 int main(int argc, char** argv) {
     ::testing::InitGoogleMock(&argc, argv);
     return RUN_ALL_TESTS();
-}
+}

src/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();
+}