Refactor classes to singletons

.gitignore

@@ -158,3 +158,5 @@ libs/
 
 .vscode/
 **/.DS_Store
+
+vcpkg_installed

Tests/Session/Session_test.cpp

@@ -72,22 +72,25 @@ TEST_F(SessionTest, ClearOutputBuffer) {
 TEST_F(SessionTest, AddRemoveStateMachine) {
     // Setup
     auto state_machine = std::make_shared<Echo>();
-    Logger logger(&std::cout, Logger::FATAL);
+    Logger* logger = Logger::initialize(&std::cout, Logger::FATAL);
 
     // Test to make sure the session doesn't have any state machines
     EXPECT_EQ(session_uut.get_state_machines().size(), 0);
 
     // Add the state machine
-    session_uut.add_state_machine(&logger, state_machine);
+    session_uut.add_state_machine(logger, state_machine);
 
     // Test to make sure the session has the state machine
     EXPECT_EQ(session_uut.get_state_machines().size(), 1);
 
     // Remove the state machine
-    session_uut.remove_state_machine(&logger, state_machine);
+    session_uut.remove_state_machine(logger, state_machine);
 
     // Test to make sure the session doesn't have any state machines
     EXPECT_EQ(session_uut.get_state_machines().size(), 0);
+
+    // Tear down logger
+    Logger::destroy();
 }
 
 TEST_F(SessionTest, GetSetKeyValue) {
@@ -123,14 +126,14 @@ TEST_F(SessionTest, RemoveKeyValue) {
 
 
 TEST_F(SessionTest, GetSetView) {
-    Logger logger(&std::cout, Logger::FATAL);
+    Logger *logger = Logger::initialize(&std::cout, Logger::FATAL);
     auto view = std::make_shared<EchoView>();
 
     // Test to make sure the session doesn't have a view
     EXPECT_EQ(session_uut.get_view(), nullptr);
 
     // Set the view
-    session_uut.set_view(&logger, view);
+    session_uut.set_view(logger, view);
 
     // Test to make sure the session has the view
     EXPECT_EQ(session_uut.get_view(), view);

Tests/Session/Sessions_test.cpp

@@ -6,19 +6,24 @@
 #include "../../Session/Sessions.h"
 #include <memory>
 
-class MockLogger : public Logger {
-public:
-    MockLogger(std::ostream* output_stream, LogLevel level) : Logger(output_stream, level) {}
-    MOCK_METHOD(void, log, (LogLevel level, std::string message), (override));
-};
-
 class SessionsTest : public ::testing::Test {
 protected:
-    SessionsTest() : configuration("test_config.json"), logger(&std::cout, Logger::FATAL), sessions(&configuration, &logger) {}
+    SessionsTest() : logger(Logger::initialize(&std::cout, Logger::INFO)), configuration(Configuration::initialize("test_config.json")), sessions(configuration, logger) {}
 
-    Configuration configuration;
-    Logger logger;
+    Logger* logger;
+    Configuration* configuration;
     Sessions sessions;
+
+public:
+
+    void TearDown() override {
+        testing::Mock::VerifyAndClearExpectations(logger);
+    }
+
+    static void TearDownTestSuite() {
+        Logger::destroy();
+    }
+
 };
 
 TEST_F(SessionsTest, AddSession) {
@@ -113,22 +118,36 @@ TEST_F(SessionsTest, RemoveNonExistentSession) {
     EXPECT_EQ(sessions.getSessions(0, 1)[0], session);
 }
 
+
 TEST_F(SessionsTest, Destructor) {
-    // Expect the logger to be called with the correct message
-    MockLogger logger_tmp(&std::cout, Logger::INFO);
-    EXPECT_CALL(logger_tmp, log(Logger::INFO, "Destroying Sessions object")).Times(1);
+    std::vector<std::weak_ptr<Session>> weak_refs;
+    {
+        Sessions *tmp_sessions = new Sessions(configuration, logger);
+
+        // Store weak references to track Session lifetime
+        auto session1 = std::make_shared<Session>(0);
+        auto session2 = std::make_shared<Session>(0);
+        auto session3 = std::make_shared<Session>(0);
 
-    Sessions *tmp_sessions = new Sessions(&configuration, &logger_tmp);
+        weak_refs.push_back(session1);
+        weak_refs.push_back(session2);
+        weak_refs.push_back(session3);
 
-    tmp_sessions->addSession(std::make_shared<Session>(0));
-    tmp_sessions->addSession(std::make_shared<Session>(0));
-    tmp_sessions->addSession(std::make_shared<Session>(0));
+        tmp_sessions->addSession(session1);
+        tmp_sessions->addSession(session2);
+        tmp_sessions->addSession(session3);
 
-    delete tmp_sessions;
+        delete tmp_sessions;
+    }
+
+    // Verify all sessions were destroyed
+    for (const auto& weak_ref : weak_refs) {
+        EXPECT_TRUE(weak_ref.expired()) << "Session was not properly destroyed";
+    }
 }
 
 TEST_F(SessionsTest, AddSessionFull) {
-    for (uint32_t i = 0; i < configuration.max_players; i++) {
+    for (uint32_t i = 0; i < configuration->max_players; i++) {
         sessions.addSession(std::make_shared<Session>(i));
     }
 

Tests/Utils/Configuration/Configuration_test.cpp

@@ -1,32 +1,40 @@
 #include "gtest/gtest.h"
 #include "../../../Utils/Configuration/Configuration.h"
 
+#include "../../../Utils/Logger/Logger.h"
+
 class ConfigurationTest : public ::testing::Test {
 protected:
-    ConfigurationTest() : configuration("test_config.json") {}
-    Configuration configuration;
+    ConfigurationTest() : logger(Logger::initialize(&std::cout, Logger::ERROR)), configuration(Configuration::initialize("test_config.json")) {}
+    Logger* logger;
+    Configuration* configuration;
+
+    static void TearDownTestSuite() {
+        Configuration::destroy();
+        Logger::destroy();
+    }
 };
 
 TEST_F(ConfigurationTest, ThreadSettings) {
-    EXPECT_EQ(configuration.connection_establishment_handler_thread_count, 43432);
-    EXPECT_EQ(configuration.player_session_socket_handler_thread_count, 5452);
-    EXPECT_EQ(configuration.game_loop_thread_count, 3425);
+    EXPECT_EQ(configuration->connection_establishment_handler_thread_count, 43432);
+    EXPECT_EQ(configuration->player_session_socket_handler_thread_count, 5452);
+    EXPECT_EQ(configuration->game_loop_thread_count, 3425);
 }
 
 TEST_F(ConfigurationTest, NetworkingSettings) {
-    EXPECT_EQ(configuration.game_port, 11111);
-    EXPECT_EQ(configuration.connection_queue_size, 5);
-    EXPECT_EQ(configuration.socket_buffer_size, 1000);
+    EXPECT_EQ(configuration->game_port, 11111);
+    EXPECT_EQ(configuration->connection_queue_size, 5);
+    EXPECT_EQ(configuration->socket_buffer_size, 1000);
 }
 
 TEST_F(ConfigurationTest, GameSettings) {
-    EXPECT_EQ(configuration.max_players, 10);
-    EXPECT_EQ(configuration.world_id, 112);
-    EXPECT_EQ(configuration.tick_rate, 12);
+    EXPECT_EQ(configuration->max_players, 10);
+    EXPECT_EQ(configuration->world_id, 112);
+    EXPECT_EQ(configuration->tick_rate, 12);
 }
 
 TEST_F(ConfigurationTest, SystemSettings) {
-    EXPECT_EQ(configuration.log_level, "debug");
+    EXPECT_EQ(configuration->log_level, "debug");
 }
 
 TEST_F(ConfigurationTest, ToString) {
@@ -47,5 +55,10 @@ TEST_F(ConfigurationTest, ToString) {
             "\n  System Settings:"
             "\n    log_level: debug";
 
-    EXPECT_EQ(configuration.toString(), expected_output);
+    EXPECT_EQ(configuration->toString(), expected_output);
+}
+
+TEST_F(ConfigurationTest, GetInstance) {
+    Configuration* instance = Configuration::get_instance();
+    EXPECT_EQ(instance, configuration);
 }