test_database_coordinator.cpp File Reference

Unit tests for database_coordinator (Phase 5) More...

#include "../../database/integrated/adapters/logger_adapter.h"
#include "../../database/integrated/adapters/monitoring_adapter.h"
#include "../../database/integrated/adapters/thread_adapter.h"
#include "../../database/integrated/core/database_coordinator.h"
#include <chrono>
#include <iostream>
#include <thread>

Include dependency graph for test_database_coordinator.cpp:

Go to the source code of this file.

Macros
#define	TEST(name)
#define	RUN_TEST(name)
#define	ASSERT_TRUE(condition)
#define	ASSERT_FALSE(condition)

Functions
void	test_basic_initialization_and_shutdown ()
void	test_adapter_access ()
void	test_logger_functionality ()
void	test_monitoring_functionality ()
void	test_thread_pool_functionality ()
void	test_health_check ()
void	test_statistics ()
void	test_double_initialization ()
void	test_shutdown_without_initialization ()
void	test_automatic_shutdown_in_destructor ()
void	test_full_integration ()
int	main ()

Variables
int	tests_passed = 0
int	tests_failed = 0

Detailed Description

Unit tests for database_coordinator (Phase 5)

Tests the coordinator's ability to:

• Initialize and shutdown adapters in correct order
• Provide access to initialized adapters
• Handle initialization failures gracefully
• Perform aggregate health checks
• Report statistics

Definition in file test_database_coordinator.cpp.

Macro Definition Documentation

ASSERT_FALSE

#define ASSERT_FALSE

(

condition

)

Value:

ASSERT_TRUE(!(condition))

Definition at line 51 of file test_database_coordinator.cpp.

Referenced by test_basic_initialization_and_shutdown(), test_double_initialization(), test_health_check(), and test_statistics().

ASSERT_TRUE

#define ASSERT_TRUE

(

condition

)

Value:

  if (!(condition)) {                                                          \
    throw std::runtime_error("Assertion failed: " #condition);                 \
  }

Definition at line 46 of file test_database_coordinator.cpp.

#define ASSERT_TRUE(condition)                                                 \
  if (!(condition)) {                                                          \
    throw std::runtime_error("Assertion failed: " #condition);                 \
  }

Referenced by test_adapter_access(), test_automatic_shutdown_in_destructor(), test_basic_initialization_and_shutdown(), test_double_initialization(), test_full_integration(), test_health_check(), test_logger_functionality(), test_monitoring_functionality(), test_shutdown_without_initialization(), test_statistics(), and test_thread_pool_functionality().

RUN_TEST

#define RUN_TEST

(

name

)

Value:

  do {                                                                         \
    std::cout << "Running test: " << #name << " ... ";                         \
    try {                                                                      \
      test_##name();                                                           \
      std::cout << "PASSED\n";                                                 \
      tests_passed++;                                                          \
    } catch (const std::exception &e) {                                        \
      std::cout << "FAILED: " << e.what() << "\n";                             \
      tests_failed++;                                                          \
    }                                                                          \
  } while (0)

Definition at line 33 of file test_database_coordinator.cpp.

#define RUN_TEST(name)                                                         \
  do {                                                                         \
    std::cout << "Running test: " << #name << " ... ";                         \
    try {                                                                      \
      test_##name();                                                           \
      std::cout << "PASSED\n";                                                 \
      tests_passed++;                                                          \
    } catch (const std::exception &e) {                                        \
      std::cout << "FAILED: " << e.what() << "\n";                             \
      tests_failed++;                                                          \
    }                                                                          \
  } while (0)

Referenced by main().

TEST

#define TEST

(

name

)

Value:

void test_##name()

Definition at line 32 of file test_database_coordinator.cpp.

Function Documentation

main()

int main

(

)

Definition at line 330 of file test_database_coordinator.cpp.

           {
  std::cout << "=== Database Coordinator Tests (Phase 5) ===\n\n";
 
  RUN_TEST(basic_initialization_and_shutdown);
  RUN_TEST(adapter_access);
  RUN_TEST(logger_functionality);
  RUN_TEST(monitoring_functionality);
  RUN_TEST(thread_pool_functionality);
  RUN_TEST(health_check);
  RUN_TEST(statistics);
  RUN_TEST(double_initialization);
  RUN_TEST(shutdown_without_initialization);
  RUN_TEST(automatic_shutdown_in_destructor);
  RUN_TEST(full_integration);
 
  std::cout << "\n=== Test Summary ===\n";
  std::cout << "Passed: " << tests_passed << "\n";
  std::cout << "Failed: " << tests_failed << "\n";
 
  if (tests_failed == 0) {
    std::cout << "=== All tests passed! ✓ ===\n";
    return 0;
  } else {
    std::cout << "=== Some tests failed! ✗ ===\n";
    return 1;
  }
}

References RUN_TEST, tests_failed, and tests_passed.

test_adapter_access()

void test_adapter_access

(

)

Definition at line 79 of file test_database_coordinator.cpp.

                     {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
  config.monitoring.enable_metrics = true;
  config.thread.thread_count = 2;
 
  database_coordinator coordinator(config);
 
  // Before initialization, adapters should be nullptr
  ASSERT_TRUE(coordinator.get_logger() == nullptr);
  ASSERT_TRUE(coordinator.get_monitor() == nullptr);
  ASSERT_TRUE(coordinator.get_thread_pool() == nullptr);
 
  // Initialize
  auto init_result = coordinator.initialize();
  ASSERT_TRUE(init_result.is_ok());
 
  // After initialization, adapters should be accessible
  ASSERT_TRUE(coordinator.get_logger() != nullptr);
  ASSERT_TRUE(coordinator.get_monitor() != nullptr);
  ASSERT_TRUE(coordinator.get_thread_pool() != nullptr);
 
  // Shutdown
  coordinator.shutdown();
}

References ASSERT_TRUE, database::integrated::db_monitoring_config::enable_metrics, database::integrated::database_coordinator::get_logger(), database::integrated::database_coordinator::get_monitor(), database::integrated::database_coordinator::get_thread_pool(), database::integrated::database_coordinator::initialize(), database::integrated::unified_db_config::monitoring, database::integrated::database_coordinator::shutdown(), database::integrated::unified_db_config::thread, and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_automatic_shutdown_in_destructor()

void test_automatic_shutdown_in_destructor

(

)

Definition at line 260 of file test_database_coordinator.cpp.

                                       {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
 
  {
    database_coordinator coordinator(config);
    coordinator.initialize();
    // Destructor will call shutdown automatically
  }
 
  // If we get here without crash, test passed
  ASSERT_TRUE(true);
}

References ASSERT_TRUE, and database::integrated::database_coordinator::initialize().

Here is the call graph for this function:

test_basic_initialization_and_shutdown()

void test_basic_initialization_and_shutdown

(

)

Definition at line 54 of file test_database_coordinator.cpp.

                                        {
  unified_db_config config;
  config.logger.min_log_level = db_log_level::info;
  // enable_console_logging does not exist
  config.logger.enable_file_logging = false;
  config.monitoring.enable_metrics = true;
  config.thread.thread_count = 2;
 
  database_coordinator coordinator(config);
 
  // Should not be initialized yet
  ASSERT_FALSE(coordinator.is_initialized());
 
  // Initialize
  auto init_result = coordinator.initialize();
  ASSERT_TRUE(init_result.is_ok());
  ASSERT_TRUE(coordinator.is_initialized());
 
  // Shutdown
  auto shutdown_result = coordinator.shutdown();
  ASSERT_TRUE(shutdown_result.is_ok());
  ASSERT_FALSE(coordinator.is_initialized());
}

References ASSERT_FALSE, ASSERT_TRUE, database::integrated::db_logger_config::enable_file_logging, database::integrated::db_monitoring_config::enable_metrics, database::integrated::database_coordinator::initialize(), database::integrated::database_coordinator::is_initialized(), database::integrated::unified_db_config::logger, database::integrated::db_logger_config::min_log_level, database::integrated::unified_db_config::monitoring, database::integrated::database_coordinator::shutdown(), database::integrated::unified_db_config::thread, and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_double_initialization()

void test_double_initialization

(

)

Definition at line 232 of file test_database_coordinator.cpp.

                            {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
 
  database_coordinator coordinator(config);
 
  // First initialization should succeed
  auto init1 = coordinator.initialize();
  ASSERT_TRUE(init1.is_ok());
 
  // Second initialization should fail
  auto init2 = coordinator.initialize();
  ASSERT_FALSE(init2.is_ok());
 
  coordinator.shutdown();
}

References ASSERT_FALSE, ASSERT_TRUE, database::integrated::database_coordinator::initialize(), and database::integrated::database_coordinator::shutdown().

Here is the call graph for this function:

test_full_integration()

void test_full_integration

(

)

Definition at line 275 of file test_database_coordinator.cpp.

                       {
  unified_db_config config;
  config.logger.min_log_level = db_log_level::info;
  // config.logger.enable_console_logging does not exist
  config.monitoring.enable_metrics = true;
  config.monitoring.enable_profiling = true;
  config.thread.thread_count = 4;
 
  database_coordinator coordinator(config);
  coordinator.initialize();
 
  // Get all adapters
  auto *logger = coordinator.get_logger();
  auto *monitor = coordinator.get_monitor();
  auto *thread_pool = coordinator.get_thread_pool();
 
  ASSERT_TRUE(logger != nullptr);
  ASSERT_TRUE(monitor != nullptr);
  ASSERT_TRUE(thread_pool != nullptr);
 
  // Simulate database operations
  logger->log(db_log_level::info, "Starting database operations");
 
  // Submit async query simulation
  auto query_future = thread_pool->submit([&]() {
    // Yield to allow simulated query execution
    std::this_thread::yield();
 
    // Record metrics
    monitor->record_query_execution(std::chrono::microseconds(100), true);
 
    logger->log(db_log_level::debug, "Query executed successfully");
 
    return true;
  });
 
  ASSERT_TRUE(query_future.get() == true);
 
  // Check health
  auto health = coordinator.check_health();
  ASSERT_TRUE(health.is_ok());
  ASSERT_TRUE(health.value());
 
  // Get metrics
  auto metrics = monitor->get_database_metrics();
  ASSERT_TRUE(metrics.is_ok());
  ASSERT_TRUE(metrics.value().total_queries == 1);
  ASSERT_TRUE(metrics.value().successful_queries == 1);
 
  logger->log(db_log_level::info, "All operations completed");
 
  coordinator.shutdown();
}

References ASSERT_TRUE, database::integrated::database_coordinator::check_health(), database::integrated::db_monitoring_config::enable_metrics, database::integrated::db_monitoring_config::enable_profiling, database::integrated::database_coordinator::get_logger(), database::integrated::database_coordinator::get_monitor(), database::integrated::database_coordinator::get_thread_pool(), database::integrated::database_coordinator::initialize(), database::integrated::unified_db_config::logger, database::integrated::db_logger_config::min_log_level, database::integrated::unified_db_config::monitoring, database::integrated::database_coordinator::shutdown(), database::integrated::unified_db_config::thread, and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_health_check()

void test_health_check

(

)

Definition at line 178 of file test_database_coordinator.cpp.

                   {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
  config.monitoring.enable_health_checks = true;
  config.thread.thread_count = 2;
 
  database_coordinator coordinator(config);
 
  // Health check before initialization should fail
  auto health_before = coordinator.check_health();
  ASSERT_FALSE(health_before.is_ok());
 
  // Initialize
  coordinator.initialize();
 
  // Health check after initialization should succeed
  auto health_after = coordinator.check_health();
  ASSERT_TRUE(health_after.is_ok());
  ASSERT_TRUE(health_after.value()); // Should be healthy
 
  coordinator.shutdown();
}

References ASSERT_FALSE, ASSERT_TRUE, database::integrated::database_coordinator::check_health(), database::integrated::db_monitoring_config::enable_health_checks, database::integrated::database_coordinator::initialize(), database::integrated::unified_db_config::monitoring, database::integrated::database_coordinator::shutdown(), database::integrated::unified_db_config::thread, and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_logger_functionality()

void test_logger_functionality

(

)

Definition at line 106 of file test_database_coordinator.cpp.

                           {
  unified_db_config config;
  config.logger.min_log_level = db_log_level::debug;
  // config.logger.enable_console_logging does not exist
 
  database_coordinator coordinator(config);
  coordinator.initialize();
 
  auto *logger = coordinator.get_logger();
  ASSERT_TRUE(logger != nullptr);
 
  // Log various levels
  logger->log(db_log_level::debug, "Debug message from coordinator test");
  logger->log(db_log_level::info, "Info message from coordinator test");
  logger->log(db_log_level::warning, "Warning message from coordinator test");
 
  coordinator.shutdown();
}

References ASSERT_TRUE, database::integrated::database_coordinator::get_logger(), database::integrated::database_coordinator::initialize(), database::integrated::unified_db_config::logger, database::integrated::db_logger_config::min_log_level, and database::integrated::database_coordinator::shutdown().

Here is the call graph for this function:

test_monitoring_functionality()

void test_monitoring_functionality

(

)

Definition at line 126 of file test_database_coordinator.cpp.

                               {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
  config.monitoring.enable_metrics = true;
  config.monitoring.enable_profiling = true;
 
  database_coordinator coordinator(config);
  coordinator.initialize();
 
  auto *monitor = coordinator.get_monitor();
  ASSERT_TRUE(monitor != nullptr);
 
  // Record some metrics
  monitor->record_connection_acquired();
  monitor->record_query_execution(std::chrono::microseconds(100), true);
  monitor->update_pool_stats(1, 5, 10);
 
  // Get metrics
  auto metrics_result = monitor->get_database_metrics();
  ASSERT_TRUE(metrics_result.is_ok());
  ASSERT_TRUE(metrics_result.value().active_connections == 1);
 
  coordinator.shutdown();
}

References ASSERT_TRUE, database::integrated::db_monitoring_config::enable_metrics, database::integrated::db_monitoring_config::enable_profiling, database::integrated::database_coordinator::get_monitor(), database::integrated::database_coordinator::initialize(), database::integrated::unified_db_config::monitoring, and database::integrated::database_coordinator::shutdown().

Here is the call graph for this function:

test_shutdown_without_initialization()

void test_shutdown_without_initialization

(

)

Definition at line 250 of file test_database_coordinator.cpp.

                                      {
  unified_db_config config;
  database_coordinator coordinator(config);
 
  // Shutdown without initialize should succeed (no-op)
  auto result = coordinator.shutdown();
  ASSERT_TRUE(result.is_ok());
}

References ASSERT_TRUE, and database::integrated::database_coordinator::shutdown().

Here is the call graph for this function:

test_statistics()

void test_statistics

(

)

Definition at line 202 of file test_database_coordinator.cpp.

                 {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
 
  database_coordinator coordinator(config);
 
  // Get stats before initialization
  auto stats_before = coordinator.get_stats();
  ASSERT_TRUE(stats_before.is_ok());
  ASSERT_FALSE(stats_before.value().is_initialized);
  ASSERT_TRUE(stats_before.value().uptime.count() == 0);
 
  // Initialize
  coordinator.initialize();
  // Need actual time to pass for uptime measurement test
  std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
  // Get stats after initialization
  auto stats_after = coordinator.get_stats();
  ASSERT_TRUE(stats_after.is_ok());
  ASSERT_TRUE(stats_after.value().is_initialized);
  ASSERT_TRUE(stats_after.value().logger_healthy);
  ASSERT_TRUE(stats_after.value().monitoring_healthy);
  ASSERT_TRUE(stats_after.value().thread_pool_healthy);
  ASSERT_TRUE(stats_after.value().uptime.count() > 0);
 
  coordinator.shutdown();
}

References ASSERT_FALSE, ASSERT_TRUE, database::integrated::database_coordinator::get_stats(), database::integrated::database_coordinator::initialize(), and database::integrated::database_coordinator::shutdown().

Here is the call graph for this function:

test_thread_pool_functionality()

void test_thread_pool_functionality

(

)

Definition at line 152 of file test_database_coordinator.cpp.

                                {
  unified_db_config config;
  // config.logger.enable_console_logging does not exist
  config.thread.thread_count = 2;
 
  database_coordinator coordinator(config);
  coordinator.initialize();
 
  auto *thread_pool = coordinator.get_thread_pool();
  ASSERT_TRUE(thread_pool != nullptr);
 
  // Submit a simple task
  std::atomic<bool> task_executed{false};
  auto future = thread_pool->submit([&task_executed]() {
    task_executed = true;
    return 42;
  });
 
  auto value = future.get();
  ASSERT_TRUE(value == 42);
  ASSERT_TRUE(task_executed);
 
  coordinator.shutdown();
}

References ASSERT_TRUE, database::integrated::database_coordinator::get_thread_pool(), database::integrated::database_coordinator::initialize(), database::integrated::database_coordinator::shutdown(), database::integrated::unified_db_config::thread, and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

Variable Documentation

tests_failed

int tests_failed = 0

Definition at line 30 of file test_database_coordinator.cpp.

Referenced by main().

tests_passed

int tests_passed = 0

Definition at line 29 of file test_database_coordinator.cpp.

Referenced by main().