test_adapter_functionality.cpp File Reference

Phase 3.2 - Adapter Functionality Verification Tests. More...

#include <gtest/gtest.h>
#include <kcenon/monitoring/adapters/logger_adapters.h>
#include <kcenon/monitoring/core/event_bus.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <memory>
#include <atomic>

Include dependency graph for test_adapter_functionality.cpp:

Go to the source code of this file.

Classes
class	mock_logger
	Mock logger for testing (does not depend on logger_system) More...

Functions
	TEST (AdapterFunctionalityTest, WorksWithoutLogger)
	Test Scenario 1: Adapter with NULL logger.
	TEST (AdapterFunctionalityTest, WorksWithMockLogger)
	Test Scenario 2: Adapter with mock logger.
	TEST (AdapterFunctionalityTest, RuntimeLoggerInjection)
	Test Scenario 3: Runtime logger injection.
	TEST (AdapterFunctionalityTest, WorksWithMonitorableLogger)
	Test Scenario 4: Adapter with IMonitorable logger.
	TEST (AdapterFunctionalityTest, MultipleAdaptersIndependent)
	Test Scenario 5: Multiple adapters with different loggers.

Detailed Description

Phase 3.2 - Adapter Functionality Verification Tests.

Tests verify that adapters work correctly with:

• NULL loggers
• Mock loggers (interface-only)
• Real loggers (full integration)
• Runtime logger injection

Definition in file test_adapter_functionality.cpp.

Function Documentation

TEST() [1/5]

TEST	(	AdapterFunctionalityTest	,
		MultipleAdaptersIndependent	)

Test Scenario 5: Multiple adapters with different loggers.

Definition at line 197 of file test_adapter_functionality.cpp.

                                                            {
    auto bus = std::make_shared<event_bus>();
 
    auto logger1 = std::make_shared<mock_logger>();
    auto logger2 = std::make_shared<mock_logger>();
 
    auto adapter1 = std::make_shared<logger_system_adapter>(bus, logger1);
    auto adapter2 = std::make_shared<logger_system_adapter>(bus, logger2);
 
    EXPECT_TRUE(adapter1->is_logger_system_available());
    EXPECT_TRUE(adapter2->is_logger_system_available());
 
    EXPECT_NE(adapter1->get_logger(), adapter2->get_logger());
}

TEST() [2/5]

TEST	(	AdapterFunctionalityTest	,
		RuntimeLoggerInjection	)

Test Scenario 3: Runtime logger injection.

Definition at line 109 of file test_adapter_functionality.cpp.

                                                       {
    auto bus = std::make_shared<event_bus>();
    auto adapter = std::make_shared<logger_system_adapter>(bus, nullptr);
 
    EXPECT_FALSE(adapter->is_logger_system_available());
 
    // Inject logger at runtime
    auto logger = std::make_shared<mock_logger>();
    adapter->set_logger(logger);
 
    EXPECT_TRUE(adapter->is_logger_system_available());
 
    // Collect metrics should work now
    EXPECT_NO_THROW({
        auto metrics = adapter->collect_metrics();
        EXPECT_TRUE(metrics.is_ok());
    });
 
    // Replace with another logger
    auto logger2 = std::make_shared<mock_logger>();
    adapter->set_logger(logger2);
 
    auto retrieved = adapter->get_logger();
    EXPECT_EQ(logger2, retrieved);
    EXPECT_NE(logger, retrieved);
}

TEST() [3/5]

TEST	(	AdapterFunctionalityTest	,
		WorksWithMockLogger	)

Test Scenario 2: Adapter with mock logger.

Definition at line 88 of file test_adapter_functionality.cpp.

                                                    {
    auto bus = std::make_shared<event_bus>();
    auto logger = std::make_shared<mock_logger>();
    auto adapter = std::make_shared<logger_system_adapter>(bus, logger);
 
    EXPECT_TRUE(adapter->is_logger_system_available());
 
    // Adapter should be able to work with the logger interface
    EXPECT_NO_THROW({
        auto metrics = adapter->collect_metrics();
        EXPECT_TRUE(metrics.is_ok());
    });
 
    // Get logger should return the same instance
    auto retrieved = adapter->get_logger();
    EXPECT_EQ(logger, retrieved);
}

TEST() [4/5]

TEST	(	AdapterFunctionalityTest	,
		WorksWithMonitorableLogger	)

Test Scenario 4: Adapter with IMonitorable logger.

This test demonstrates that the adapter can work with any ILogger that also implements IMonitorable, without requiring the concrete logger_system classes.

Definition at line 139 of file test_adapter_functionality.cpp.

                                                           {
    class monitorable_mock_logger : public mock_logger, public IMonitorable {
    public:
        Result<metrics_snapshot> get_monitoring_data() override {
            metrics_snapshot snapshot;
            snapshot.source_id = "mock_logger";
            snapshot.add_metric("messages_logged", 42.0);
            return snapshot;
        }
 
        Result<health_check_result> health_check() override {
            health_check_result result;
            result.status = health_status::healthy;
            result.message = "Mock logger operational";
            return result;
        }
 
        std::string get_component_name() const override {
            return "monitorable_mock_logger";
        }
    };
 
    auto bus = std::make_shared<event_bus>();
    auto logger = std::make_shared<monitorable_mock_logger>();
    auto adapter = std::make_shared<logger_system_adapter>(bus, logger);
 
    EXPECT_TRUE(adapter->is_logger_system_available());
 
    // Collect metrics should retrieve from IMonitorable
    auto metrics_result = adapter->collect_metrics();
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto& metrics = metrics_result.value();
    EXPECT_FALSE(metrics.empty());
 
    // Should have the metric from the mock
    bool found_metric = false;
    for (const auto& m : metrics) {
        if (m.name == "messages_logged") {
            if (auto* dval = std::get_if<double>(&m.value)) {
                if (*dval == 42.0) {
                    found_metric = true;
                    break;
                }
            }
        }
    }
    EXPECT_TRUE(found_metric);
}

References kcenon::monitoring::metrics_snapshot::add_metric(), kcenon::monitoring::health_check_result::message, kcenon::monitoring::metrics_snapshot::source_id, and kcenon::monitoring::health_check_result::status.

Here is the call graph for this function:

TEST() [5/5]

TEST	(	AdapterFunctionalityTest	,
		WorksWithoutLogger	)

Test Scenario 1: Adapter with NULL logger.

Definition at line 70 of file test_adapter_functionality.cpp.

                                                   {
    auto bus = std::make_shared<event_bus>();
    auto adapter = std::make_shared<logger_system_adapter>(bus, nullptr);
 
    // Should not crash with null logger
    EXPECT_FALSE(adapter->is_logger_system_available());
    EXPECT_NO_THROW({
        auto metrics = adapter->collect_metrics();
        EXPECT_TRUE(metrics.is_ok());
    });
 
    // Get log rate should return 0
    EXPECT_EQ(0.0, adapter->get_current_log_rate());
}