test_result_types.cpp File Reference

#include <gtest/gtest.h>
#include "kcenon/monitoring/core/result_types.h"
#include "kcenon/monitoring/core/error_codes.h"
#include "kcenon/monitoring/interfaces/monitoring_core.h"

Include dependency graph for test_result_types.cpp:

Go to the source code of this file.

Classes
class	ResultTypesTest
	Test basic Result pattern functionality. More...

Functions
	TEST_F (ResultTypesTest, SuccessResultContainsValue)
	TEST_F (ResultTypesTest, ErrorResultContainsError)
	TEST_F (ResultTypesTest, ValueOrReturnsDefaultOnError)
	TEST_F (ResultTypesTest, MapTransformsSuccessValue)
	TEST_F (ResultTypesTest, MapPropagatesError)
	TEST_F (ResultTypesTest, AndThenChainsOperations)
	TEST_F (ResultTypesTest, ResultVoidSuccess)
	TEST_F (ResultTypesTest, ResultVoidError)
	TEST_F (ResultTypesTest, ErrorCodeToString)
	TEST_F (ResultTypesTest, ErrorInfoWithContext)
	TEST_F (ResultTypesTest, MetricsSnapshotOperations)
	TEST_F (ResultTypesTest, MonitoringConfigValidation)
	TEST_F (ResultTypesTest, HealthCheckResult)

Function Documentation

TEST_F() [1/13]

TEST_F	(	ResultTypesTest	,
		AndThenChainsOperations	)

Definition at line 62 of file test_result_types.cpp.

                                                 {
    auto result = kcenon::common::ok(10);
    auto chained = result.and_then([](int x) {
        if (x > 5) {
            return kcenon::common::ok(std::string("Large"));
        }
        return kcenon::common::make_error<std::string>(static_cast<int>(monitoring_error_code::invalid_configuration), "");
    });
 
    EXPECT_TRUE(chained.is_ok());
    EXPECT_EQ(chained.value(), "Large");
}

TEST_F() [2/13]

TEST_F	(	ResultTypesTest	,
		ErrorCodeToString	)

Definition at line 90 of file test_result_types.cpp.

                                           {
    EXPECT_EQ(error_code_to_string(monitoring_error_code::success), "Success");
    EXPECT_EQ(error_code_to_string(monitoring_error_code::collector_not_found), "Collector not found");
    EXPECT_EQ(error_code_to_string(monitoring_error_code::storage_full), "Storage is full");
    EXPECT_EQ(error_code_to_string(monitoring_error_code::invalid_configuration), "Invalid configuration");
}

References kcenon::monitoring::error_code_to_string().

Here is the call graph for this function:

TEST_F() [3/13]

TEST_F	(	ResultTypesTest	,
		ErrorInfoWithContext	)

Definition at line 97 of file test_result_types.cpp.

                                              {
    auto result = kcenon::common::make_error<int>(
        static_cast<int>(monitoring_error_code::collection_failed),
        "Failed to collect metrics",
        "",
        "CPU collector timeout"
    );
 
    EXPECT_FALSE(result.is_ok());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::collection_failed);
    EXPECT_EQ(result.error().message, "Failed to collect metrics");
    EXPECT_TRUE(result.error().details.has_value());
    EXPECT_EQ(result.error().details.value(), "CPU collector timeout");
}

TEST_F() [4/13]

TEST_F	(	ResultTypesTest	,
		ErrorResultContainsError	)

Definition at line 29 of file test_result_types.cpp.

                                                  {
    auto result = kcenon::common::make_error<int>(static_cast<int>(monitoring_error_code::collector_not_found), "Test error");
 
    EXPECT_FALSE(result.is_ok());
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::collector_not_found);
    EXPECT_EQ(result.error().message, "Test error");
}

TEST_F() [5/13]

TEST_F	(	ResultTypesTest	,
		HealthCheckResult	)

Definition at line 158 of file test_result_types.cpp.

                                           {
    health_check_result health;
    
    EXPECT_EQ(health.status, health_status::unknown);
    EXPECT_FALSE(health.is_healthy());
    
    health.status = health_status::healthy;
    EXPECT_TRUE(health.is_healthy());
    
    health.status = health_status::degraded;
    health.issues.push_back("High memory usage");
    EXPECT_FALSE(health.is_healthy());
    EXPECT_EQ(health.issues.size(), 1);
}

References kcenon::monitoring::health_check_result::is_healthy(), kcenon::monitoring::health_check_result::issues, and kcenon::monitoring::health_check_result::status.

Here is the call graph for this function:

TEST_F() [6/13]

TEST_F	(	ResultTypesTest	,
		MapPropagatesError	)

Definition at line 54 of file test_result_types.cpp.

                                            {
    auto result = kcenon::common::make_error<int>(static_cast<int>(monitoring_error_code::invalid_configuration), "");
    auto mapped = result.map([](int x) { return x * 2; });
 
    EXPECT_FALSE(mapped.is_ok());
    EXPECT_EQ(static_cast<monitoring_error_code>(mapped.error().code), monitoring_error_code::invalid_configuration);
}

TEST_F() [7/13]

TEST_F	(	ResultTypesTest	,
		MapTransformsSuccessValue	)

Definition at line 46 of file test_result_types.cpp.

                                                   {
    auto result = kcenon::common::ok(10);
    auto mapped = result.map([](int x) { return x * 2; });
 
    EXPECT_TRUE(mapped.is_ok());
    EXPECT_EQ(mapped.value(), 20);
}

TEST_F() [8/13]

TEST_F	(	ResultTypesTest	,
		MetricsSnapshotOperations	)

Definition at line 112 of file test_result_types.cpp.

                                                   {
    metrics_snapshot snapshot;
    snapshot.add_metric("cpu_usage", 45.5);
    snapshot.add_metric("memory_usage", 2048.0);
    
    EXPECT_EQ(snapshot.metrics.size(), 2);
    
    auto cpu = snapshot.get_metric("cpu_usage");
    EXPECT_TRUE(cpu.has_value());
    EXPECT_EQ(cpu.value(), 45.5);
    
    auto unknown = snapshot.get_metric("unknown_metric");
    EXPECT_FALSE(unknown.has_value());
}

References kcenon::monitoring::metrics_snapshot::add_metric(), kcenon::monitoring::cpu, kcenon::monitoring::metrics_snapshot::get_metric(), kcenon::monitoring::metrics_snapshot::metrics, and kcenon::monitoring::unknown.

Here is the call graph for this function:

TEST_F() [9/13]

TEST_F	(	ResultTypesTest	,
		MonitoringConfigValidation	)

Definition at line 127 of file test_result_types.cpp.

                                                    {
    monitoring_config config;
 
    // Valid configuration
    config.history_size = 100;
    config.collection_interval = std::chrono::milliseconds(100);
    config.buffer_size = 1000;
    auto result = config.validate();
    EXPECT_TRUE(result.is_ok());
 
    // Invalid history size
    config.history_size = 0;
    result = config.validate();
    EXPECT_FALSE(result.is_ok());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::invalid_capacity);
 
    // Invalid interval
    config.history_size = 100;
    config.collection_interval = std::chrono::milliseconds(5);
    result = config.validate();
    EXPECT_FALSE(result.is_ok());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::invalid_interval);
 
    // Invalid buffer size
    config.collection_interval = std::chrono::milliseconds(100);
    config.buffer_size = 50; // Less than history_size
    result = config.validate();
    EXPECT_FALSE(result.is_ok());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::invalid_capacity);
}

References kcenon::monitoring::monitoring_config::buffer_size, kcenon::monitoring::monitoring_config::collection_interval, kcenon::monitoring::monitoring_config::history_size, and kcenon::monitoring::monitoring_config::validate().

Here is the call graph for this function:

TEST_F() [10/13]

TEST_F	(	ResultTypesTest	,
		ResultVoidError	)

Definition at line 82 of file test_result_types.cpp.

                                         {
    auto result = kcenon::common::VoidResult::err(static_cast<int>(monitoring_error_code::storage_full), "Storage is full");
 
    EXPECT_FALSE(result.is_ok());
    EXPECT_TRUE(result.is_err());
    EXPECT_EQ(static_cast<monitoring_error_code>(result.error().code), monitoring_error_code::storage_full);
}

TEST_F() [11/13]

TEST_F	(	ResultTypesTest	,
		ResultVoidSuccess	)

Definition at line 75 of file test_result_types.cpp.

                                           {
    auto result = kcenon::common::ok();
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_FALSE(result.is_err());
}

TEST_F() [12/13]

TEST_F	(	ResultTypesTest	,
		SuccessResultContainsValue	)

Definition at line 21 of file test_result_types.cpp.

                                                    {
    auto result = kcenon::common::ok(42);
 
    EXPECT_TRUE(result.is_ok());
    EXPECT_FALSE(result.is_err());
    EXPECT_EQ(result.value(), 42);
}

TEST_F() [13/13]

TEST_F	(	ResultTypesTest	,
		ValueOrReturnsDefaultOnError	)

Definition at line 38 of file test_result_types.cpp.

                                                      {
    auto error_result = kcenon::common::make_error<int>(static_cast<int>(monitoring_error_code::unknown_error), "");
    EXPECT_EQ(error_result.value_or(100), 100);
 
    auto success_result = kcenon::common::ok(42);
    EXPECT_EQ(success_result.value_or(100), 42);
}