test_adapter_functionality.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#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>
 
using namespace kcenon::monitoring;
using namespace kcenon::common::interfaces;
using kcenon::common::VoidResult;
using kcenon::common::Result;
 
class mock_logger : public ILogger {
private:
    std::atomic<int> log_count_{0};
    log_level min_level_{log_level::trace};
 
public:
    int get_call_count() const { return log_count_.load(); }
 
    VoidResult log(log_level /*level*/, const std::string& /*message*/) override {
        log_count_++;
        return kcenon::common::ok();
    }
 
    VoidResult log(const log_entry& /*entry*/) override {
        log_count_++;
        return kcenon::common::ok();
    }
 
    bool is_enabled(log_level level) const override {
        return level >= min_level_;
    }
 
    VoidResult set_level(log_level level) override {
        min_level_ = level;
        return kcenon::common::ok();
    }
 
    log_level get_level() const override {
        return min_level_;
    }
 
    VoidResult flush() override {
        return kcenon::common::ok();
    }
};
 
TEST(AdapterFunctionalityTest, WorksWithoutLogger) {
    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());
}
 
TEST(AdapterFunctionalityTest, WorksWithMockLogger) {
    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(AdapterFunctionalityTest, RuntimeLoggerInjection) {
    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(AdapterFunctionalityTest, WorksWithMonitorableLogger) {
    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);
}
 
TEST(AdapterFunctionalityTest, MultipleAdaptersIndependent) {
    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());
}