feat: additional test and logcollector arch separation

src/modules/logcollector/include/logcollector.hpp

@@ -48,7 +48,7 @@ class Logcollector {
     /// @param log Message to send
     /// @param collectorType type of logcollector
     /// @pre The message queue must be set with SetMessageQueue
-    void SendMessage(const std::string& location, const std::string& log, const std::string& collectorType);
+    virtual void SendMessage(const std::string& location, const std::string& log, const std::string& collectorType);
 
     /// @brief Enqueues an ASIO task (coroutine)
     /// @param task Task to enqueue
@@ -71,6 +71,11 @@ class Logcollector {
         return s_instance;
     }
 
+    /// @brief Add platform specific implementation of IReader to logcollector.
+    /// @param ConfgurationParser where to get parameters.
+    /// @param logcollector instance.
+    void AddPlatformSpecificReader(std::shared_ptr<const configuration::ConfigurationParser> configurationParser);
+
 protected:
     /// @brief Constructor
     Logcollector() { }
@@ -111,9 +116,4 @@ class Logcollector {
     std::list<boost::asio::steady_timer*> m_timers;
 };
 
-/// @brief Add platform specific implementation of IReader to logcollector.
-/// @param ConfgurationParser where to get parameters.
-/// @param logcollector instance.
-void AddPlatformSpecificReader(std::shared_ptr<const configuration::ConfigurationParser> configurationParser, Logcollector &logcollector);
-
 }

src/modules/logcollector/src/event_reader_win.cpp

@@ -9,21 +9,6 @@
 namespace logcollector
 {
 
-void AddPlatformSpecificReader(std::shared_ptr<const configuration::ConfigurationParser> configurationParser, Logcollector &logcollector)
-{
-    const auto refreshInterval = configurationParser->GetConfig<time_t>("logcollector", "channel_refresh").value_or(config::logcollector::CHANNEL_REFRESH_INTERVAL);
-
-    const auto windowsConfig = configurationParser->GetConfig<std::vector<std::map<std::string, std::string>>>("logcollector", "windows").value_or(
-        std::vector<std::map<std::string, std::string>> {});
-
-    for (auto& entry : windowsConfig)
-    {
-        const auto channel = entry.at("channel");
-        const auto query = entry.at("query");
-        logcollector.AddReader(std::make_shared<WindowsEventTracerReader>(logcollector, channel, query, refreshInterval));
-    }
-}
-
 WindowsEventTracerReader::WindowsEventTracerReader(Logcollector &logcollector,
                            const std::string channel,
                            const std::string query,

src/modules/logcollector/src/logcollector.cpp

@@ -73,7 +73,7 @@ void Logcollector::Setup(std::shared_ptr<const configuration::ConfigurationParse
 
     SetupFileReader(configurationParser);
 
-    AddPlatformSpecificReader(configurationParser, *this);
+    AddPlatformSpecificReader(configurationParser);
 }
 
 void Logcollector::SetupFileReader(const std::shared_ptr<const configuration::ConfigurationParser> configurationParser)

src/modules/logcollector/src/logcollector_unix.cpp

@@ -0,0 +1,17 @@
+#include <config.h>
+#include <timeHelper.h>
+
+#include <chrono>
+#include <map>
+
+#include <logcollector.hpp>
+
+namespace logcollector
+{
+
+void Logcollector::AddPlatformSpecificReader([[maybe_unused]] std::shared_ptr<const configuration::ConfigurationParser> configurationParser)
+{
+
+}
+
+}

src/modules/logcollector/src/logcollector_win.cpp

@@ -0,0 +1,29 @@
+#include "event_reader_win.hpp"
+
+#include <config.h>
+#include <timeHelper.h>
+
+#include <chrono>
+#include <map>
+
+#include <logcollector.hpp>
+
+namespace logcollector
+{
+
+void Logcollector::AddPlatformSpecificReader(std::shared_ptr<const configuration::ConfigurationParser> configurationParser)
+{
+    const auto refreshInterval = configurationParser->GetConfig<time_t>("logcollector", "channel_refresh").value_or(config::logcollector::CHANNEL_REFRESH_INTERVAL);
+
+    const auto windowsConfig = configurationParser->GetConfig<std::vector<std::map<std::string, std::string>>>("logcollector", "windows").value_or(
+        std::vector<std::map<std::string, std::string>> {});
+
+    for (auto& entry : windowsConfig)
+    {
+        const auto channel = entry.at("channel");
+        const auto query = entry.at("query");
+        AddReader(std::make_shared<WindowsEventTracerReader>(*this, channel, query, refreshInterval));
+    }
+}
+
+}

src/modules/logcollector/tests/unit/event_reader_mocks.hpp

@@ -38,3 +38,26 @@ class MockWinAPIWrapper : public IWinAPIWrapper
 
 };
 
+//Has some duplicated methods from logcollector_mock
+class LogcollectorMock : public Logcollector {
+public:
+    LogcollectorMock() {
+        ON_CALL(*this, AddReader(::testing::_))
+            .WillByDefault(::testing::Invoke([this](std::shared_ptr<IReader> reader) {
+                this->Logcollector::AddReader(reader);
+            })
+        );
+    }
+
+    MOCK_METHOD(void, AddReader, (std::shared_ptr<IReader> reader), (override));
+    MOCK_METHOD(void, EnqueueTask, (Awaitable task), (override));
+    MOCK_METHOD(void, SendMessage, (const std::string& channel, const std::string& message, int collectorType), ());
+    boost::asio::awaitable<void> Wait([[maybe_unused]]std::chrono::milliseconds ms)
+    {
+        return Logcollector::Wait(ms);
+    }
+    void Stop()
+    {
+        Logcollector::Stop();
+    }
+};

src/modules/logcollector/tests/unit/event_reader_win_test.cpp

@@ -4,7 +4,6 @@
 #include <event_reader_win.hpp>
 #include <logcollector.hpp>
 #include "event_reader_mocks.hpp"
-#include "logcollector_mock.hpp"
 
 #include <sstream>
 #include <spdlog/spdlog.h>
@@ -62,7 +61,7 @@ TEST_F(WindowsEventChannel, AddReader)
         .WillOnce(SaveArg<0>(&capturedReader1))
         .WillOnce(SaveArg<0>(&capturedReader2));
 
-    AddPlatformSpecificReader(config, mockedLogcollector);
+    mockedLogcollector.AddPlatformSpecificReader(config);
 
     ASSERT_NE(capturedReader1, nullptr);
     ASSERT_NE(capturedReader2, nullptr);
@@ -119,20 +118,16 @@ TEST_F(WindowsEventChannel, RunMethodSuccessfulSubscription)
     EXPECT_NO_THROW(ioContext.run());
 }
 
-TEST_F(WindowsEventChannel, ProcessEvent_SendsMessage)
+TEST_F(WindowsEventChannel, ProcessEventSendsMessage)
 {
-    //TODO:
-    GTEST_SKIP();
-    // Arrange: Create mocks
     auto mockedWinAPI = std::make_shared<MockWinAPIWrapper>();
     auto mockedLogcollector = LogcollectorMock();
 
     auto reader = std::make_shared<WindowsEventTracerReader>(
         mockedLogcollector, channelName, query, defaultChannelRefresh, mockedWinAPI);
 
-    // Mock EvtRender to return a fake event XML string
     std::wstring fakeEventXml = L"<Event><Message>Test Log</Message></Event>";
-    DWORD fakeBufferUsed = static_cast<DWORD>((fakeEventXml.size() + 1) * sizeof(wchar_t)); // Include null terminator
+    DWORD fakeBufferUsed = static_cast<DWORD>((fakeEventXml.size() + 1) * sizeof(wchar_t));
 
     EXPECT_CALL(*mockedWinAPI, EvtRender(_, _, EvtRenderEventXml, 0, nullptr, _, _))
         .WillOnce(DoAll(SetArgPointee<5>(fakeBufferUsed), Return(TRUE)));
@@ -143,11 +138,9 @@ TEST_F(WindowsEventChannel, ProcessEvent_SendsMessage)
                       }),
                       Return(TRUE)));
 
-    // Expect the SendMessage method to be called with the processed log
-    // EXPECT_CALL(*mockedLogcollector, SendMessage(channelName, "Test Log", _))
-    //     .Times(1);
+    EXPECT_CALL(mockedLogcollector, SendMessage(channelName, "<Event><Message>Test Log</Message></Event>", collectorType))
+        .Times(1);
 
-    // Act: Simulate an event
     EVT_HANDLE mockEventHandle = reinterpret_cast<EVT_HANDLE>(2);
     reader->ProcessEvent(mockEventHandle);
 }

src/modules/logcollector/tests/unit/logcollector_mock.hpp

@@ -22,16 +22,6 @@ class LogcollectorMock : public Logcollector {
     }
     MOCK_METHOD(void, AddReader, (std::shared_ptr<IReader> reader), (override));
     MOCK_METHOD(void, EnqueueTask, (Awaitable task), (override));
-    // TODO:
-    // MOCK_METHOD(void, SendMessage, (const std::string& channel, const std::string& message, int collectorType), ());
-    boost::asio::awaitable<void> Wait([[maybe_unused]]std::chrono::milliseconds ms)
-    {
-        return Logcollector::Wait(ms);
-    }
-    void Stop()
-    {
-        Logcollector::Stop();
-    }
 };
 
 class PushMessageMock {