test_alert_manager.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/alert/alert_manager.h>
#include <kcenon/monitoring/alert/alert_triggers.h>
 
#include <atomic>
#include <chrono>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
using namespace kcenon::monitoring;
using namespace std::chrono_literals;
 
// =============================================================================
// alert_manager_config Tests
// =============================================================================
 
TEST(AlertManagerConfigTest, DefaultConfigIsValid) {
    alert_manager_config config;
    EXPECT_TRUE(config.validate());
}
 
TEST(AlertManagerConfigTest, ZeroEvaluationIntervalInvalid) {
    alert_manager_config config;
    config.default_evaluation_interval = 0ms;
    EXPECT_FALSE(config.validate());
}
 
TEST(AlertManagerConfigTest, ZeroRepeatIntervalInvalid) {
    alert_manager_config config;
    config.default_repeat_interval = 0ms;
    EXPECT_FALSE(config.validate());
}
 
TEST(AlertManagerConfigTest, ZeroMaxAlertsInvalid) {
    alert_manager_config config;
    config.max_alerts_per_rule = 0;
    EXPECT_FALSE(config.validate());
}
 
TEST(AlertManagerConfigTest, ZeroMaxSilencesInvalid) {
    alert_manager_config config;
    config.max_silences = 0;
    EXPECT_FALSE(config.validate());
}
 
// =============================================================================
// alert_manager_metrics Tests
// =============================================================================
 
TEST(AlertManagerMetricsTest, DefaultZero) {
    alert_manager_metrics metrics;
    EXPECT_EQ(metrics.rules_evaluated.load(), 0u);
    EXPECT_EQ(metrics.alerts_created.load(), 0u);
    EXPECT_EQ(metrics.alerts_resolved.load(), 0u);
    EXPECT_EQ(metrics.alerts_suppressed.load(), 0u);
    EXPECT_EQ(metrics.notifications_sent.load(), 0u);
    EXPECT_EQ(metrics.notifications_failed.load(), 0u);
}
 
TEST(AlertManagerMetricsTest, CopyConstructor) {
    alert_manager_metrics original;
    original.rules_evaluated = 10;
    original.alerts_created = 5;
 
    alert_manager_metrics copy(original);
    EXPECT_EQ(copy.rules_evaluated.load(), 10u);
    EXPECT_EQ(copy.alerts_created.load(), 5u);
}
 
// =============================================================================
// Lifecycle Tests
// =============================================================================
 
class AlertManagerLifecycleTest : public ::testing::Test {
protected:
    alert_manager_config config_;
 
    void SetUp() override {
        config_.default_evaluation_interval = 100ms;
    }
};
 
TEST_F(AlertManagerLifecycleTest, DefaultConstruction) {
    alert_manager manager;
    EXPECT_FALSE(manager.is_running());
}
 
TEST_F(AlertManagerLifecycleTest, ConstructWithConfig) {
    alert_manager manager(config_);
    EXPECT_FALSE(manager.is_running());
    EXPECT_EQ(manager.config().default_evaluation_interval, 100ms);
}
 
TEST_F(AlertManagerLifecycleTest, StartAndStop) {
    alert_manager manager(config_);
    auto start_result = manager.start();
    EXPECT_TRUE(start_result.is_ok());
    EXPECT_TRUE(manager.is_running());
 
    auto stop_result = manager.stop();
    EXPECT_TRUE(stop_result.is_ok());
    EXPECT_FALSE(manager.is_running());
}
 
TEST_F(AlertManagerLifecycleTest, DoubleStartFails) {
    alert_manager manager(config_);
    EXPECT_TRUE(manager.start().is_ok());
    EXPECT_FALSE(manager.start().is_ok());
    manager.stop();
}
 
TEST_F(AlertManagerLifecycleTest, StopWithoutStartIsOk) {
    alert_manager manager(config_);
    auto result = manager.stop();
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerLifecycleTest, DestructorStopsManager) {
    {
        alert_manager manager(config_);
        manager.start();
        EXPECT_TRUE(manager.is_running());
    }
    // Destructor should cleanly stop without crash
    SUCCEED();
}
 
// =============================================================================
// Rule Management Tests
// =============================================================================
 
class AlertManagerRuleTest : public ::testing::Test {
protected:
    alert_manager manager_;
 
    std::shared_ptr<alert_rule> create_rule(const std::string& name,
                                             const std::string& metric = "cpu_usage") {
        auto rule = std::make_shared<alert_rule>(name);
        rule->set_metric_name(metric)
            .set_severity(alert_severity::critical)
            .set_trigger(threshold_trigger::above(80.0))
            .set_summary("Test rule: " + name);
        return rule;
    }
};
 
TEST_F(AlertManagerRuleTest, AddRule) {
    auto rule = create_rule("test_rule");
    auto result = manager_.add_rule(rule);
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerRuleTest, AddNullRuleFails) {
    auto result = manager_.add_rule(nullptr);
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerRuleTest, GetExistingRule) {
    auto rule = create_rule("get_test");
    manager_.add_rule(rule);
 
    auto retrieved = manager_.get_rule("get_test");
    ASSERT_NE(retrieved, nullptr);
    EXPECT_EQ(retrieved->name(), "get_test");
}
 
TEST_F(AlertManagerRuleTest, GetNonexistentRuleReturnsNull) {
    auto retrieved = manager_.get_rule("missing");
    EXPECT_EQ(retrieved, nullptr);
}
 
TEST_F(AlertManagerRuleTest, RemoveExistingRule) {
    manager_.add_rule(create_rule("to_remove"));
    auto result = manager_.remove_rule("to_remove");
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(manager_.get_rule("to_remove"), nullptr);
}
 
TEST_F(AlertManagerRuleTest, RemoveNonexistentRuleFails) {
    auto result = manager_.remove_rule("missing");
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerRuleTest, GetAllRules) {
    manager_.add_rule(create_rule("rule1"));
    manager_.add_rule(create_rule("rule2"));
    manager_.add_rule(create_rule("rule3"));
 
    auto rules = manager_.get_rules();
    EXPECT_EQ(rules.size(), 3u);
}
 
TEST_F(AlertManagerRuleTest, GetRulesEmpty) {
    auto rules = manager_.get_rules();
    EXPECT_TRUE(rules.empty());
}
 
// =============================================================================
// alert_rule Builder API Tests
// =============================================================================
 
TEST(AlertRuleTest, FluentBuilder) {
    alert_rule rule("cpu_high");
    rule.set_metric_name("cpu_usage")
        .set_severity(alert_severity::critical)
        .set_summary("CPU usage too high")
        .set_description("CPU usage exceeded threshold")
        .set_runbook_url("https://runbooks.example.com/cpu")
        .add_label("team", "infra")
        .add_label("env", "prod")
        .set_group("system_health")
        .set_evaluation_interval(15s)
        .set_for_duration(5min)
        .set_repeat_interval(10min)
        .set_enabled(true)
        .set_trigger(threshold_trigger::above(80.0));
 
    EXPECT_EQ(rule.name(), "cpu_high");
    EXPECT_EQ(rule.metric_name(), "cpu_usage");
    EXPECT_EQ(rule.severity(), alert_severity::critical);
    EXPECT_EQ(rule.annotations().summary, "CPU usage too high");
    EXPECT_EQ(rule.annotations().description, "CPU usage exceeded threshold");
    EXPECT_EQ(*rule.annotations().runbook_url, "https://runbooks.example.com/cpu");
    EXPECT_EQ(rule.labels().get("team"), "infra");
    EXPECT_EQ(rule.labels().get("env"), "prod");
    EXPECT_EQ(rule.group(), "system_health");
    EXPECT_TRUE(rule.is_enabled());
    EXPECT_NE(rule.trigger(), nullptr);
}
 
TEST(AlertRuleTest, ValidateSuccess) {
    alert_rule rule("test");
    rule.set_trigger(threshold_trigger::above(80.0));
    auto result = rule.validate();
    EXPECT_TRUE(result.is_ok());
}
 
TEST(AlertRuleTest, ValidateEmptyNameFails) {
    alert_rule rule("");
    rule.set_trigger(threshold_trigger::above(80.0));
    auto result = rule.validate();
    EXPECT_FALSE(result.is_ok());
}
 
TEST(AlertRuleTest, ValidateNoTriggerFails) {
    alert_rule rule("test");
    auto result = rule.validate();
    EXPECT_FALSE(result.is_ok());
}
 
TEST(AlertRuleTest, ValidateInvalidConfigFails) {
    alert_rule rule("test");
    rule.set_trigger(threshold_trigger::above(80.0))
        .set_evaluation_interval(0ms);
    auto result = rule.validate();
    EXPECT_FALSE(result.is_ok());
}
 
TEST(AlertRuleTest, CreateAlertFromRule) {
    alert_rule rule("cpu_high");
    rule.set_metric_name("cpu_usage")
        .set_severity(alert_severity::critical)
        .set_summary("CPU high")
        .add_label("service", "api")
        .set_group("infra")
        .set_trigger(threshold_trigger::above(80.0));
 
    auto a = rule.create_alert(95.0);
    EXPECT_EQ(a.name, "cpu_high");
    EXPECT_EQ(a.severity, alert_severity::critical);
    EXPECT_EQ(a.value, 95.0);
    EXPECT_EQ(a.rule_name, "cpu_high");
    EXPECT_EQ(a.group_key, "infra");
    EXPECT_EQ(a.labels.get("service"), "api");
}
 
TEST(AlertRuleTest, CreateAlertWithoutGroupUsesName) {
    alert_rule rule("test_rule");
    rule.set_trigger(threshold_trigger::above(80.0));
    auto a = rule.create_alert(90.0);
    EXPECT_EQ(a.group_key, "test_rule");
}
 
TEST(AlertRuleTest, DisabledRule) {
    alert_rule rule("test");
    rule.set_enabled(false);
    EXPECT_FALSE(rule.is_enabled());
}
 
TEST(AlertRuleTest, DefaultSeverityIsWarning) {
    alert_rule rule("test");
    EXPECT_EQ(rule.severity(), alert_severity::warning);
}
 
// =============================================================================
// alert_rule_config Tests
// =============================================================================
 
TEST(AlertRuleConfigTest, DefaultConfigIsValid) {
    alert_rule_config config;
    EXPECT_TRUE(config.validate());
}
 
TEST(AlertRuleConfigTest, ZeroEvalIntervalInvalid) {
    alert_rule_config config;
    config.evaluation_interval = 0ms;
    EXPECT_FALSE(config.validate());
}
 
TEST(AlertRuleConfigTest, ZeroRepeatIntervalInvalid) {
    alert_rule_config config;
    config.repeat_interval = 0ms;
    EXPECT_FALSE(config.validate());
}
 
// =============================================================================
// Rule Group Tests
// =============================================================================
 
TEST(AlertRuleGroupTest, Construction) {
    alert_rule_group group("infra");
    EXPECT_EQ(group.name(), "infra");
    EXPECT_TRUE(group.empty());
    EXPECT_EQ(group.size(), 0u);
}
 
TEST(AlertRuleGroupTest, AddRule) {
    alert_rule_group group("infra");
    auto rule = std::make_shared<alert_rule>("test");
    group.add_rule(rule);
    EXPECT_EQ(group.size(), 1u);
    EXPECT_FALSE(group.empty());
    // Rule should have its group set
    EXPECT_EQ(rule->group(), "infra");
}
 
TEST(AlertRuleGroupTest, AddNullRuleIgnored) {
    alert_rule_group group("test");
    group.add_rule(nullptr);
    EXPECT_TRUE(group.empty());
}
 
TEST(AlertRuleGroupTest, CommonInterval) {
    alert_rule_group group("infra");
    auto rule1 = std::make_shared<alert_rule>("r1");
    auto rule2 = std::make_shared<alert_rule>("r2");
    group.add_rule(rule1);
    group.add_rule(rule2);
    group.set_common_interval(30s);
 
    EXPECT_TRUE(group.common_interval().has_value());
    EXPECT_EQ(*group.common_interval(), 30s);
    EXPECT_EQ(rule1->config().evaluation_interval, 30s);
    EXPECT_EQ(rule2->config().evaluation_interval, 30s);
}
 
TEST(AlertRuleGroupTest, CommonIntervalNotSetByDefault) {
    alert_rule_group group("test");
    EXPECT_FALSE(group.common_interval().has_value());
}
 
TEST(AlertRuleGroupTest, AddRuleGroupToManager) {
    alert_manager manager;
    auto group = std::make_shared<alert_rule_group>("infra");
    auto rule = std::make_shared<alert_rule>("test");
    rule->set_trigger(threshold_trigger::above(80.0))
        .set_metric_name("cpu");
    group->add_rule(rule);
 
    auto result = manager.add_rule_group(group);
    EXPECT_TRUE(result.is_ok());
}
 
// =============================================================================
// Alert Processing Tests
// =============================================================================
 
class AlertManagerProcessingTest : public ::testing::Test {
protected:
    alert_manager manager_;
 
    void SetUp() override {
        auto rule = std::make_shared<alert_rule>("cpu_high");
        rule->set_metric_name("cpu_usage")
            .set_severity(alert_severity::critical)
            .set_trigger(threshold_trigger::above(80.0))
            .set_for_duration(0ms); // Immediate transition (no pending wait)
        manager_.add_rule(rule);
    }
};
 
TEST_F(AlertManagerProcessingTest, ProcessMetricBelowThreshold) {
    auto result = manager_.process_metric("cpu_usage", 50.0);
    EXPECT_TRUE(result.is_ok());
 
    auto alerts = manager_.get_active_alerts();
    EXPECT_TRUE(alerts.empty());
}
 
TEST_F(AlertManagerProcessingTest, ProcessMetricAboveThreshold) {
    auto result = manager_.process_metric("cpu_usage", 95.0);
    EXPECT_TRUE(result.is_ok());
 
    auto alerts = manager_.get_active_alerts();
    // Should have at least one active alert
    EXPECT_GE(alerts.size(), 0u); // Implementation may require manager to be running
}
 
TEST_F(AlertManagerProcessingTest, ProcessUnknownMetric) {
    // Processing a metric with no matching rule should still succeed
    auto result = manager_.process_metric("unknown_metric", 42.0);
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerProcessingTest, ProcessBatchMetrics) {
    std::unordered_map<std::string, double> metrics{
        {"cpu_usage", 95.0},
        {"memory_usage", 85.0},
        {"disk_usage", 50.0}};
 
    auto result = manager_.process_metrics(metrics);
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerProcessingTest, MetricsTrackRulesEvaluated) {
    manager_.process_metric("cpu_usage", 50.0);
    auto metrics = manager_.get_metrics();
    EXPECT_GE(metrics.rules_evaluated.load(), 1u);
}
 
// =============================================================================
// Alert Resolution Tests
// =============================================================================
 
class AlertManagerResolutionTest : public ::testing::Test {
protected:
    alert_manager manager_;
};
 
TEST_F(AlertManagerResolutionTest, ResolveNonexistentAlert) {
    auto result = manager_.resolve_alert("nonexistent_fingerprint");
    // Should fail gracefully for nonexistent alert
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerResolutionTest, GetAlertByFingerprint) {
    // With no alerts, should return empty optional
    auto alert_opt = manager_.get_alert("nonexistent");
    EXPECT_FALSE(alert_opt.has_value());
}
 
// =============================================================================
// Silence Management Tests
// =============================================================================
 
class AlertManagerSilenceTest : public ::testing::Test {
protected:
    alert_manager manager_;
};
 
TEST_F(AlertManagerSilenceTest, CreateSilence) {
    alert_silence silence;
    silence.matchers.set("service", "api");
    silence.comment = "Maintenance window";
 
    auto result = manager_.create_silence(silence);
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerSilenceTest, CreateSilenceReturnsId) {
    alert_silence silence;
    silence.id = 42;
    auto result = manager_.create_silence(silence);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 42u);
}
 
TEST_F(AlertManagerSilenceTest, DeleteSilence) {
    alert_silence silence;
    auto create_result = manager_.create_silence(silence);
    ASSERT_TRUE(create_result.is_ok());
 
    auto delete_result = manager_.delete_silence(create_result.value());
    EXPECT_TRUE(delete_result.is_ok());
}
 
TEST_F(AlertManagerSilenceTest, DeleteNonexistentSilence) {
    auto result = manager_.delete_silence(99999);
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerSilenceTest, GetSilences) {
    alert_silence s1;
    s1.matchers.set("env", "prod");
    manager_.create_silence(s1);
 
    alert_silence s2;
    s2.matchers.set("env", "staging");
    manager_.create_silence(s2);
 
    auto silences = manager_.get_silences();
    EXPECT_EQ(silences.size(), 2u);
}
 
TEST_F(AlertManagerSilenceTest, GetSilencesEmpty) {
    auto silences = manager_.get_silences();
    EXPECT_TRUE(silences.empty());
}
 
TEST_F(AlertManagerSilenceTest, IsSilencedMatchingAlert) {
    alert_silence silence;
    silence.matchers.set("service", "api");
    manager_.create_silence(silence);
 
    alert a;
    a.labels.set("service", "api");
    EXPECT_TRUE(manager_.is_silenced(a));
}
 
TEST_F(AlertManagerSilenceTest, IsNotSilencedNonMatchingAlert) {
    alert_silence silence;
    silence.matchers.set("service", "api");
    manager_.create_silence(silence);
 
    alert a;
    a.labels.set("service", "web");
    EXPECT_FALSE(manager_.is_silenced(a));
}
 
TEST_F(AlertManagerSilenceTest, IsNotSilencedNoSilences) {
    alert a;
    a.labels.set("service", "api");
    EXPECT_FALSE(manager_.is_silenced(a));
}
 
// =============================================================================
// Notifier Management Tests
// =============================================================================
 
class AlertManagerNotifierTest : public ::testing::Test {
protected:
    alert_manager manager_;
};
 
TEST_F(AlertManagerNotifierTest, AddNotifier) {
    auto notifier = std::make_shared<log_notifier>("test_log");
    auto result = manager_.add_notifier(notifier);
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerNotifierTest, AddNullNotifierFails) {
    auto result = manager_.add_notifier(nullptr);
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerNotifierTest, RemoveNotifier) {
    auto notifier = std::make_shared<log_notifier>("removable");
    manager_.add_notifier(notifier);
    auto result = manager_.remove_notifier("removable");
    EXPECT_TRUE(result.is_ok());
}
 
TEST_F(AlertManagerNotifierTest, RemoveNonexistentNotifier) {
    auto result = manager_.remove_notifier("missing");
    EXPECT_FALSE(result.is_ok());
}
 
TEST_F(AlertManagerNotifierTest, GetNotifiers) {
    manager_.add_notifier(std::make_shared<log_notifier>("n1"));
    manager_.add_notifier(std::make_shared<log_notifier>("n2"));
 
    auto notifiers = manager_.get_notifiers();
    EXPECT_EQ(notifiers.size(), 2u);
}
 
// =============================================================================
// callback_notifier Tests
// =============================================================================
 
TEST(CallbackNotifierTest, NotifyInvokesCallback) {
    std::atomic<int> count{0};
    auto notifier = std::make_shared<callback_notifier>(
        "test_cb",
        [&](const alert& /*a*/) { count++; });
 
    alert test_alert;
    auto result = notifier->notify(test_alert);
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(count.load(), 1);
}
 
TEST(CallbackNotifierTest, NotifyGroupInvokesGroupCallback) {
    std::atomic<int> group_count{0};
    auto notifier = std::make_shared<callback_notifier>(
        "test_cb",
        [](const alert&) {},
        [&](const alert_group& /*g*/) { group_count++; });
 
    alert_group group("test");
    auto result = notifier->notify_group(group);
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(group_count.load(), 1);
}
 
TEST(CallbackNotifierTest, NotifyGroupFallsBackToIndividual) {
    std::atomic<int> individual_count{0};
    auto notifier = std::make_shared<callback_notifier>(
        "test_cb",
        [&](const alert& /*a*/) { individual_count++; },
        nullptr); // No group callback
 
    alert_group group("test");
    group.add_alert(alert{});
    group.add_alert(alert{});
 
    auto result = notifier->notify_group(group);
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(individual_count.load(), 2);
}
 
TEST(CallbackNotifierTest, NameIsCorrect) {
    auto notifier = std::make_shared<callback_notifier>(
        "my_notifier", [](const alert&) {});
    EXPECT_EQ(notifier->name(), "my_notifier");
}
 
TEST(CallbackNotifierTest, IsReadyWithCallback) {
    auto notifier = std::make_shared<callback_notifier>(
        "test", [](const alert&) {});
    EXPECT_TRUE(notifier->is_ready());
}
 
TEST(CallbackNotifierTest, NotReadyWithoutCallback) {
    auto notifier = std::make_shared<callback_notifier>(
        "test", nullptr);
    EXPECT_FALSE(notifier->is_ready());
}
 
TEST(CallbackNotifierTest, NotifyWithNullCallbackFails) {
    auto notifier = std::make_shared<callback_notifier>(
        "test", nullptr);
    alert a;
    auto result = notifier->notify(a);
    EXPECT_FALSE(result.is_ok());
}
 
// =============================================================================
// log_notifier Tests
// =============================================================================
 
TEST(LogNotifierTest, DefaultName) {
    log_notifier notifier;
    EXPECT_EQ(notifier.name(), "log_notifier");
}
 
TEST(LogNotifierTest, CustomName) {
    log_notifier notifier("custom_logger");
    EXPECT_EQ(notifier.name(), "custom_logger");
}
 
TEST(LogNotifierTest, IsAlwaysReady) {
    log_notifier notifier;
    EXPECT_TRUE(notifier.is_ready());
}
 
// =============================================================================
// Metric Provider Tests
// =============================================================================
 
TEST(AlertManagerMetricProviderTest, SetMetricProvider) {
    alert_manager manager;
    bool called = false;
 
    manager.set_metric_provider([&](const std::string& name)
                                    -> std::optional<double> {
        called = true;
        if (name == "cpu") return 95.0;
        return std::nullopt;
    });
 
    // The provider is used internally by the evaluation loop
    // Just verify it doesn't crash to set
    SUCCEED();
}
 
// =============================================================================
// Manager Config Access Test
// =============================================================================
 
TEST(AlertManagerConfigAccessTest, DefaultConfig) {
    alert_manager manager;
    auto& config = manager.config();
    EXPECT_TRUE(config.validate());
    EXPECT_EQ(config.default_evaluation_interval, 15000ms);
}
 
TEST(AlertManagerConfigAccessTest, CustomConfig) {
    alert_manager_config config;
    config.default_evaluation_interval = 5s;
    config.max_alerts_per_rule = 50;
 
    alert_manager manager(config);
    EXPECT_EQ(manager.config().default_evaluation_interval, 5s);
    EXPECT_EQ(manager.config().max_alerts_per_rule, 50u);
}
 
// =============================================================================
// Metrics Tracking Tests
// =============================================================================
 
TEST(AlertManagerMetricsTrackingTest, InitialMetricsAreZero) {
    alert_manager manager;
    auto metrics = manager.get_metrics();
    EXPECT_EQ(metrics.rules_evaluated.load(), 0u);
    EXPECT_EQ(metrics.alerts_created.load(), 0u);
    EXPECT_EQ(metrics.alerts_resolved.load(), 0u);
}
 
TEST(AlertManagerMetricsTrackingTest, MetricsIncrementOnProcessing) {
    alert_manager manager;
 
    auto rule = std::make_shared<alert_rule>("test_rule");
    rule->set_metric_name("test_metric")
        .set_trigger(threshold_trigger::above(80.0));
    manager.add_rule(rule);
 
    manager.process_metric("test_metric", 50.0);
 
    auto metrics = manager.get_metrics();
    EXPECT_GE(metrics.rules_evaluated.load(), 1u);
}
 
// =============================================================================
// Event Bus Integration Test
// =============================================================================
 
TEST(AlertManagerEventBusTest, SetEventBusDoesNotCrash) {
    alert_manager manager;
    // Passing nullptr should be handled gracefully
    manager.set_event_bus(nullptr);
    SUCCEED();
}
 
// =============================================================================
// Non-copyable, Non-movable Test
// =============================================================================
 
TEST(AlertManagerNonCopyableTest, VerifyTraits) {
    EXPECT_FALSE(std::is_copy_constructible_v<alert_manager>);
    EXPECT_FALSE(std::is_copy_assignable_v<alert_manager>);
    EXPECT_FALSE(std::is_move_constructible_v<alert_manager>);
    EXPECT_FALSE(std::is_move_assignable_v<alert_manager>);
}