test_alert_types.cpp File Reference

#include <gtest/gtest.h>
#include <kcenon/monitoring/alert/alert_types.h>
#include <chrono>
#include <thread>

Include dependency graph for test_alert_types.cpp:

Go to the source code of this file.

Classes
class	AlertLabelsTest
class	AlertTest
class	AlertTransitionTest
class	AlertGroupTest
class	AlertSilenceTest

Functions
	TEST (AlertSeverityTest, ToStringConversions)
	TEST (AlertSeverityTest, OrderingByValue)
	TEST (AlertStateTest, ToStringConversions)
	TEST_F (AlertLabelsTest, DefaultConstructionIsEmpty)
	TEST_F (AlertLabelsTest, ConstructFromMap)
	TEST_F (AlertLabelsTest, SetAndGet)
	TEST_F (AlertLabelsTest, GetNonexistentReturnsEmpty)
	TEST_F (AlertLabelsTest, HasExistingKey)
	TEST_F (AlertLabelsTest, SetOverwritesExisting)
	TEST_F (AlertLabelsTest, FingerprintIsDeterministic)
	TEST_F (AlertLabelsTest, FingerprintDiffersForDifferentValues)
	TEST_F (AlertLabelsTest, EqualityOperator)
	TEST_F (AlertLabelsTest, InequalityWhenDifferent)
	TEST (AlertAnnotationsTest, DefaultConstruction)
	TEST (AlertAnnotationsTest, ConstructWithSummaryAndDescription)
	TEST (AlertAnnotationsTest, RunbookUrl)
	TEST (AlertAnnotationsTest, CustomAnnotations)
	TEST_F (AlertTest, DefaultConstruction)
	TEST_F (AlertTest, ConstructWithNameAndLabels)
	TEST_F (AlertTest, UniqueIds)
	TEST_F (AlertTest, FingerprintIncludesNameAndLabels)
	TEST_F (AlertTest, FingerprintConsistency)
	TEST_F (AlertTest, IsActiveForPendingAndFiring)
	TEST_F (AlertTest, StateDurationIsPositive)
	TEST_F (AlertTest, FiringDurationZeroWhenNotFiring)
	TEST_F (AlertTransitionTest, InactiveToLending)
	TEST_F (AlertTransitionTest, InactiveToFiringInvalid)
	TEST_F (AlertTransitionTest, InactiveToResolvedInvalid)
	TEST_F (AlertTransitionTest, PendingToFiring)
	TEST_F (AlertTransitionTest, PendingToInactive)
	TEST_F (AlertTransitionTest, FiringToResolved)
	TEST_F (AlertTransitionTest, FiringToPendingInvalid)
	TEST_F (AlertTransitionTest, ResolvedToPending)
	TEST_F (AlertTransitionTest, ResolvedToInactive)
	TEST_F (AlertTransitionTest, AnyStateToSuppressed)
	TEST_F (AlertTransitionTest, SuppressedToAnyState)
	TEST_F (AlertTransitionTest, FullLifecycle)
	TEST_F (AlertTransitionTest, FiringStartedAtSetOnlyOnce)
	TEST_F (AlertTransitionTest, UpdatedAtChangesOnTransition)
	TEST_F (AlertGroupTest, DefaultConstruction)
	TEST_F (AlertGroupTest, ConstructWithKey)
	TEST_F (AlertGroupTest, AddAlert)
	TEST_F (AlertGroupTest, AddMultipleAlerts)
	TEST_F (AlertGroupTest, MaxSeverityEmptyGroup)
	TEST_F (AlertGroupTest, MaxSeveritySingleAlert)
	TEST_F (AlertGroupTest, MaxSeverityMultipleAlerts)
	TEST_F (AlertGroupTest, UpdatedAtChangesOnAdd)
	TEST_F (AlertSilenceTest, DefaultConstructionIsActive)
	TEST_F (AlertSilenceTest, UniqueIds)
	TEST_F (AlertSilenceTest, ExpiredSilenceNotActive)
	TEST_F (AlertSilenceTest, FutureSilenceNotActive)
	TEST_F (AlertSilenceTest, MatchesAlertWithMatchingLabels)
	TEST_F (AlertSilenceTest, DoesNotMatchAlertWithDifferentLabels)
	TEST_F (AlertSilenceTest, DoesNotMatchAlertMissingLabel)
	TEST_F (AlertSilenceTest, EmptyMatchersMatchesAll)
	TEST_F (AlertSilenceTest, ExpiredSilenceDoesNotMatch)
	TEST_F (AlertSilenceTest, MultipleMatchersMustAllMatch)
	TEST_F (AlertSilenceTest, CommentAndCreatedBy)

Function Documentation

TEST() [1/7]

TEST	(	AlertAnnotationsTest	,
		ConstructWithSummaryAndDescription	)

Definition at line 157 of file test_alert_types.cpp.

                                                               {
    alert_annotations ann("High CPU", "CPU usage exceeded 80%");
    EXPECT_EQ(ann.summary, "High CPU");
    EXPECT_EQ(ann.description, "CPU usage exceeded 80%");
}

References kcenon::monitoring::alert_annotations::description, and kcenon::monitoring::alert_annotations::summary.

TEST() [2/7]

TEST	(	AlertAnnotationsTest	,
		CustomAnnotations	)

Definition at line 170 of file test_alert_types.cpp.

                                              {
    alert_annotations ann;
    ann.custom["dashboard"] = "grafana/cpu";
    EXPECT_EQ(ann.custom.at("dashboard"), "grafana/cpu");
}

References kcenon::monitoring::alert_annotations::custom.

TEST() [3/7]

TEST	(	AlertAnnotationsTest	,
		DefaultConstruction	)

Definition at line 149 of file test_alert_types.cpp.

                                                {
    alert_annotations ann;
    EXPECT_TRUE(ann.summary.empty());
    EXPECT_TRUE(ann.description.empty());
    EXPECT_FALSE(ann.runbook_url.has_value());
    EXPECT_TRUE(ann.custom.empty());
}

References kcenon::monitoring::alert_annotations::custom, kcenon::monitoring::alert_annotations::description, kcenon::monitoring::alert_annotations::runbook_url, and kcenon::monitoring::alert_annotations::summary.

TEST() [4/7]

TEST	(	AlertAnnotationsTest	,
		RunbookUrl	)

Definition at line 163 of file test_alert_types.cpp.

                                       {
    alert_annotations ann;
    ann.runbook_url = "https://runbooks.example.com/cpu";
    EXPECT_TRUE(ann.runbook_url.has_value());
    EXPECT_EQ(*ann.runbook_url, "https://runbooks.example.com/cpu");
}

References kcenon::monitoring::alert_annotations::runbook_url.

TEST() [5/7]

TEST	(	AlertSeverityTest	,
		OrderingByValue	)

Definition at line 37 of file test_alert_types.cpp.

                                         {
    EXPECT_LT(static_cast<uint8_t>(alert_severity::info),
              static_cast<uint8_t>(alert_severity::warning));
    EXPECT_LT(static_cast<uint8_t>(alert_severity::warning),
              static_cast<uint8_t>(alert_severity::critical));
    EXPECT_LT(static_cast<uint8_t>(alert_severity::critical),
              static_cast<uint8_t>(alert_severity::emergency));
}

TEST() [6/7]

TEST	(	AlertSeverityTest	,
		ToStringConversions	)

Definition at line 30 of file test_alert_types.cpp.

                                             {
    EXPECT_STREQ(alert_severity_to_string(alert_severity::info), "info");
    EXPECT_STREQ(alert_severity_to_string(alert_severity::warning), "warning");
    EXPECT_STREQ(alert_severity_to_string(alert_severity::critical), "critical");
    EXPECT_STREQ(alert_severity_to_string(alert_severity::emergency), "emergency");
}

References kcenon::monitoring::alert_severity_to_string().

Here is the call graph for this function:

TEST() [7/7]

TEST	(	AlertStateTest	,
		ToStringConversions	)

Definition at line 50 of file test_alert_types.cpp.

                                          {
    EXPECT_STREQ(alert_state_to_string(alert_state::inactive), "inactive");
    EXPECT_STREQ(alert_state_to_string(alert_state::pending), "pending");
    EXPECT_STREQ(alert_state_to_string(alert_state::firing), "firing");
    EXPECT_STREQ(alert_state_to_string(alert_state::resolved), "resolved");
    EXPECT_STREQ(alert_state_to_string(alert_state::suppressed), "suppressed");
}

References kcenon::monitoring::alert_state_to_string().

Here is the call graph for this function:

TEST_F() [1/51]

TEST_F	(	AlertGroupTest	,
		AddAlert	)

Definition at line 392 of file test_alert_types.cpp.

                                 {
    alert a("test", alert_labels{});
    group_.add_alert(a);
    EXPECT_EQ(group_.size(), 1u);
    EXPECT_FALSE(group_.empty());
}

TEST_F() [2/51]

TEST_F	(	AlertGroupTest	,
		AddMultipleAlerts	)

Definition at line 399 of file test_alert_types.cpp.

                                          {
    for (int i = 0; i < 5; ++i) {
        alert a("alert_" + std::to_string(i), alert_labels{});
        group_.add_alert(a);
    }
    EXPECT_EQ(group_.size(), 5u);
}

TEST_F() [3/51]

TEST_F	(	AlertGroupTest	,
		ConstructWithKey	)

Definition at line 387 of file test_alert_types.cpp.

                                         {
    EXPECT_EQ(group_.group_key, "test_group");
    EXPECT_TRUE(group_.empty());
}

TEST_F() [4/51]

TEST_F	(	AlertGroupTest	,
		DefaultConstruction	)

Definition at line 380 of file test_alert_types.cpp.

                                            {
    alert_group g;
    EXPECT_TRUE(g.group_key.empty());
    EXPECT_TRUE(g.empty());
    EXPECT_EQ(g.size(), 0u);
}

References kcenon::monitoring::alert_group::empty(), kcenon::monitoring::alert_group::group_key, and kcenon::monitoring::alert_group::size().

Here is the call graph for this function:

TEST_F() [5/51]

TEST_F	(	AlertGroupTest	,
		MaxSeverityEmptyGroup	)

Definition at line 407 of file test_alert_types.cpp.

                                              {
    EXPECT_EQ(group_.max_severity(), alert_severity::info);
}

TEST_F() [6/51]

TEST_F	(	AlertGroupTest	,
		MaxSeverityMultipleAlerts	)

Definition at line 418 of file test_alert_types.cpp.

                                                  {
    alert a1;
    a1.severity = alert_severity::info;
    group_.add_alert(a1);
 
    alert a2;
    a2.severity = alert_severity::emergency;
    group_.add_alert(a2);
 
    alert a3;
    a3.severity = alert_severity::warning;
    group_.add_alert(a3);
 
    EXPECT_EQ(group_.max_severity(), alert_severity::emergency);
}

References kcenon::monitoring::alert::severity.

TEST_F() [7/51]

TEST_F	(	AlertGroupTest	,
		MaxSeveritySingleAlert	)

Definition at line 411 of file test_alert_types.cpp.

                                               {
    alert a;
    a.severity = alert_severity::critical;
    group_.add_alert(a);
    EXPECT_EQ(group_.max_severity(), alert_severity::critical);
}

References kcenon::monitoring::alert::severity.

TEST_F() [8/51]

TEST_F	(	AlertGroupTest	,
		UpdatedAtChangesOnAdd	)

Definition at line 434 of file test_alert_types.cpp.

                                              {
    auto initial = group_.updated_at;
    std::this_thread::sleep_for(1ms);
    alert a;
    group_.add_alert(a);
    EXPECT_GT(group_.updated_at, initial);
}

TEST_F() [9/51]

TEST_F	(	AlertLabelsTest	,
		ConstructFromMap	)

Definition at line 71 of file test_alert_types.cpp.

                                          {
    std::unordered_map<std::string, std::string> map{
        {"env", "production"}, {"service", "api"}};
    alert_labels lbl(map);
    EXPECT_EQ(lbl.labels.size(), 2u);
    EXPECT_EQ(lbl.get("env"), "production");
}

References kcenon::monitoring::alert_labels::get(), and kcenon::monitoring::alert_labels::labels.

Here is the call graph for this function:

TEST_F() [10/51]

TEST_F	(	AlertLabelsTest	,
		DefaultConstructionIsEmpty	)

Definition at line 67 of file test_alert_types.cpp.

                                                    {
    EXPECT_TRUE(labels_.labels.empty());
}

TEST_F() [11/51]

TEST_F	(	AlertLabelsTest	,
		EqualityOperator	)

Definition at line 125 of file test_alert_types.cpp.

                                          {
    labels_.set("a", "1");
    labels_.set("b", "2");
 
    alert_labels other;
    other.set("a", "1");
    other.set("b", "2");
 
    EXPECT_EQ(labels_, other);
}

References kcenon::monitoring::other, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [12/51]

TEST_F	(	AlertLabelsTest	,
		FingerprintDiffersForDifferentValues	)

Definition at line 114 of file test_alert_types.cpp.

                                                              {
    labels_.set("key", "value1");
    auto fp1 = labels_.fingerprint();
 
    alert_labels other;
    other.set("key", "value2");
    auto fp2 = other.fingerprint();
 
    EXPECT_NE(fp1, fp2);
}

References kcenon::monitoring::other, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [13/51]

TEST_F	(	AlertLabelsTest	,
		FingerprintIsDeterministic	)

Definition at line 100 of file test_alert_types.cpp.

                                                    {
    labels_.set("b", "2");
    labels_.set("a", "1");
    auto fp1 = labels_.fingerprint();
 
    alert_labels other;
    other.set("a", "1");
    other.set("b", "2");
    auto fp2 = other.fingerprint();
 
    // Sorted order: a=1,b=2, regardless of insertion order
    EXPECT_EQ(fp1, fp2);
}

References kcenon::monitoring::other, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [14/51]

TEST_F	(	AlertLabelsTest	,
		GetNonexistentReturnsEmpty	)

Definition at line 84 of file test_alert_types.cpp.

                                                    {
    EXPECT_EQ(labels_.get("missing"), "");
}

TEST_F() [15/51]

TEST_F	(	AlertLabelsTest	,
		HasExistingKey	)

Definition at line 88 of file test_alert_types.cpp.

                                        {
    labels_.set("region", "us-east");
    EXPECT_TRUE(labels_.has("region"));
    EXPECT_FALSE(labels_.has("zone"));
}

TEST_F() [16/51]

TEST_F	(	AlertLabelsTest	,
		InequalityWhenDifferent	)

Definition at line 136 of file test_alert_types.cpp.

                                                 {
    labels_.set("a", "1");
 
    alert_labels other;
    other.set("a", "2");
 
    EXPECT_FALSE(labels_ == other);
}

References kcenon::monitoring::other, and kcenon::monitoring::alert_labels::set().

Here is the call graph for this function:

TEST_F() [17/51]

TEST_F	(	AlertLabelsTest	,
		SetAndGet	)

Definition at line 79 of file test_alert_types.cpp.

                                   {
    labels_.set("team", "infra");
    EXPECT_EQ(labels_.get("team"), "infra");
}

TEST_F() [18/51]

TEST_F	(	AlertLabelsTest	,
		SetOverwritesExisting	)

Definition at line 94 of file test_alert_types.cpp.

                                               {
    labels_.set("env", "staging");
    labels_.set("env", "production");
    EXPECT_EQ(labels_.get("env"), "production");
}

TEST_F() [19/51]

TEST_F	(	AlertSilenceTest	,
		CommentAndCreatedBy	)

Definition at line 535 of file test_alert_types.cpp.

                                              {
    silence_.comment = "Maintenance window";
    silence_.created_by = "admin@example.com";
    EXPECT_EQ(silence_.comment, "Maintenance window");
    EXPECT_EQ(silence_.created_by, "admin@example.com");
}

TEST_F() [20/51]

TEST_F	(	AlertSilenceTest	,
		DefaultConstructionIsActive	)

Definition at line 451 of file test_alert_types.cpp.

                                                      {
    // Default: starts_at = now, ends_at = now + 1 hour
    EXPECT_TRUE(silence_.is_active());
}

TEST_F() [21/51]

TEST_F	(	AlertSilenceTest	,
		DoesNotMatchAlertMissingLabel	)

Definition at line 493 of file test_alert_types.cpp.

                                                        {
    silence_.matchers.set("service", "api");
 
    alert a;
    a.labels.set("env", "prod");
 
    EXPECT_FALSE(silence_.matches(a));
}

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

Here is the call graph for this function:

TEST_F() [22/51]

TEST_F	(	AlertSilenceTest	,
		DoesNotMatchAlertWithDifferentLabels	)

Definition at line 484 of file test_alert_types.cpp.

                                                               {
    silence_.matchers.set("service", "api");
 
    alert a;
    a.labels.set("service", "web");
 
    EXPECT_FALSE(silence_.matches(a));
}

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

Here is the call graph for this function:

TEST_F() [23/51]

TEST_F	(	AlertSilenceTest	,
		EmptyMatchersMatchesAll	)

Definition at line 502 of file test_alert_types.cpp.

                                                  {
    // No matcher labels means all alerts match
    alert a;
    a.labels.set("anything", "value");
    EXPECT_TRUE(silence_.matches(a));
}

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

Here is the call graph for this function:

TEST_F() [24/51]

TEST_F	(	AlertSilenceTest	,
		ExpiredSilenceDoesNotMatch	)

Definition at line 509 of file test_alert_types.cpp.

                                                     {
    silence_.matchers.set("service", "api");
    silence_.starts_at = std::chrono::steady_clock::now() - 2h;
    silence_.ends_at = std::chrono::steady_clock::now() - 1h;
 
    alert a;
    a.labels.set("service", "api");
 
    EXPECT_FALSE(silence_.matches(a));
}

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

Here is the call graph for this function:

TEST_F() [25/51]

TEST_F	(	AlertSilenceTest	,
		ExpiredSilenceNotActive	)

Definition at line 462 of file test_alert_types.cpp.

                                                  {
    silence_.starts_at = std::chrono::steady_clock::now() - 2h;
    silence_.ends_at = std::chrono::steady_clock::now() - 1h;
    EXPECT_FALSE(silence_.is_active());
}

TEST_F() [26/51]

TEST_F	(	AlertSilenceTest	,
		FutureSilenceNotActive	)

Definition at line 468 of file test_alert_types.cpp.

                                                 {
    silence_.starts_at = std::chrono::steady_clock::now() + 1h;
    silence_.ends_at = std::chrono::steady_clock::now() + 2h;
    EXPECT_FALSE(silence_.is_active());
}

TEST_F() [27/51]

TEST_F	(	AlertSilenceTest	,
		MatchesAlertWithMatchingLabels	)

Definition at line 474 of file test_alert_types.cpp.

                                                         {
    silence_.matchers.set("service", "api");
 
    alert a;
    a.labels.set("service", "api");
    a.labels.set("env", "prod");
 
    EXPECT_TRUE(silence_.matches(a));
}

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

Here is the call graph for this function:

TEST_F() [28/51]

TEST_F	(	AlertSilenceTest	,
		MultipleMatchersMustAllMatch	)

Definition at line 520 of file test_alert_types.cpp.

                                                       {
    silence_.matchers.set("service", "api");
    silence_.matchers.set("env", "prod");
 
    alert a1;
    a1.labels.set("service", "api");
    a1.labels.set("env", "prod");
    EXPECT_TRUE(silence_.matches(a1));
 
    alert a2;
    a2.labels.set("service", "api");
    a2.labels.set("env", "staging");
    EXPECT_FALSE(silence_.matches(a2));
}

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

Here is the call graph for this function:

TEST_F() [29/51]

TEST_F	(	AlertSilenceTest	,
		UniqueIds	)

Definition at line 456 of file test_alert_types.cpp.

                                    {
    alert_silence s1;
    alert_silence s2;
    EXPECT_NE(s1.id, s2.id);
}

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

TEST_F() [30/51]

TEST_F	(	AlertTest	,
		ConstructWithNameAndLabels	)

Definition at line 203 of file test_alert_types.cpp.

                                              {
    auto a = create_test_alert();
    EXPECT_EQ(a.name, "high_cpu");
    EXPECT_EQ(a.labels.get("service"), "api");
    EXPECT_EQ(a.severity, alert_severity::critical);
}

TEST_F() [31/51]

TEST_F	(	AlertTest	,
		DefaultConstruction	)

Definition at line 193 of file test_alert_types.cpp.

                                       {
    alert a;
    EXPECT_TRUE(a.name.empty());
    EXPECT_EQ(a.state, alert_state::inactive);
    EXPECT_EQ(a.severity, alert_severity::warning);
    EXPECT_EQ(a.value, 0.0);
    EXPECT_FALSE(a.started_at.has_value());
    EXPECT_FALSE(a.resolved_at.has_value());
}

References kcenon::monitoring::alert::name, kcenon::monitoring::alert::resolved_at, kcenon::monitoring::alert::severity, kcenon::monitoring::alert::started_at, kcenon::monitoring::alert::state, and kcenon::monitoring::alert::value.

TEST_F() [32/51]

TEST_F	(	AlertTest	,
		FingerprintConsistency	)

Definition at line 223 of file test_alert_types.cpp.

                                          {
    auto a1 = create_test_alert();
    auto a2 = create_test_alert();
    // Same name + same labels = same fingerprint (for dedup)
    EXPECT_EQ(a1.fingerprint(), a2.fingerprint());
}

TEST_F() [33/51]

TEST_F	(	AlertTest	,
		FingerprintIncludesNameAndLabels	)

Definition at line 216 of file test_alert_types.cpp.

                                                    {
    auto a = create_test_alert();
    auto fp = a.fingerprint();
    EXPECT_FALSE(fp.empty());
    EXPECT_NE(fp.find("high_cpu"), std::string::npos);
}

TEST_F() [34/51]

TEST_F	(	AlertTest	,
		FiringDurationZeroWhenNotFiring	)

Definition at line 255 of file test_alert_types.cpp.

                                                   {
    alert a;
    EXPECT_EQ(a.firing_duration().count(), 0);
}

References kcenon::monitoring::alert::firing_duration().

Here is the call graph for this function:

TEST_F() [35/51]

TEST_F	(	AlertTest	,
		IsActiveForPendingAndFiring	)

Definition at line 230 of file test_alert_types.cpp.

                                               {
    alert a;
    EXPECT_FALSE(a.is_active()); // inactive
 
    a.state = alert_state::pending;
    EXPECT_TRUE(a.is_active());
 
    a.state = alert_state::firing;
    EXPECT_TRUE(a.is_active());
 
    a.state = alert_state::resolved;
    EXPECT_FALSE(a.is_active());
 
    a.state = alert_state::suppressed;
    EXPECT_FALSE(a.is_active());
}

References kcenon::monitoring::alert::is_active(), and kcenon::monitoring::alert::state.

Here is the call graph for this function:

TEST_F() [36/51]

TEST_F	(	AlertTest	,
		StateDurationIsPositive	)

Definition at line 247 of file test_alert_types.cpp.

                                           {
    alert a;
    // Sleep briefly to ensure non-zero duration
    std::this_thread::sleep_for(1ms);
    auto dur = a.state_duration();
    EXPECT_GT(dur.count(), 0);
}

References kcenon::monitoring::alert::state_duration().

Here is the call graph for this function:

TEST_F() [37/51]

TEST_F	(	AlertTest	,
		UniqueIds	)

Definition at line 210 of file test_alert_types.cpp.

                             {
    alert a1;
    alert a2;
    EXPECT_NE(a1.id, a2.id);
}

References kcenon::monitoring::alert::id.

TEST_F() [38/51]

TEST_F	(	AlertTransitionTest	,
		AnyStateToSuppressed	)

Definition at line 327 of file test_alert_types.cpp.

                                                  {
    EXPECT_TRUE(a_.transition_to(alert_state::suppressed));
    EXPECT_EQ(a_.state, alert_state::suppressed);
}

TEST_F() [39/51]

TEST_F	(	AlertTransitionTest	,
		FiringStartedAtSetOnlyOnce	)

Definition at line 350 of file test_alert_types.cpp.

                                                        {
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
    auto first_started = a_.started_at;
 
    // Resolve and re-fire
    a_.transition_to(alert_state::resolved);
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
 
    // started_at should remain the same (first firing)
    EXPECT_EQ(a_.started_at, first_started);
}

TEST_F() [40/51]

TEST_F	(	AlertTransitionTest	,
		FiringToPendingInvalid	)

Definition at line 305 of file test_alert_types.cpp.

                                                    {
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
    EXPECT_FALSE(a_.transition_to(alert_state::pending));
    EXPECT_EQ(a_.state, alert_state::firing);
}

TEST_F() [41/51]

TEST_F	(	AlertTransitionTest	,
		FiringToResolved	)

Definition at line 297 of file test_alert_types.cpp.

                                              {
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
    EXPECT_TRUE(a_.transition_to(alert_state::resolved));
    EXPECT_EQ(a_.state, alert_state::resolved);
    EXPECT_TRUE(a_.resolved_at.has_value());
}

TEST_F() [42/51]

TEST_F	(	AlertTransitionTest	,
		FullLifecycle	)

Definition at line 340 of file test_alert_types.cpp.

                                           {
    // inactive -> pending -> firing -> resolved -> pending -> firing -> resolved
    EXPECT_TRUE(a_.transition_to(alert_state::pending));
    EXPECT_TRUE(a_.transition_to(alert_state::firing));
    EXPECT_TRUE(a_.transition_to(alert_state::resolved));
    EXPECT_TRUE(a_.transition_to(alert_state::pending));
    EXPECT_TRUE(a_.transition_to(alert_state::firing));
    EXPECT_TRUE(a_.transition_to(alert_state::resolved));
}

TEST_F() [43/51]

TEST_F	(	AlertTransitionTest	,
		InactiveToFiringInvalid	)

Definition at line 274 of file test_alert_types.cpp.

                                                     {
    EXPECT_FALSE(a_.transition_to(alert_state::firing));
    EXPECT_EQ(a_.state, alert_state::inactive);
}

TEST_F() [44/51]

TEST_F	(	AlertTransitionTest	,
		InactiveToLending	)

Definition at line 269 of file test_alert_types.cpp.

                                               {
    EXPECT_TRUE(a_.transition_to(alert_state::pending));
    EXPECT_EQ(a_.state, alert_state::pending);
}

TEST_F() [45/51]

TEST_F	(	AlertTransitionTest	,
		InactiveToResolvedInvalid	)

Definition at line 279 of file test_alert_types.cpp.

                                                       {
    EXPECT_FALSE(a_.transition_to(alert_state::resolved));
    EXPECT_EQ(a_.state, alert_state::inactive);
}

TEST_F() [46/51]

TEST_F	(	AlertTransitionTest	,
		PendingToFiring	)

Definition at line 284 of file test_alert_types.cpp.

                                             {
    a_.transition_to(alert_state::pending);
    EXPECT_TRUE(a_.transition_to(alert_state::firing));
    EXPECT_EQ(a_.state, alert_state::firing);
    EXPECT_TRUE(a_.started_at.has_value());
}

TEST_F() [47/51]

TEST_F	(	AlertTransitionTest	,
		PendingToInactive	)

Definition at line 291 of file test_alert_types.cpp.

                                               {
    a_.transition_to(alert_state::pending);
    EXPECT_TRUE(a_.transition_to(alert_state::inactive));
    EXPECT_EQ(a_.state, alert_state::inactive);
}

TEST_F() [48/51]

TEST_F	(	AlertTransitionTest	,
		ResolvedToInactive	)

Definition at line 320 of file test_alert_types.cpp.

                                                {
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
    a_.transition_to(alert_state::resolved);
    EXPECT_TRUE(a_.transition_to(alert_state::inactive));
}

TEST_F() [49/51]

TEST_F	(	AlertTransitionTest	,
		ResolvedToPending	)

Definition at line 312 of file test_alert_types.cpp.

                                               {
    a_.transition_to(alert_state::pending);
    a_.transition_to(alert_state::firing);
    a_.transition_to(alert_state::resolved);
    EXPECT_TRUE(a_.transition_to(alert_state::pending));
    EXPECT_EQ(a_.state, alert_state::pending);
}

TEST_F() [50/51]

TEST_F	(	AlertTransitionTest	,
		SuppressedToAnyState	)

Definition at line 332 of file test_alert_types.cpp.

                                                  {
    a_.transition_to(alert_state::suppressed);
 
    // From suppressed, all transitions should be valid
    EXPECT_TRUE(a_.transition_to(alert_state::firing));
    EXPECT_EQ(a_.state, alert_state::firing);
}

TEST_F() [51/51]

TEST_F	(	AlertTransitionTest	,
		UpdatedAtChangesOnTransition	)

Definition at line 364 of file test_alert_types.cpp.

                                                          {
    auto initial_updated = a_.updated_at;
    std::this_thread::sleep_for(1ms);
    a_.transition_to(alert_state::pending);
    EXPECT_GT(a_.updated_at, initial_updated);
}