test_cross_system_integration.cpp File Reference

Phase 3.3 - Cross-System Integration Tests. More...

#include <gtest/gtest.h>
#include <kcenon/monitoring/core/performance_monitor.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <memory>
#include <mutex>
#include <thread>
#include <chrono>

Include dependency graph for test_cross_system_integration.cpp:

Go to the source code of this file.

Classes
class	simple_mock_logger
	Simple mock logger for testing. More...
class	mock_monitor
	Mock IMonitor for testing cross-system integration. More...

Functions
	TEST (CrossSystemIntegrationTest, BothSystemsStandalone)
	Test Case 1: Both systems standalone.
	TEST (CrossSystemIntegrationTest, LoggerWithMonitorInjection)
	Test Case 2: Logger with monitor injection.
	TEST (CrossSystemIntegrationTest, MonitorInterfaceCompatibility)
	Test Case 3: Monitor with logger (interface compatibility)
	TEST (CrossSystemIntegrationTest, BidirectionalDependencyInjection)
	Test Case 4: Bidirectional DI (NO CIRCULAR DEPENDENCY!)
	TEST (CrossSystemIntegrationTest, RepeatedInjection)
	Test Case 5: Repeated injection.
	TEST (CrossSystemIntegrationTest, NullInjection)
	Test Case 6: NULL injection.
	TEST (CrossSystemIntegrationTest, IntegrationPerformanceOverhead)
	Performance test: Integration overhead.
	TEST (CrossSystemIntegrationTest, MonitoringSystemStandalone)
	Test monitoring_system's performance_monitor standalone.
int	main (int argc, char **argv)

Detailed Description

Phase 3.3 - Cross-System Integration Tests.

Tests verify the integration matrix:

1. Both systems standalone
2. Logger with monitor injection
3. Monitor with logger injection
4. Bidirectional DI (no compile-time circular dependency!)
5. Repeated injection
6. NULL injection

Definition in file test_cross_system_integration.cpp.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 337 of file test_cross_system_integration.cpp.

                                {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

TEST() [1/8]

TEST	(	CrossSystemIntegrationTest	,
		BidirectionalDependencyInjection	)

Test Case 4: Bidirectional DI (NO CIRCULAR DEPENDENCY!)

This is the critical test - we can create bidirectional runtime dependencies WITHOUT compile-time circular dependency!

Definition at line 217 of file test_cross_system_integration.cpp.

                                                                   {
    // Create both systems
    auto logger = std::make_shared<simple_mock_logger>();
    auto monitor = std::make_shared<mock_monitor>();
 
    // Bidirectional injection
    logger->set_monitor(monitor);
 
    // Use both systems
    for (int i = 0; i < 10; ++i) {
        logger->log(common_if::log_level::info, "Request " + std::to_string(i));
    }
 
    // Verify logger health
    auto logger_health = logger->health_check();
    ASSERT_TRUE(logger_health.is_ok());
    EXPECT_TRUE(logger_health.value().is_healthy());
 
    // Verify monitor health
    auto monitor_health = monitor->check_health();
    ASSERT_TRUE(monitor_health.is_ok());
    EXPECT_TRUE(monitor_health.value().is_healthy());
 
    // Verify metrics were recorded
    auto monitor_metrics = monitor->get_metrics();
    ASSERT_TRUE(monitor_metrics.is_ok());
    EXPECT_EQ(10, monitor_metrics.value().metrics.size());
 
    // Logger should have logged
    EXPECT_EQ(10, logger->get_log_count());
}

TEST() [2/8]

TEST	(	CrossSystemIntegrationTest	,
		BothSystemsStandalone	)

Test Case 1: Both systems standalone.

Definition at line 148 of file test_cross_system_integration.cpp.

                                                        {
    // Create logger without monitor
    auto logger = std::make_shared<simple_mock_logger>();
 
    EXPECT_NO_THROW({
        logger->log(common_if::log_level::info, "Test message");
    });
    EXPECT_EQ(1, logger->get_log_count());
 
    // Create monitor without logger
    auto monitor = std::make_shared<mock_monitor>();
 
    EXPECT_NO_THROW({
        auto result = monitor->record_metric("test_metric", 1.0);
        EXPECT_TRUE(result.is_ok());
    });
 
    // Both should work independently
    auto monitor_metrics = monitor->get_metrics();
    ASSERT_TRUE(monitor_metrics.is_ok());
    EXPECT_EQ(1, monitor_metrics.value().metrics.size());
}

TEST() [3/8]

TEST	(	CrossSystemIntegrationTest	,
		IntegrationPerformanceOverhead	)

Performance test: Integration overhead.

Definition at line 298 of file test_cross_system_integration.cpp.

                                                                 {
    auto logger = std::make_shared<simple_mock_logger>();
    auto monitor = std::make_shared<mock_monitor>();
 
    logger->set_monitor(monitor);
 
    // Measure time for integrated operations
    auto start = std::chrono::high_resolution_clock::now();
 
    for (int i = 0; i < 1000; ++i) {
        logger->log(common_if::log_level::info, "Performance test");
    }
 
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 
    // Integration should be fast (< 100ms for 1000 operations)
    EXPECT_LT(duration.count(), 100);
    EXPECT_EQ(1000, monitor->get_metric_count());
}

TEST() [4/8]

TEST	(	CrossSystemIntegrationTest	,
		LoggerWithMonitorInjection	)

Test Case 2: Logger with monitor injection.

Definition at line 174 of file test_cross_system_integration.cpp.

                                                             {
    auto monitor = std::make_shared<mock_monitor>();
    auto logger = std::make_shared<simple_mock_logger>();
 
    // Inject monitor into logger
    logger->set_monitor(monitor);
 
    // Log messages - each log should record a metric
    logger->log(common_if::log_level::info, "Test 1");
    logger->log(common_if::log_level::info, "Test 2");
 
    // Monitor should have received metrics from logger
    auto metrics_result = monitor->get_metrics();
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto& snapshot = metrics_result.value();
    EXPECT_EQ(2, snapshot.metrics.size());
}

TEST() [5/8]

TEST	(	CrossSystemIntegrationTest	,
		MonitoringSystemStandalone	)

Test monitoring_system's performance_monitor standalone.

Definition at line 322 of file test_cross_system_integration.cpp.

                                                             {
    auto monitor = std::make_shared<mon::performance_monitor>();
 
    // Test monitoring_system's native interface
    EXPECT_NO_THROW({
        auto timer = monitor->time_operation("test_op");
        // Simulate work
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    });
 
    // Collect metrics using native interface
    auto result = monitor->collect();
    ASSERT_TRUE(result.is_ok());
}

TEST() [6/8]

TEST	(	CrossSystemIntegrationTest	,
		MonitorInterfaceCompatibility	)

Test Case 3: Monitor with logger (interface compatibility)

Definition at line 196 of file test_cross_system_integration.cpp.

                                                                {
    auto monitor = std::make_shared<mock_monitor>();
 
    // Test IMonitor interface methods
    EXPECT_NO_THROW({
        auto result = monitor->record_metric("test_metric", 42.0);
        EXPECT_TRUE(result.is_ok());
    });
 
    // Monitor health check should work
    auto health = monitor->check_health();
    ASSERT_TRUE(health.is_ok());
    EXPECT_EQ(common_if::health_status::healthy, health.value().status);
}

TEST() [7/8]

TEST	(	CrossSystemIntegrationTest	,
		NullInjection	)

Test Case 6: NULL injection.

Definition at line 277 of file test_cross_system_integration.cpp.

                                                {
    auto logger = std::make_shared<simple_mock_logger>();
    auto monitor = std::make_shared<mock_monitor>();
 
    // Inject then remove
    logger->set_monitor(monitor);
    logger->set_monitor(nullptr);
 
    // Should not crash
    EXPECT_NO_THROW({
        logger->log(common_if::log_level::info, "After null injection");
    });
 
    EXPECT_EQ(1, logger->get_log_count());
    // Monitor should not have received the last log (null injection)
    EXPECT_EQ(0, monitor->get_metric_count());
}

TEST() [8/8]

TEST	(	CrossSystemIntegrationTest	,
		RepeatedInjection	)

Test Case 5: Repeated injection.

Definition at line 252 of file test_cross_system_integration.cpp.

                                                    {
    auto logger = std::make_shared<simple_mock_logger>();
    auto monitor1 = std::make_shared<mock_monitor>();
    auto monitor2 = std::make_shared<mock_monitor>();
 
    // First injection
    logger->set_monitor(monitor1);
    logger->log(common_if::log_level::info, "With monitor1");
 
    // monitor1 should have received the metric
    EXPECT_EQ(1, monitor1->get_metric_count());
 
    // Replace with second monitor
    logger->set_monitor(monitor2);
    logger->log(common_if::log_level::info, "With monitor2");
 
    // monitor2 should now receive metrics, monitor1 stays at 1
    EXPECT_EQ(1, monitor1->get_metric_count());
    EXPECT_EQ(1, monitor2->get_metric_count());
    EXPECT_EQ(2, logger->get_log_count());
}