test_interfaces_compile.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 <kcenon/monitoring/interfaces/observer_interface.h>
#include <kcenon/monitoring/interfaces/metric_collector_interface.h>
#include <kcenon/monitoring/interfaces/event_bus_interface.h>
#include <memory>
#include <iostream>
 
using namespace kcenon::monitoring;
 
// Test implementation of observer interface
class test_observer : public interface_monitoring_observer {
public:
    void on_metric_collected(const metric_event& event) override {
        std::cout << "Metric collected from: " << event.source() << std::endl;
    }
 
    void on_event_occurred(const system_event& event) override {
        std::cout << "System event from: " << event.component() << std::endl;
    }
 
    void on_system_state_changed(const state_change_event& event) override {
        std::cout << "State change in: " << event.component() << std::endl;
    }
};
 
// Test that interfaces can be used as base classes
class test_collector : public interface_metric_collector {
public:
    kcenon::common::Result<std::vector<metric>> collect_metrics() override {
        return kcenon::common::ok(std::vector<metric>{});
    }
 
    kcenon::common::VoidResult start_collection(const collection_config& config) override {
        (void)config;
        return kcenon::common::ok();
    }
 
    kcenon::common::VoidResult stop_collection() override {
        return kcenon::common::ok();
    }
 
    bool is_collecting() const override {
        return false;
    }
 
    std::vector<std::string> get_metric_types() const override {
        return {"test_metric"};
    }
 
    collection_config get_config() const override {
        return collection_config{};
    }
 
    kcenon::common::VoidResult update_config(const collection_config& config) override {
        (void)config;
        return kcenon::common::ok();
    }
 
    kcenon::common::Result<std::vector<metric>> force_collect() override {
        return collect_metrics();
    }
 
    metric_stats get_stats() const override {
        return metric_stats{};
    }
 
    void reset_stats() override {}
 
    // Observable interface methods
    kcenon::common::VoidResult register_observer(std::shared_ptr<interface_monitoring_observer> observer) override {
        (void)observer;
        return kcenon::common::ok();
    }
 
    kcenon::common::VoidResult unregister_observer(std::shared_ptr<interface_monitoring_observer> observer) override {
        (void)observer;
        return kcenon::common::ok();
    }
 
    void notify_metric(const metric_event& event) override { (void)event; }
    void notify_event(const system_event& event) override { (void)event; }
    void notify_state_change(const state_change_event& event) override { (void)event; }
};
 
int main() {
    std::cout << "=== Interface Compilation Test ===" << std::endl;
 
    // Test that interfaces can be instantiated through implementations
    auto observer = std::make_shared<test_observer>();
    auto collector = std::make_shared<test_collector>();
 
    // Test that interfaces can be used
    metric m{"test", 42.0, {}};
    metric_event me("test_source", m);
    observer->on_metric_collected(me);
 
    system_event se(system_event::event_type::component_started, "test_component", "Started");
    observer->on_event_occurred(se);
 
    state_change_event sce("test_component",
                          state_change_event::state::healthy,
                          state_change_event::state::degraded);
    observer->on_system_state_changed(sce);
 
    // Test collector interface
    auto result = collector->collect_metrics();
    if (result.is_ok()) {
        std::cout << "Metrics collected successfully" << std::endl;
    }
 
    auto types = collector->get_metric_types();
    std::cout << "Collector supports " << types.size() << " metric type(s)" << std::endl;
 
    std::cout << "✅ All interface compilation tests passed!" << std::endl;
 
    return 0;
}