Fix logger tests

Author: stefanDeveloper

heidpi-logger/CMakeLists.txt

@@ -23,7 +23,7 @@ FetchContent_MakeAvailable(json)
 FetchContent_Declare(
         json-schema-validator
         GIT_REPOSITORY https://github.com/pboettch/json-schema-validator.git
-        GIT_TAG main
+        GIT_TAG 2.3.0
 )
 FetchContent_MakeAvailable(json-schema-validator)
 
@@ -39,9 +39,16 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(maxminddb)
 
+FetchContent_Declare(
+  googletest
+  GIT_REPOSITORY https://github.com/google/googletest.git
+  GIT_TAG        v1.17.0
+)
+FetchContent_MakeAvailable(googletest)
+
 file(GLOB SOURCES src/*.cpp)
 add_executable(heidpi_cpp ${SOURCES})
-target_include_directories(heidpi_cpp PRIVATE include)
+target_include_directories(heidpi_cpp PRIVATE ${PROJECT_SOURCE_DIR}/include)
 target_link_libraries(heidpi_cpp PRIVATE
         yaml-cpp
         nlohmann_json::nlohmann_json
@@ -54,3 +61,9 @@ include(GNUInstallDirs)
 install(TARGETS heidpi_cpp
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
+
+option(BUILD_TESTING "Build the tests" ON)
+if(BUILD_TESTING)
+    enable_testing()
+    add_subdirectory(test)
+endif()

heidpi-logger/include/Logger.hpp

@@ -13,6 +13,7 @@ class Logger
     static void init(const LoggingConfig &cfg);
     static void info(const std::string &msg);
     static void error(const std::string &msg);
+    static void destroy();
     ~Logger();
 
 private:

heidpi-logger/src/Logger.cpp

@@ -1,3 +1,11 @@
+/**
+ * @file Logger.cpp
+ * @brief Implements thread-safe logging functionality with console and file output.
+ *
+ * This file provides the implementation for the Logger class, which supports logging
+ * messages with timestamps to both the console and an optional file. It ensures thread
+ * safety using a mutex and flushes critical error logs immediately to disk.
+ */
 #include "Logger.hpp"
 #include <iostream>
 #include <chrono>
@@ -8,15 +16,6 @@
 std::mutex Logger::mtx;
 std::ofstream Logger::file;
 
-/**
- * @file Logger.cpp
- * @brief Implements thread-safe logging functionality with console and file output.
- *
- * This file provides the implementation for the Logger class, which supports logging
- * messages with timestamps to both the console and an optional file. It ensures thread
- * safety using a mutex and flushes critical error logs immediately to disk.
- */
-
 /**
  * @namespace Logger
  * @brief Namespace for logging-related functionality.
@@ -49,6 +48,7 @@ static std::string timestamp()
  */
 void Logger::init(const LoggingConfig &cfg)
 {
+    std::lock_guard<std::mutex> lock(mtx);
     if (!cfg.filename.empty())
     {
         file.open(cfg.filename, std::ios::app); // Append mode
@@ -99,13 +99,28 @@ void Logger::error(const std::string &msg)
     }
 }
 
+/**
+ * @brief Closes the log file when the Logger object is destroyed.
+ *
+ * Ensures the log file is properly closed to release system resources.
+ */
+void Logger::destroy() {
+    std::lock_guard<std::mutex> lock(mtx);
+    if (file.is_open()) {
+        file.close();
+    }
+    file.clear();  // reset flags
+}
+
+
 /**
  * @brief Closes the log file when the Logger object is destroyed.
  *
  * Ensures the log file is properly closed to release system resources.
  */
 Logger::~Logger()
 {
+    std::lock_guard<std::mutex> lock(mtx);
     if (file.is_open())
     {
         file.close();

heidpi-logger/test/LoggerTest.cpp

@@ -0,0 +1,128 @@
+#include "Logger.hpp"
+#include <gtest/gtest.h>
+#include <fstream>
+#include <sstream>
+#include <cstdio>     // For remove()
+#include <thread>
+#include <regex>
+
+// Helper to read file contents
+std::string readFile(const std::string& filename) {
+    std::ifstream in(filename);
+    std::stringstream buffer;
+    buffer << in.rdbuf();
+    return buffer.str();
+}
+
+// Captures std::cout and std::cerr output
+class OutputCapture {
+public:
+    void startCapture() {
+        oldCout = std::cout.rdbuf(coutStream.rdbuf());
+        oldCerr = std::cerr.rdbuf(cerrStream.rdbuf());
+    }
+
+    void stopCapture() {
+        std::cout.rdbuf(oldCout);
+        std::cerr.rdbuf(oldCerr);
+    }
+
+    std::string getCapturedStdout() const {
+        return coutStream.str();
+    }
+
+    std::string getCapturedStderr() const {
+        return cerrStream.str();
+    }
+
+private:
+    std::ostringstream coutStream;
+    std::ostringstream cerrStream;
+    std::streambuf* oldCout = nullptr;
+    std::streambuf* oldCerr = nullptr;
+};
+
+TEST(LoggerTest, LogsToFileAndConsole) {
+    std::string testFile = "test_log.txt";
+    std::remove(testFile.c_str());  // Ensure clean start
+
+    LoggingConfig cfg;
+    cfg.filename = testFile;
+    Logger::init(cfg);
+
+    OutputCapture capture;
+    capture.startCapture();
+
+    Logger::info("This is an info message.");
+    Logger::error("This is an error message.");
+
+    capture.stopCapture();
+
+    std::string fileContent = readFile(testFile);
+    std::string stdoutContent = capture.getCapturedStdout();
+    std::string stderrContent = capture.getCapturedStderr();
+
+    std::regex infoPattern(R"(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} INFO: This is an info message\.\n)");
+    std::regex errorPattern(R"(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} ERROR: This is an error message\.\n)");
+
+    // Console output checks
+    EXPECT_TRUE(std::regex_match(stdoutContent, infoPattern));
+    EXPECT_TRUE(std::regex_match(stderrContent, errorPattern));
+
+    // File output checks
+    EXPECT_NE(fileContent.find("INFO: This is an info message."), std::string::npos);
+    EXPECT_NE(fileContent.find("ERROR: This is an error message."), std::string::npos);
+
+    std::remove(testFile.c_str());  // Cleanup
+    Logger::destroy();
+}
+
+TEST(LoggerTest, LogsWithoutFile) {
+    LoggingConfig cfg;
+    cfg.filename = ""; // No file
+    Logger::init(cfg);
+
+    OutputCapture capture;
+    capture.startCapture();
+
+    Logger::info("Console only info");
+    Logger::error("Console only error");
+
+    capture.stopCapture();
+
+    EXPECT_NE(capture.getCapturedStdout().find("INFO: Console only info"), std::string::npos);
+    EXPECT_NE(capture.getCapturedStderr().find("ERROR: Console only error"), std::string::npos);
+
+    Logger::destroy();
+}
+
+TEST(LoggerTest, ThreadSafeLogging) {
+    std::string testFile = "threaded_log.txt";
+    std::remove(testFile.c_str());
+
+    LoggingConfig cfg;
+    cfg.filename = testFile;
+    Logger::init(cfg);
+
+    auto logTask = [](int threadId) {
+        for (int i = 0; i < 10; ++i) {
+            Logger::info("Thread " + std::to_string(threadId) + " message " + std::to_string(i));
+        }
+    };
+
+    std::thread t1(logTask, 1);
+    std::thread t2(logTask, 2);
+
+    t1.join();
+    t2.join();
+
+    std::string content = readFile(testFile);
+
+    for (int i = 0; i < 10; ++i) {
+        EXPECT_NE(content.find("Thread 1 message " + std::to_string(i)), std::string::npos);
+        EXPECT_NE(content.find("Thread 2 message " + std::to_string(i)), std::string::npos);
+    }
+
+    std::remove(testFile.c_str());
+    Logger::destroy();
+}