test_alert_manager.cpp File Reference

#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>

Include dependency graph for test_alert_manager.cpp:

Go to the source code of this file.

Classes
class	AlertManagerLifecycleTest
class	AlertManagerRuleTest
class	AlertManagerProcessingTest
class	AlertManagerResolutionTest
class	AlertManagerSilenceTest
class	AlertManagerNotifierTest

Functions
	TEST (AlertManagerConfigTest, DefaultConfigIsValid)
	TEST (AlertManagerConfigTest, ZeroEvaluationIntervalInvalid)
	TEST (AlertManagerConfigTest, ZeroRepeatIntervalInvalid)
	TEST (AlertManagerConfigTest, ZeroMaxAlertsInvalid)
	TEST (AlertManagerConfigTest, ZeroMaxSilencesInvalid)
	TEST (AlertManagerMetricsTest, DefaultZero)
	TEST (AlertManagerMetricsTest, CopyConstructor)
	TEST_F (AlertManagerLifecycleTest, DefaultConstruction)
	TEST_F (AlertManagerLifecycleTest, ConstructWithConfig)
	TEST_F (AlertManagerLifecycleTest, StartAndStop)
	TEST_F (AlertManagerLifecycleTest, DoubleStartFails)
	TEST_F (AlertManagerLifecycleTest, StopWithoutStartIsOk)
	TEST_F (AlertManagerLifecycleTest, DestructorStopsManager)
	TEST_F (AlertManagerRuleTest, AddRule)
	TEST_F (AlertManagerRuleTest, AddNullRuleFails)
	TEST_F (AlertManagerRuleTest, GetExistingRule)
	TEST_F (AlertManagerRuleTest, GetNonexistentRuleReturnsNull)
	TEST_F (AlertManagerRuleTest, RemoveExistingRule)
	TEST_F (AlertManagerRuleTest, RemoveNonexistentRuleFails)
	TEST_F (AlertManagerRuleTest, GetAllRules)
	TEST_F (AlertManagerRuleTest, GetRulesEmpty)
	TEST (AlertRuleTest, FluentBuilder)
	TEST (AlertRuleTest, ValidateSuccess)
	TEST (AlertRuleTest, ValidateEmptyNameFails)
	TEST (AlertRuleTest, ValidateNoTriggerFails)
	TEST (AlertRuleTest, ValidateInvalidConfigFails)
	TEST (AlertRuleTest, CreateAlertFromRule)
	TEST (AlertRuleTest, CreateAlertWithoutGroupUsesName)
	TEST (AlertRuleTest, DisabledRule)
	TEST (AlertRuleTest, DefaultSeverityIsWarning)
	TEST (AlertRuleConfigTest, DefaultConfigIsValid)
	TEST (AlertRuleConfigTest, ZeroEvalIntervalInvalid)
	TEST (AlertRuleConfigTest, ZeroRepeatIntervalInvalid)
	TEST (AlertRuleGroupTest, Construction)
	TEST (AlertRuleGroupTest, AddRule)
	TEST (AlertRuleGroupTest, AddNullRuleIgnored)
	TEST (AlertRuleGroupTest, CommonInterval)
	TEST (AlertRuleGroupTest, CommonIntervalNotSetByDefault)
	TEST (AlertRuleGroupTest, AddRuleGroupToManager)
	TEST_F (AlertManagerProcessingTest, ProcessMetricBelowThreshold)
	TEST_F (AlertManagerProcessingTest, ProcessMetricAboveThreshold)
	TEST_F (AlertManagerProcessingTest, ProcessUnknownMetric)
	TEST_F (AlertManagerProcessingTest, ProcessBatchMetrics)
	TEST_F (AlertManagerProcessingTest, MetricsTrackRulesEvaluated)
	TEST_F (AlertManagerResolutionTest, ResolveNonexistentAlert)
	TEST_F (AlertManagerResolutionTest, GetAlertByFingerprint)
	TEST_F (AlertManagerSilenceTest, CreateSilence)
	TEST_F (AlertManagerSilenceTest, CreateSilenceReturnsId)
	TEST_F (AlertManagerSilenceTest, DeleteSilence)
	TEST_F (AlertManagerSilenceTest, DeleteNonexistentSilence)
	TEST_F (AlertManagerSilenceTest, GetSilences)
	TEST_F (AlertManagerSilenceTest, GetSilencesEmpty)
	TEST_F (AlertManagerSilenceTest, IsSilencedMatchingAlert)
	TEST_F (AlertManagerSilenceTest, IsNotSilencedNonMatchingAlert)
	TEST_F (AlertManagerSilenceTest, IsNotSilencedNoSilences)
	TEST_F (AlertManagerNotifierTest, AddNotifier)
	TEST_F (AlertManagerNotifierTest, AddNullNotifierFails)
	TEST_F (AlertManagerNotifierTest, RemoveNotifier)
	TEST_F (AlertManagerNotifierTest, RemoveNonexistentNotifier)
	TEST_F (AlertManagerNotifierTest, GetNotifiers)
	TEST (CallbackNotifierTest, NotifyInvokesCallback)
	TEST (CallbackNotifierTest, NotifyGroupInvokesGroupCallback)
	TEST (CallbackNotifierTest, NotifyGroupFallsBackToIndividual)
	TEST (CallbackNotifierTest, NameIsCorrect)
	TEST (CallbackNotifierTest, IsReadyWithCallback)
	TEST (CallbackNotifierTest, NotReadyWithoutCallback)
	TEST (CallbackNotifierTest, NotifyWithNullCallbackFails)
	TEST (LogNotifierTest, DefaultName)
	TEST (LogNotifierTest, CustomName)
	TEST (LogNotifierTest, IsAlwaysReady)
	TEST (AlertManagerMetricProviderTest, SetMetricProvider)
	TEST (AlertManagerConfigAccessTest, DefaultConfig)
	TEST (AlertManagerConfigAccessTest, CustomConfig)
	TEST (AlertManagerMetricsTrackingTest, InitialMetricsAreZero)
	TEST (AlertManagerMetricsTrackingTest, MetricsIncrementOnProcessing)
	TEST (AlertManagerEventBusTest, SetEventBusDoesNotCrash)
	TEST (AlertManagerNonCopyableTest, VerifyTraits)

Function Documentation

TEST() [1/42]

TEST	(	AlertManagerConfigAccessTest	,
		CustomConfig	)

Definition at line 721 of file test_alert_manager.cpp.

                                                 {
    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);
}

References kcenon::monitoring::alert_manager::config(), kcenon::monitoring::alert_manager_config::default_evaluation_interval, and kcenon::monitoring::alert_manager_config::max_alerts_per_rule.

Here is the call graph for this function:

TEST() [2/42]

TEST	(	AlertManagerConfigAccessTest	,
		DefaultConfig	)

Definition at line 714 of file test_alert_manager.cpp.

                                                  {
    alert_manager manager;
    auto& config = manager.config();
    EXPECT_TRUE(config.validate());
    EXPECT_EQ(config.default_evaluation_interval, 15000ms);
}

References kcenon::monitoring::alert_manager::config().

Here is the call graph for this function:

TEST() [3/42]

TEST	(	AlertManagerConfigTest	,
		DefaultConfigIsValid	)

Definition at line 41 of file test_alert_manager.cpp.

                                                   {
    alert_manager_config config;
    EXPECT_TRUE(config.validate());
}

References kcenon::monitoring::alert_manager_config::validate().

Here is the call graph for this function:

TEST() [4/42]

TEST	(	AlertManagerConfigTest	,
		ZeroEvaluationIntervalInvalid	)

Definition at line 46 of file test_alert_manager.cpp.

                                                            {
    alert_manager_config config;
    config.default_evaluation_interval = 0ms;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_manager_config::default_evaluation_interval, and kcenon::monitoring::alert_manager_config::validate().

Here is the call graph for this function:

TEST() [5/42]

TEST	(	AlertManagerConfigTest	,
		ZeroMaxAlertsInvalid	)

Definition at line 58 of file test_alert_manager.cpp.

                                                   {
    alert_manager_config config;
    config.max_alerts_per_rule = 0;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_manager_config::max_alerts_per_rule, and kcenon::monitoring::alert_manager_config::validate().

Here is the call graph for this function:

TEST() [6/42]

TEST	(	AlertManagerConfigTest	,
		ZeroMaxSilencesInvalid	)

Definition at line 64 of file test_alert_manager.cpp.

                                                     {
    alert_manager_config config;
    config.max_silences = 0;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_manager_config::max_silences, and kcenon::monitoring::alert_manager_config::validate().

Here is the call graph for this function:

TEST() [7/42]

TEST	(	AlertManagerConfigTest	,
		ZeroRepeatIntervalInvalid	)

Definition at line 52 of file test_alert_manager.cpp.

                                                        {
    alert_manager_config config;
    config.default_repeat_interval = 0ms;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_manager_config::default_repeat_interval, and kcenon::monitoring::alert_manager_config::validate().

Here is the call graph for this function:

TEST() [8/42]

TEST	(	AlertManagerEventBusTest	,
		SetEventBusDoesNotCrash	)

Definition at line 761 of file test_alert_manager.cpp.

                                                        {
    alert_manager manager;
    // Passing nullptr should be handled gracefully
    manager.set_event_bus(nullptr);
    SUCCEED();
}

References kcenon::monitoring::alert_manager::set_event_bus().

Here is the call graph for this function:

TEST() [9/42]

TEST	(	AlertManagerMetricProviderTest	,
		SetMetricProvider	)

Definition at line 694 of file test_alert_manager.cpp.

                                                        {
    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();
}

References kcenon::monitoring::alert_manager::set_metric_provider().

Here is the call graph for this function:

TEST() [10/42]

TEST	(	AlertManagerMetricsTest	,
		CopyConstructor	)

Definition at line 84 of file test_alert_manager.cpp.

                                               {
    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);
}

References kcenon::monitoring::alert_manager_metrics::alerts_created, and kcenon::monitoring::alert_manager_metrics::rules_evaluated.

TEST() [11/42]

TEST	(	AlertManagerMetricsTest	,
		DefaultZero	)

Definition at line 74 of file test_alert_manager.cpp.

                                           {
    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);
}

References kcenon::monitoring::alert_manager_metrics::alerts_created, kcenon::monitoring::alert_manager_metrics::alerts_resolved, kcenon::monitoring::alert_manager_metrics::alerts_suppressed, kcenon::monitoring::alert_manager_metrics::notifications_failed, kcenon::monitoring::alert_manager_metrics::notifications_sent, and kcenon::monitoring::alert_manager_metrics::rules_evaluated.

TEST() [12/42]

TEST	(	AlertManagerMetricsTrackingTest	,
		InitialMetricsAreZero	)

Definition at line 735 of file test_alert_manager.cpp.

                                                             {
    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);
}

References kcenon::monitoring::alert_manager::get_metrics().

Here is the call graph for this function:

TEST() [13/42]

TEST	(	AlertManagerMetricsTrackingTest	,
		MetricsIncrementOnProcessing	)

Definition at line 743 of file test_alert_manager.cpp.

                                                                    {
    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);
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_manager::add_rule(), kcenon::monitoring::alert_manager::get_metrics(), and kcenon::monitoring::alert_manager::process_metric().

Here is the call graph for this function:

TEST() [14/42]

TEST	(	AlertManagerNonCopyableTest	,
		VerifyTraits	)

Definition at line 772 of file test_alert_manager.cpp.

                                                {
    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>);
}

TEST() [15/42]

TEST	(	AlertRuleConfigTest	,
		DefaultConfigIsValid	)

Definition at line 323 of file test_alert_manager.cpp.

                                                {
    alert_rule_config config;
    EXPECT_TRUE(config.validate());
}

References kcenon::monitoring::alert_rule_config::validate().

Here is the call graph for this function:

TEST() [16/42]

TEST	(	AlertRuleConfigTest	,
		ZeroEvalIntervalInvalid	)

Definition at line 328 of file test_alert_manager.cpp.

                                                   {
    alert_rule_config config;
    config.evaluation_interval = 0ms;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_rule_config::evaluation_interval, and kcenon::monitoring::alert_rule_config::validate().

Here is the call graph for this function:

TEST() [17/42]

TEST	(	AlertRuleConfigTest	,
		ZeroRepeatIntervalInvalid	)

Definition at line 334 of file test_alert_manager.cpp.

                                                     {
    alert_rule_config config;
    config.repeat_interval = 0ms;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::alert_rule_config::repeat_interval, and kcenon::monitoring::alert_rule_config::validate().

Here is the call graph for this function:

TEST() [18/42]

TEST	(	AlertRuleGroupTest	,
		AddNullRuleIgnored	)

Definition at line 361 of file test_alert_manager.cpp.

                                             {
    alert_rule_group group("test");
    group.add_rule(nullptr);
    EXPECT_TRUE(group.empty());
}

References kcenon::monitoring::alert_rule_group::add_rule(), and kcenon::monitoring::alert_rule_group::empty().

Here is the call graph for this function:

TEST() [19/42]

TEST	(	AlertRuleGroupTest	,
		AddRule	)

Definition at line 351 of file test_alert_manager.cpp.

                                  {
    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");
}

References kcenon::monitoring::alert_rule_group::add_rule(), kcenon::monitoring::alert_rule_group::empty(), and kcenon::monitoring::alert_rule_group::size().

Here is the call graph for this function:

TEST() [20/42]

TEST	(	AlertRuleGroupTest	,
		AddRuleGroupToManager	)

Definition at line 386 of file test_alert_manager.cpp.

                                                {
    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());
}

References kcenon::monitoring::threshold_trigger::above(), and kcenon::monitoring::alert_manager::add_rule_group().

Here is the call graph for this function:

TEST() [21/42]

TEST	(	AlertRuleGroupTest	,
		CommonInterval	)

Definition at line 367 of file test_alert_manager.cpp.

                                         {
    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);
}

References kcenon::monitoring::alert_rule_group::add_rule(), kcenon::monitoring::alert_rule_group::common_interval(), and kcenon::monitoring::alert_rule_group::set_common_interval().

Here is the call graph for this function:

TEST() [22/42]

TEST	(	AlertRuleGroupTest	,
		CommonIntervalNotSetByDefault	)

Definition at line 381 of file test_alert_manager.cpp.

                                                        {
    alert_rule_group group("test");
    EXPECT_FALSE(group.common_interval().has_value());
}

References kcenon::monitoring::alert_rule_group::common_interval().

Here is the call graph for this function:

TEST() [23/42]

TEST	(	AlertRuleGroupTest	,
		Construction	)

Definition at line 344 of file test_alert_manager.cpp.

                                       {
    alert_rule_group group("infra");
    EXPECT_EQ(group.name(), "infra");
    EXPECT_TRUE(group.empty());
    EXPECT_EQ(group.size(), 0u);
}

References kcenon::monitoring::alert_rule_group::empty(), kcenon::monitoring::alert_rule_group::name(), and kcenon::monitoring::alert_rule_group::size().

Here is the call graph for this function:

TEST() [24/42]

TEST	(	AlertRuleTest	,
		CreateAlertFromRule	)

Definition at line 283 of file test_alert_manager.cpp.

                                         {
    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");
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::add_label(), kcenon::monitoring::alert_rule::create_alert(), kcenon::monitoring::alert_rule::set_group(), kcenon::monitoring::alert_rule::set_metric_name(), kcenon::monitoring::alert_rule::set_severity(), kcenon::monitoring::alert_rule::set_summary(), and kcenon::monitoring::alert_rule::set_trigger().

Here is the call graph for this function:

TEST() [25/42]

TEST	(	AlertRuleTest	,
		CreateAlertWithoutGroupUsesName	)

Definition at line 301 of file test_alert_manager.cpp.

                                                     {
    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");
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::create_alert(), and kcenon::monitoring::alert_rule::set_trigger().

Here is the call graph for this function:

TEST() [26/42]

TEST	(	AlertRuleTest	,
		DefaultSeverityIsWarning	)

Definition at line 314 of file test_alert_manager.cpp.

                                              {
    alert_rule rule("test");
    EXPECT_EQ(rule.severity(), alert_severity::warning);
}

References kcenon::monitoring::alert_rule::severity().

Here is the call graph for this function:

TEST() [27/42]

TEST	(	AlertRuleTest	,
		DisabledRule	)

Definition at line 308 of file test_alert_manager.cpp.

                                  {
    alert_rule rule("test");
    rule.set_enabled(false);
    EXPECT_FALSE(rule.is_enabled());
}

References kcenon::monitoring::alert_rule::is_enabled(), and kcenon::monitoring::alert_rule::set_enabled().

Here is the call graph for this function:

TEST() [28/42]

TEST	(	AlertRuleTest	,
		FluentBuilder	)

Definition at line 226 of file test_alert_manager.cpp.

                                   {
    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);
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::add_label(), kcenon::monitoring::alert_rule::annotations(), kcenon::monitoring::alert_annotations::description, kcenon::monitoring::alert_labels::get(), kcenon::monitoring::alert_rule::group(), kcenon::monitoring::alert_rule::is_enabled(), kcenon::monitoring::alert_rule::labels(), kcenon::monitoring::alert_rule::metric_name(), kcenon::monitoring::alert_rule::name(), kcenon::monitoring::alert_annotations::runbook_url, kcenon::monitoring::alert_rule::set_description(), kcenon::monitoring::alert_rule::set_enabled(), kcenon::monitoring::alert_rule::set_evaluation_interval(), kcenon::monitoring::alert_rule::set_for_duration(), kcenon::monitoring::alert_rule::set_group(), kcenon::monitoring::alert_rule::set_metric_name(), kcenon::monitoring::alert_rule::set_repeat_interval(), kcenon::monitoring::alert_rule::set_runbook_url(), kcenon::monitoring::alert_rule::set_severity(), kcenon::monitoring::alert_rule::set_summary(), kcenon::monitoring::alert_rule::set_trigger(), kcenon::monitoring::alert_rule::severity(), kcenon::monitoring::alert_annotations::summary, and kcenon::monitoring::alert_rule::trigger().

Here is the call graph for this function:

TEST() [29/42]

TEST	(	AlertRuleTest	,
		ValidateEmptyNameFails	)

Definition at line 262 of file test_alert_manager.cpp.

                                            {
    alert_rule rule("");
    rule.set_trigger(threshold_trigger::above(80.0));
    auto result = rule.validate();
    EXPECT_FALSE(result.is_ok());
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::set_trigger(), and kcenon::monitoring::alert_rule::validate().

Here is the call graph for this function:

TEST() [30/42]

TEST	(	AlertRuleTest	,
		ValidateInvalidConfigFails	)

Definition at line 275 of file test_alert_manager.cpp.

                                                {
    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());
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::set_evaluation_interval(), kcenon::monitoring::alert_rule::set_trigger(), and kcenon::monitoring::alert_rule::validate().

Here is the call graph for this function:

TEST() [31/42]

TEST	(	AlertRuleTest	,
		ValidateNoTriggerFails	)

Definition at line 269 of file test_alert_manager.cpp.

                                            {
    alert_rule rule("test");
    auto result = rule.validate();
    EXPECT_FALSE(result.is_ok());
}

References kcenon::monitoring::alert_rule::validate().

Here is the call graph for this function:

TEST() [32/42]

TEST	(	AlertRuleTest	,
		ValidateSuccess	)

Definition at line 255 of file test_alert_manager.cpp.

                                     {
    alert_rule rule("test");
    rule.set_trigger(threshold_trigger::above(80.0));
    auto result = rule.validate();
    EXPECT_TRUE(result.is_ok());
}

References kcenon::monitoring::threshold_trigger::above(), kcenon::monitoring::alert_rule::set_trigger(), and kcenon::monitoring::alert_rule::validate().

Here is the call graph for this function:

TEST() [33/42]

TEST	(	CallbackNotifierTest	,
		IsReadyWithCallback	)

Definition at line 651 of file test_alert_manager.cpp.

                                                {
    auto notifier = std::make_shared<callback_notifier>(
        "test", [](const alert&) {});
    EXPECT_TRUE(notifier->is_ready());
}

TEST() [34/42]

TEST	(	CallbackNotifierTest	,
		NameIsCorrect	)

Definition at line 645 of file test_alert_manager.cpp.

                                          {
    auto notifier = std::make_shared<callback_notifier>(
        "my_notifier", [](const alert&) {});
    EXPECT_EQ(notifier->name(), "my_notifier");
}

TEST() [35/42]

TEST	(	CallbackNotifierTest	,
		NotifyGroupFallsBackToIndividual	)

Definition at line 629 of file test_alert_manager.cpp.

                                                             {
    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() [36/42]

TEST	(	CallbackNotifierTest	,
		NotifyGroupInvokesGroupCallback	)

Definition at line 616 of file test_alert_manager.cpp.

                                                            {
    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() [37/42]

TEST	(	CallbackNotifierTest	,
		NotifyInvokesCallback	)

Definition at line 604 of file test_alert_manager.cpp.

                                                  {
    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() [38/42]

TEST	(	CallbackNotifierTest	,
		NotifyWithNullCallbackFails	)

Definition at line 663 of file test_alert_manager.cpp.

                                                        {
    auto notifier = std::make_shared<callback_notifier>(
        "test", nullptr);
    alert a;
    auto result = notifier->notify(a);
    EXPECT_FALSE(result.is_ok());
}

TEST() [39/42]

TEST	(	CallbackNotifierTest	,
		NotReadyWithoutCallback	)

Definition at line 657 of file test_alert_manager.cpp.

                                                    {
    auto notifier = std::make_shared<callback_notifier>(
        "test", nullptr);
    EXPECT_FALSE(notifier->is_ready());
}

TEST() [40/42]

TEST	(	LogNotifierTest	,
		CustomName	)

Definition at line 680 of file test_alert_manager.cpp.

                                  {
    log_notifier notifier("custom_logger");
    EXPECT_EQ(notifier.name(), "custom_logger");
}

References kcenon::monitoring::log_notifier::name().

Here is the call graph for this function:

TEST() [41/42]

TEST	(	LogNotifierTest	,
		DefaultName	)

Definition at line 675 of file test_alert_manager.cpp.

                                   {
    log_notifier notifier;
    EXPECT_EQ(notifier.name(), "log_notifier");
}

References kcenon::monitoring::log_notifier::name().

Here is the call graph for this function:

TEST() [42/42]

TEST	(	LogNotifierTest	,
		IsAlwaysReady	)

Definition at line 685 of file test_alert_manager.cpp.

                                     {
    log_notifier notifier;
    EXPECT_TRUE(notifier.is_ready());
}

References kcenon::monitoring::log_notifier::is_ready().

Here is the call graph for this function:

TEST_F() [1/35]

TEST_F	(	AlertManagerLifecycleTest	,
		ConstructWithConfig	)

Definition at line 112 of file test_alert_manager.cpp.

                                                       {
    alert_manager manager(config_);
    EXPECT_FALSE(manager.is_running());
    EXPECT_EQ(manager.config().default_evaluation_interval, 100ms);
}

References kcenon::monitoring::alert_manager::config(), kcenon::monitoring::alert_manager_config::default_evaluation_interval, and kcenon::monitoring::alert_manager::is_running().

Here is the call graph for this function:

TEST_F() [2/35]

TEST_F	(	AlertManagerLifecycleTest	,
		DefaultConstruction	)

Definition at line 107 of file test_alert_manager.cpp.

                                                       {
    alert_manager manager;
    EXPECT_FALSE(manager.is_running());
}

References kcenon::monitoring::alert_manager::is_running().

Here is the call graph for this function:

TEST_F() [3/35]

TEST_F	(	AlertManagerLifecycleTest	,
		DestructorStopsManager	)

Definition at line 142 of file test_alert_manager.cpp.

                                                          {
    {
        alert_manager manager(config_);
        manager.start();
        EXPECT_TRUE(manager.is_running());
    }
    // Destructor should cleanly stop without crash
    SUCCEED();
}

References kcenon::monitoring::alert_manager::is_running(), and kcenon::monitoring::alert_manager::start().

Here is the call graph for this function:

TEST_F() [4/35]

TEST_F	(	AlertManagerLifecycleTest	,
		DoubleStartFails	)

Definition at line 129 of file test_alert_manager.cpp.

                                                    {
    alert_manager manager(config_);
    EXPECT_TRUE(manager.start().is_ok());
    EXPECT_FALSE(manager.start().is_ok());
    manager.stop();
}

References kcenon::monitoring::alert_manager::start(), and kcenon::monitoring::alert_manager::stop().

Here is the call graph for this function:

TEST_F() [5/35]

TEST_F	(	AlertManagerLifecycleTest	,
		StartAndStop	)

Definition at line 118 of file test_alert_manager.cpp.

                                                {
    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());
}

References kcenon::monitoring::alert_manager::is_running(), kcenon::monitoring::alert_manager::start(), and kcenon::monitoring::alert_manager::stop().

Here is the call graph for this function:

TEST_F() [6/35]

TEST_F	(	AlertManagerLifecycleTest	,
		StopWithoutStartIsOk	)

Definition at line 136 of file test_alert_manager.cpp.

                                                        {
    alert_manager manager(config_);
    auto result = manager.stop();
    EXPECT_TRUE(result.is_ok());
}

References kcenon::monitoring::alert_manager::stop().

Here is the call graph for this function:

TEST_F() [7/35]

TEST_F	(	AlertManagerNotifierTest	,
		AddNotifier	)

Definition at line 569 of file test_alert_manager.cpp.

                                              {
    auto notifier = std::make_shared<log_notifier>("test_log");
    auto result = manager_.add_notifier(notifier);
    EXPECT_TRUE(result.is_ok());
}

TEST_F() [8/35]

TEST_F	(	AlertManagerNotifierTest	,
		AddNullNotifierFails	)

Definition at line 575 of file test_alert_manager.cpp.

                                                       {
    auto result = manager_.add_notifier(nullptr);
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [9/35]

TEST_F	(	AlertManagerNotifierTest	,
		GetNotifiers	)

Definition at line 592 of file test_alert_manager.cpp.

                                               {
    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);
}

TEST_F() [10/35]

TEST_F	(	AlertManagerNotifierTest	,
		RemoveNonexistentNotifier	)

Definition at line 587 of file test_alert_manager.cpp.

                                                            {
    auto result = manager_.remove_notifier("missing");
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [11/35]

TEST_F	(	AlertManagerNotifierTest	,
		RemoveNotifier	)

Definition at line 580 of file test_alert_manager.cpp.

                                                 {
    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() [12/35]

TEST_F	(	AlertManagerProcessingTest	,
		MetricsTrackRulesEvaluated	)

Definition at line 449 of file test_alert_manager.cpp.

                                                               {
    manager_.process_metric("cpu_usage", 50.0);
    auto metrics = manager_.get_metrics();
    EXPECT_GE(metrics.rules_evaluated.load(), 1u);
}

TEST_F() [13/35]

TEST_F	(	AlertManagerProcessingTest	,
		ProcessBatchMetrics	)

Definition at line 439 of file test_alert_manager.cpp.

                                                        {
    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() [14/35]

TEST_F	(	AlertManagerProcessingTest	,
		ProcessMetricAboveThreshold	)

Definition at line 424 of file test_alert_manager.cpp.

                                                                {
    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() [15/35]

TEST_F	(	AlertManagerProcessingTest	,
		ProcessMetricBelowThreshold	)

Definition at line 416 of file test_alert_manager.cpp.

                                                                {
    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() [16/35]

TEST_F	(	AlertManagerProcessingTest	,
		ProcessUnknownMetric	)

Definition at line 433 of file test_alert_manager.cpp.

                                                         {
    // 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() [17/35]

TEST_F	(	AlertManagerResolutionTest	,
		GetAlertByFingerprint	)

Definition at line 470 of file test_alert_manager.cpp.

                                                          {
    // With no alerts, should return empty optional
    auto alert_opt = manager_.get_alert("nonexistent");
    EXPECT_FALSE(alert_opt.has_value());
}

TEST_F() [18/35]

TEST_F	(	AlertManagerResolutionTest	,
		ResolveNonexistentAlert	)

Definition at line 464 of file test_alert_manager.cpp.

                                                            {
    auto result = manager_.resolve_alert("nonexistent_fingerprint");
    // Should fail gracefully for nonexistent alert
    EXPECT_FALSE(result.is_ok());
}

References kcenon::monitoring::alert_manager::resolve_alert().

Here is the call graph for this function:

TEST_F() [19/35]

TEST_F	(	AlertManagerRuleTest	,
		AddNullRuleFails	)

Definition at line 177 of file test_alert_manager.cpp.

                                               {
    auto result = manager_.add_rule(nullptr);
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [20/35]

TEST_F	(	AlertManagerRuleTest	,
		AddRule	)

Definition at line 171 of file test_alert_manager.cpp.

                                      {
    auto rule = create_rule("test_rule");
    auto result = manager_.add_rule(rule);
    EXPECT_TRUE(result.is_ok());
}

TEST_F() [21/35]

TEST_F	(	AlertManagerRuleTest	,
		GetAllRules	)

Definition at line 208 of file test_alert_manager.cpp.

                                          {
    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() [22/35]

TEST_F	(	AlertManagerRuleTest	,
		GetExistingRule	)

Definition at line 182 of file test_alert_manager.cpp.

                                              {
    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() [23/35]

TEST_F	(	AlertManagerRuleTest	,
		GetNonexistentRuleReturnsNull	)

Definition at line 191 of file test_alert_manager.cpp.

                                                            {
    auto retrieved = manager_.get_rule("missing");
    EXPECT_EQ(retrieved, nullptr);
}

TEST_F() [24/35]

TEST_F	(	AlertManagerRuleTest	,
		GetRulesEmpty	)

Definition at line 217 of file test_alert_manager.cpp.

                                            {
    auto rules = manager_.get_rules();
    EXPECT_TRUE(rules.empty());
}

TEST_F() [25/35]

TEST_F	(	AlertManagerRuleTest	,
		RemoveExistingRule	)

Definition at line 196 of file test_alert_manager.cpp.

                                                 {
    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() [26/35]

TEST_F	(	AlertManagerRuleTest	,
		RemoveNonexistentRuleFails	)

Definition at line 203 of file test_alert_manager.cpp.

                                                         {
    auto result = manager_.remove_rule("missing");
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [27/35]

TEST_F	(	AlertManagerSilenceTest	,
		CreateSilence	)

Definition at line 485 of file test_alert_manager.cpp.

                                               {
    alert_silence silence;
    silence.matchers.set("service", "api");
    silence.comment = "Maintenance window";
 
    auto result = manager_.create_silence(silence);
    EXPECT_TRUE(result.is_ok());
}

References kcenon::monitoring::alert_silence::comment, kcenon::monitoring::alert_silence::matchers, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [28/35]

TEST_F	(	AlertManagerSilenceTest	,
		CreateSilenceReturnsId	)

Definition at line 494 of file test_alert_manager.cpp.

                                                        {
    alert_silence silence;
    silence.id = 42;
    auto result = manager_.create_silence(silence);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 42u);
}

References kcenon::monitoring::alert_silence::id.

TEST_F() [29/35]

TEST_F	(	AlertManagerSilenceTest	,
		DeleteNonexistentSilence	)

Definition at line 511 of file test_alert_manager.cpp.

                                                          {
    auto result = manager_.delete_silence(99999);
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [30/35]

TEST_F	(	AlertManagerSilenceTest	,
		DeleteSilence	)

Definition at line 502 of file test_alert_manager.cpp.

                                               {
    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() [31/35]

TEST_F	(	AlertManagerSilenceTest	,
		GetSilences	)

Definition at line 516 of file test_alert_manager.cpp.

                                             {
    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);
}

References kcenon::monitoring::alert_silence::matchers, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [32/35]

TEST_F	(	AlertManagerSilenceTest	,
		GetSilencesEmpty	)

Definition at line 529 of file test_alert_manager.cpp.

                                                  {
    auto silences = manager_.get_silences();
    EXPECT_TRUE(silences.empty());
}

TEST_F() [33/35]

TEST_F	(	AlertManagerSilenceTest	,
		IsNotSilencedNonMatchingAlert	)

Definition at line 544 of file test_alert_manager.cpp.

                                                               {
    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));
}

References kcenon::monitoring::alert::labels, kcenon::monitoring::alert_silence::matchers, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [34/35]

TEST_F	(	AlertManagerSilenceTest	,
		IsNotSilencedNoSilences	)

Definition at line 554 of file test_alert_manager.cpp.

                                                         {
    alert a;
    a.labels.set("service", "api");
    EXPECT_FALSE(manager_.is_silenced(a));
}

References kcenon::monitoring::alert::labels, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [35/35]

TEST_F	(	AlertManagerSilenceTest	,
		IsSilencedMatchingAlert	)

Definition at line 534 of file test_alert_manager.cpp.

                                                         {
    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));
}

References kcenon::monitoring::alert::labels, kcenon::monitoring::alert_silence::matchers, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function: