test_fault_tolerance.cpp File Reference

#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <kcenon/monitoring/reliability/circuit_breaker.h>
#include <kcenon/monitoring/reliability/retry_policy.h>
#include <kcenon/monitoring/reliability/fault_tolerance_manager.h>

Include dependency graph for test_fault_tolerance.cpp:

Go to the source code of this file.

Classes
class	FaultToleranceTest

Functions
	TEST_F (FaultToleranceTest, CircuitBreakerClosedState)
	TEST_F (FaultToleranceTest, CircuitBreakerOpensAfterFailures)
	TEST_F (FaultToleranceTest, CircuitBreakerHalfOpenTransition)
	TEST_F (FaultToleranceTest, CircuitBreakerHalfOpenToClosedTransition)
	TEST_F (FaultToleranceTest, CircuitBreakerWithFallback)
	TEST_F (FaultToleranceTest, CircuitBreakerStats)
	TEST_F (FaultToleranceTest, RetryExecutorBasicRetry)
	TEST_F (FaultToleranceTest, RetryExecutorMaxAttemptsExceeded)
	TEST_F (FaultToleranceTest, RetryExecutorFixedDelay)
	TEST_F (FaultToleranceTest, RetryExecutorFibonacciBackoff)
	TEST_F (FaultToleranceTest, RetryExecutorCustomShouldRetry)
	TEST_F (FaultToleranceTest, FaultToleranceManagerCircuitBreakerFirst)
	TEST_F (FaultToleranceTest, FaultToleranceManagerRetryFirst)
	TEST_F (FaultToleranceTest, FaultToleranceManagerOnlyCircuitBreaker)
	TEST_F (FaultToleranceTest, FaultToleranceManagerOnlyRetry)
	TEST_F (FaultToleranceTest, FaultToleranceManagerWithTimeout)
	TEST_F (FaultToleranceTest, FaultToleranceManagerMetrics)
	TEST_F (FaultToleranceTest, FaultToleranceManagerHealthCheck)
	TEST_F (FaultToleranceTest, CircuitBreakerRegistry)
	TEST_F (FaultToleranceTest, RetryExecutorRegistry)
	TEST_F (FaultToleranceTest, FaultToleranceRegistry)
	TEST_F (FaultToleranceTest, RetryConfigValidation)
	TEST_F (FaultToleranceTest, FaultToleranceConfigValidation)
	TEST_F (FaultToleranceTest, CircuitBreakerConcurrency)
	TEST_F (FaultToleranceTest, CircuitBreakerResetViaRecreation)
	TEST_F (FaultToleranceTest, RetryExecutorResetMetrics)

Function Documentation

TEST_F() [1/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerClosedState	)

Definition at line 63 of file test_fault_tolerance.cpp.

                                                      {
    circuit_breaker_config config;
    config.failure_threshold = 3;
 
    circuit_breaker breaker(config);
 
    EXPECT_EQ(breaker.get_state(), circuit_state::CLOSED);
 
    auto result = execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 100);
    EXPECT_EQ(breaker.get_state(), circuit_state::CLOSED);
    EXPECT_EQ(call_count.load(), 1);
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [2/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerConcurrency	)

Definition at line 477 of file test_fault_tolerance.cpp.

                                                      {
    circuit_breaker_config config;
    config.failure_threshold = 10;
 
    circuit_breaker breaker(config);
 
    constexpr int num_threads = 4;
    constexpr int operations_per_thread = 100;
 
    std::vector<std::thread> threads;
    std::atomic<int> successful_operations{0};
 
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([&breaker, &successful_operations, operations_per_thread]() {
            for (int j = 0; j < operations_per_thread; ++j) {
                auto result = execute_with_circuit_breaker<int>(breaker, "test", []() { return kcenon::common::ok(1); });
                if (result.is_ok()) {
                    successful_operations++;
                }
            }
        });
    }
 
    for (auto& thread : threads) {
        thread.join();
    }
 
    EXPECT_EQ(successful_operations.load(), num_threads * operations_per_thread);
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [3/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerHalfOpenToClosedTransition	)

Definition at line 122 of file test_fault_tolerance.cpp.

                                                                     {
    circuit_breaker_config config;
    config.failure_threshold = 2;
    config.success_threshold = 2;
    config.timeout = std::chrono::milliseconds(50);
 
    circuit_breaker breaker(config);
 
    // Open the circuit
    for (int i = 0; i < 2; ++i) {
        execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
    }
 
    // Wait and transition to half-open
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
    EXPECT_EQ(breaker.get_state(), circuit_state::HALF_OPEN);
 
    // One more success should close the circuit
    auto result = execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(breaker.get_state(), circuit_state::CLOSED);
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [4/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerHalfOpenTransition	)

Definition at line 100 of file test_fault_tolerance.cpp.

                                                             {
    circuit_breaker_config config;
    config.failure_threshold = 2;
    config.timeout = std::chrono::milliseconds(100);
 
    circuit_breaker breaker(config);
 
    // Open the circuit
    for (int i = 0; i < 2; ++i) {
        execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
    }
    EXPECT_EQ(breaker.get_state(), circuit_state::OPEN);
 
    // Wait for reset timeout
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
 
    // Next call should transition to half-open
    auto result = execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(breaker.get_state(), circuit_state::HALF_OPEN);
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [5/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerOpensAfterFailures	)

Definition at line 78 of file test_fault_tolerance.cpp.

                                                             {
    circuit_breaker_config config;
    config.failure_threshold = 3;
 
    circuit_breaker breaker(config);
 
    // First 3 failures should open the circuit
    for (int i = 0; i < 3; ++i) {
        auto result = execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
        EXPECT_TRUE(result.is_err());
    }
 
    EXPECT_EQ(breaker.get_state(), circuit_state::OPEN);
    EXPECT_EQ(call_count.load(), 3);
 
    // Next call should be rejected without calling operation
    auto result = execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(call_count.load(), 3); // Should not increment
    EXPECT_EQ(result.error().code, static_cast<int>(monitoring_error_code::circuit_breaker_open));
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [6/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerRegistry	)

Definition at line 386 of file test_fault_tolerance.cpp.

                                                   {
    auto& registry = global_circuit_breaker_registry();
 
    auto breaker = std::make_shared<circuit_breaker>();
    registry.register_circuit_breaker("test", breaker);
 
    auto retrieved = registry.get_circuit_breaker("test");
    EXPECT_EQ(retrieved, breaker);
 
    auto names = registry.get_all_names();
    EXPECT_EQ(names.size(), 1);
    EXPECT_EQ(names[0], "test");
 
    registry.remove_circuit_breaker("test");
    retrieved = registry.get_circuit_breaker("test");
    EXPECT_EQ(retrieved, nullptr);
}

References kcenon::monitoring::global_circuit_breaker_registry().

Here is the call graph for this function:

TEST_F() [7/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerResetViaRecreation	)

Definition at line 508 of file test_fault_tolerance.cpp.

                                                             {
    circuit_breaker_config config;
    config.failure_threshold = 2;
 
    auto breaker = std::make_unique<circuit_breaker>(config);
 
    // Open the circuit
    for (int i = 0; i < 2; ++i) {
        execute_with_circuit_breaker<int>(*breaker, "test", [this]() { return always_failing_operation(); });
    }
    EXPECT_EQ(breaker->get_state(), circuit_state::OPEN);
 
    // Reset by recreating
    breaker = std::make_unique<circuit_breaker>(config);
    EXPECT_EQ(breaker->get_state(), circuit_state::CLOSED);
 
    // Should work normally now
    auto result = execute_with_circuit_breaker<int>(*breaker, "test", [this]() { return always_succeeding_operation(); });
    EXPECT_TRUE(result.is_ok());
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [8/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerStats	)

Definition at line 164 of file test_fault_tolerance.cpp.

                                                {
    circuit_breaker_config config;
    config.failure_threshold = 3;
 
    circuit_breaker breaker(config);
 
    // Execute some operations
    execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
    execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
    execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_succeeding_operation(); });
 
    auto stats = breaker.get_stats();
    EXPECT_FALSE(stats.empty());
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [9/26]

TEST_F	(	FaultToleranceTest	,
		CircuitBreakerWithFallback	)

Definition at line 146 of file test_fault_tolerance.cpp.

                                                       {
    circuit_breaker_config config;
    config.failure_threshold = 1;
 
    circuit_breaker breaker(config);
 
    // Open the circuit with one failure
    execute_with_circuit_breaker<int>(breaker, "test", [this]() { return always_failing_operation(); });
    EXPECT_EQ(breaker.get_state(), circuit_state::OPEN);
 
    // Use fallback when circuit is open
    if (!breaker.allow_request()) {
        auto result = kcenon::common::ok(999);
        EXPECT_TRUE(result.is_ok());
        EXPECT_EQ(result.value(), 999);
    }
}

References kcenon::monitoring::execute_with_circuit_breaker().

Here is the call graph for this function:

TEST_F() [10/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceConfigValidation	)

Definition at line 460 of file test_fault_tolerance.cpp.

                                                           {
    fault_tolerance_config config;
 
    // Valid config
    EXPECT_TRUE(config.validate());
 
    // Both mechanisms disabled
    config.enable_circuit_breaker = false;
    config.enable_retry = false;
    EXPECT_FALSE(config.validate());
 
    // Enable one mechanism
    config.enable_retry = true;
    EXPECT_TRUE(config.validate());
}

References kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, and kcenon::monitoring::fault_tolerance_config::validate().

Here is the call graph for this function:

TEST_F() [11/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerCircuitBreakerFirst	)

Definition at line 256 of file test_fault_tolerance.cpp.

                                                                     {
    fault_tolerance_config config;
    config.enable_circuit_breaker = true;
    config.enable_retry = true;
    config.circuit_breaker_first = true;
    config.circuit_config.failure_threshold = 2;
    config.retry_cfg = create_exponential_backoff_config(2, std::chrono::milliseconds(10));
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    success_after_attempts = 1; // Succeed on 2nd attempt
 
    auto result = manager.execute([this]() { return failing_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 42);
    EXPECT_EQ(call_count.load(), 2); // Retry executed
}

References kcenon::monitoring::fault_tolerance_config::circuit_breaker_first, kcenon::monitoring::fault_tolerance_config::circuit_config, kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, kcenon::monitoring::fault_tolerance_manager< T >::execute(), and kcenon::monitoring::fault_tolerance_config::retry_cfg.

Here is the call graph for this function:

TEST_F() [12/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerHealthCheck	)

Definition at line 362 of file test_fault_tolerance.cpp.

                                                             {
    fault_tolerance_config config;
    config.enable_circuit_breaker = true;
    config.circuit_config.failure_threshold = 2;
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    // Initially healthy
    auto health = manager.is_healthy();
    EXPECT_TRUE(health.is_ok());
    EXPECT_TRUE(health.value());
 
    // Open circuit breaker
    for (int i = 0; i < 2; ++i) {
        manager.execute([this]() { return always_failing_operation(); });
    }
 
    // Should now be unhealthy due to open circuit
    health = manager.is_healthy();
    EXPECT_TRUE(health.is_ok());
    EXPECT_FALSE(health.value());
}

References kcenon::monitoring::fault_tolerance_config::circuit_config, kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_manager< T >::execute(), and kcenon::monitoring::fault_tolerance_manager< T >::is_healthy().

Here is the call graph for this function:

TEST_F() [13/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerMetrics	)

Definition at line 340 of file test_fault_tolerance.cpp.

                                                         {
    fault_tolerance_config config;
    config.enable_circuit_breaker = true;
    config.enable_retry = true;
    config.circuit_config.failure_threshold = 5;
    config.retry_cfg = create_exponential_backoff_config(2, std::chrono::milliseconds(10));
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    // Execute successful operation
    manager.execute([this]() { return always_succeeding_operation(); });
 
    // Execute failing operation (will retry once)
    manager.execute([this]() { return always_failing_operation(); });
 
    auto metrics = manager.get_metrics();
    EXPECT_EQ(metrics.total_operations, 2);
    EXPECT_EQ(metrics.successful_operations, 1);
    EXPECT_EQ(metrics.failed_operations, 1);
    EXPECT_NEAR(metrics.get_overall_success_rate(), 0.5, 0.01);
}

References kcenon::monitoring::fault_tolerance_config::circuit_config, kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, kcenon::monitoring::fault_tolerance_manager< T >::execute(), kcenon::monitoring::fault_tolerance_manager< T >::get_metrics(), and kcenon::monitoring::fault_tolerance_config::retry_cfg.

Here is the call graph for this function:

TEST_F() [14/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerOnlyCircuitBreaker	)

Definition at line 293 of file test_fault_tolerance.cpp.

                                                                    {
    fault_tolerance_config config;
    config.enable_circuit_breaker = true;
    config.enable_retry = false;
    config.circuit_config.failure_threshold = 2;
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    auto result = manager.execute([this]() { return always_succeeding_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 100);
}

References kcenon::monitoring::fault_tolerance_config::circuit_config, kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, and kcenon::monitoring::fault_tolerance_manager< T >::execute().

Here is the call graph for this function:

TEST_F() [15/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerOnlyRetry	)

Definition at line 307 of file test_fault_tolerance.cpp.

                                                           {
    fault_tolerance_config config;
    config.enable_circuit_breaker = false;
    config.enable_retry = true;
    config.retry_cfg = create_exponential_backoff_config(3, std::chrono::milliseconds(10));
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    success_after_attempts = 2;
 
    auto result = manager.execute([this]() { return failing_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(call_count.load(), 3);
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, kcenon::monitoring::fault_tolerance_manager< T >::execute(), and kcenon::monitoring::fault_tolerance_config::retry_cfg.

Here is the call graph for this function:

TEST_F() [16/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerRetryFirst	)

Definition at line 275 of file test_fault_tolerance.cpp.

                                                            {
    fault_tolerance_config config;
    config.enable_circuit_breaker = true;
    config.enable_retry = true;
    config.circuit_breaker_first = false;
    config.circuit_config.failure_threshold = 5;
    config.retry_cfg = create_exponential_backoff_config(3, std::chrono::milliseconds(10));
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    success_after_attempts = 2;
 
    auto result = manager.execute([this]() { return failing_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(call_count.load(), 3);
}

References kcenon::monitoring::fault_tolerance_config::circuit_breaker_first, kcenon::monitoring::fault_tolerance_config::circuit_config, kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, kcenon::monitoring::fault_tolerance_manager< T >::execute(), and kcenon::monitoring::fault_tolerance_config::retry_cfg.

Here is the call graph for this function:

TEST_F() [17/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceManagerWithTimeout	)

Definition at line 323 of file test_fault_tolerance.cpp.

                                                             {
    fault_tolerance_config config;
    config.enable_circuit_breaker = false;
    config.enable_retry = true;
    config.retry_cfg = create_exponential_backoff_config(2, std::chrono::milliseconds(10));
 
    fault_tolerance_manager<int> manager("test_manager", config);
 
    auto result = manager.execute_with_timeout(
        [this]() { return slow_operation(std::chrono::milliseconds(500)); },
        std::chrono::milliseconds(50)
    );
 
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(result.error().code, static_cast<int>(monitoring_error_code::operation_timeout));
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::fault_tolerance_config::enable_circuit_breaker, kcenon::monitoring::fault_tolerance_config::enable_retry, kcenon::monitoring::fault_tolerance_manager< T >::execute_with_timeout(), and kcenon::monitoring::fault_tolerance_config::retry_cfg.

Here is the call graph for this function:

TEST_F() [18/26]

TEST_F	(	FaultToleranceTest	,
		FaultToleranceRegistry	)

Definition at line 422 of file test_fault_tolerance.cpp.

                                                   {
    auto& registry = global_fault_tolerance_registry();
 
    auto manager = std::make_shared<fault_tolerance_manager<int>>("test_manager");
    registry.register_manager<int>("test", manager);
 
    auto retrieved = registry.get_manager<int>("test");
    EXPECT_EQ(retrieved, manager);
 
    auto names = registry.get_all_names();
    EXPECT_EQ(names.size(), 1);
    EXPECT_EQ(names[0], "test");
 
    registry.remove_manager("test");
    retrieved = registry.get_manager<int>("test");
    EXPECT_EQ(retrieved, nullptr);
}

References kcenon::monitoring::global_fault_tolerance_registry().

Here is the call graph for this function:

TEST_F() [19/26]

TEST_F	(	FaultToleranceTest	,
		RetryConfigValidation	)

Definition at line 441 of file test_fault_tolerance.cpp.

                                                  {
    retry_config config;
 
    // Valid config
    EXPECT_TRUE(config.validate());
 
    // Invalid max attempts
    config.max_attempts = 0;
    EXPECT_FALSE(config.validate());
 
    // Reset to valid
    config.max_attempts = 3;
    EXPECT_TRUE(config.validate());
 
    // Invalid backoff multiplier
    config.backoff_multiplier = 0.5;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::retry_config::backoff_multiplier, kcenon::monitoring::retry_config::max_attempts, and kcenon::monitoring::retry_config::validate().

Here is the call graph for this function:

TEST_F() [20/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorBasicRetry	)

Definition at line 180 of file test_fault_tolerance.cpp.

                                                    {
    auto config = create_exponential_backoff_config(3, std::chrono::milliseconds(10));
    retry_executor<int> executor("test_retry", config);
 
    success_after_attempts = 2; // Succeed on 3rd attempt
 
    auto result = executor.execute([this]() { return failing_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(result.value(), 42);
    EXPECT_EQ(call_count.load(), 3);
 
    auto metrics = executor.get_metrics();
    EXPECT_EQ(metrics.total_executions, 1);
    EXPECT_EQ(metrics.successful_executions, 1);
    EXPECT_EQ(metrics.total_retries, 2);
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::retry_executor< T >::execute(), and kcenon::monitoring::retry_executor< T >::get_metrics().

Here is the call graph for this function:

TEST_F() [21/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorCustomShouldRetry	)

Definition at line 239 of file test_fault_tolerance.cpp.

                                                           {
    retry_config config = create_exponential_backoff_config(3);
    config.should_retry = [](const error_info& error) {
        // Only retry operation_timeout errors
        return error.code == monitoring_error_code::operation_timeout;
    };
 
    retry_executor<int> executor("test_retry", config);
 
    // This should not retry because it's not a timeout error
    auto result = executor.execute([this]() { return always_failing_operation(); });
 
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(call_count.load(), 1); // No retries
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::error, kcenon::monitoring::retry_executor< T >::execute(), and kcenon::monitoring::retry_config::should_retry.

Here is the call graph for this function:

TEST_F() [22/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorFibonacciBackoff	)

Definition at line 227 of file test_fault_tolerance.cpp.

                                                          {
    auto config = create_fibonacci_backoff_config(4, std::chrono::milliseconds(10));
    retry_executor<int> executor("test_retry", config);
 
    success_after_attempts = 3;
 
    auto result = executor.execute([this]() { return failing_operation(); });
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(call_count.load(), 4);
}

References kcenon::monitoring::create_fibonacci_backoff_config(), and kcenon::monitoring::retry_executor< T >::execute().

Here is the call graph for this function:

TEST_F() [23/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorFixedDelay	)

Definition at line 213 of file test_fault_tolerance.cpp.

                                                    {
    retry_config config = create_fixed_delay_config(3, std::chrono::milliseconds(50));
    retry_executor<int> executor("test_retry", config);
 
    success_after_attempts = 2;
 
    auto start = std::chrono::steady_clock::now();
    auto result = executor.execute([this]() { return failing_operation(); });
    auto duration = std::chrono::steady_clock::now() - start;
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_GE(duration, std::chrono::milliseconds(100)); // At least 2 delays
}

References kcenon::monitoring::create_fixed_delay_config(), and kcenon::monitoring::retry_executor< T >::execute().

Here is the call graph for this function:

TEST_F() [24/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorMaxAttemptsExceeded	)

Definition at line 198 of file test_fault_tolerance.cpp.

                                                             {
    auto config = create_exponential_backoff_config(2, std::chrono::milliseconds(10));
    retry_executor<int> executor("test_retry", config);
 
    auto result = executor.execute([this]() { return always_failing_operation(); });
 
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(call_count.load(), 2);
 
    auto metrics = executor.get_metrics();
    EXPECT_EQ(metrics.total_executions, 1);
    EXPECT_EQ(metrics.failed_executions, 1);
    EXPECT_EQ(metrics.total_retries, 1);
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::retry_executor< T >::execute(), and kcenon::monitoring::retry_executor< T >::get_metrics().

Here is the call graph for this function:

TEST_F() [25/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorRegistry	)

Definition at line 404 of file test_fault_tolerance.cpp.

                                                  {
    auto& registry = global_retry_executor_registry();
 
    auto executor = std::make_shared<retry_executor<int>>("test_executor");
    registry.register_executor<int>("test", executor);
 
    auto retrieved = registry.get_executor<int>("test");
    EXPECT_EQ(retrieved, executor);
 
    auto names = registry.get_all_names();
    EXPECT_EQ(names.size(), 1);
    EXPECT_EQ(names[0], "test");
 
    registry.remove_executor("test");
    retrieved = registry.get_executor<int>("test");
    EXPECT_EQ(retrieved, nullptr);
}

References kcenon::monitoring::global_retry_executor_registry().

Here is the call graph for this function:

TEST_F() [26/26]

TEST_F	(	FaultToleranceTest	,
		RetryExecutorResetMetrics	)

Definition at line 529 of file test_fault_tolerance.cpp.

                                                      {
    auto config = create_exponential_backoff_config(3, std::chrono::milliseconds(10));
    retry_executor<int> executor("reset_test", config);
 
    // Execute some operations
    executor.execute([this]() { return always_succeeding_operation(); });
    executor.execute([this]() { return always_failing_operation(); });
 
    auto metrics_before = executor.get_metrics();
    EXPECT_GT(metrics_before.total_executions, 0);
 
    // Reset metrics
    executor.reset_metrics();
 
    auto metrics_after = executor.get_metrics();
    EXPECT_EQ(metrics_after.total_executions, 0);
    EXPECT_EQ(metrics_after.successful_executions, 0);
    EXPECT_EQ(metrics_after.failed_executions, 0);
}

References kcenon::monitoring::create_exponential_backoff_config(), kcenon::monitoring::retry_executor< T >::execute(), kcenon::monitoring::retry_executor< T >::get_metrics(), and kcenon::monitoring::retry_executor< T >::reset_metrics().

Here is the call graph for this function: