test_data_consistency.cpp File Reference

#include <gtest/gtest.h>
#include <atomic>
#include <chrono>
#include <thread>
#include <vector>
#include <kcenon/monitoring/reliability/data_consistency.h>

Include dependency graph for test_data_consistency.cpp:

Go to the source code of this file.

Classes
class	DataConsistencyTest

Functions
	TEST_F (DataConsistencyTest, TransactionOperationBasic)
	TEST_F (DataConsistencyTest, TransactionCommitSuccess)
	TEST_F (DataConsistencyTest, TransactionRollbackOnFailure)
	TEST_F (DataConsistencyTest, TransactionManualAbort)
	TEST_F (DataConsistencyTest, TransactionTimeout)
	TEST_F (DataConsistencyTest, StateValidatorBasicValidation)
	TEST_F (DataConsistencyTest, StateValidatorFailureAndRepair)
	TEST_F (DataConsistencyTest, StateValidatorContinuousValidation)
	TEST_F (DataConsistencyTest, TransactionManagerBasicOperations)
	TEST_F (DataConsistencyTest, TransactionManagerAbort)
	TEST_F (DataConsistencyTest, TransactionManagerDuplicateTransaction)
	TEST_F (DataConsistencyTest, TransactionManagerDeadlockDetection)
	TEST_F (DataConsistencyTest, TransactionManagerCleanup)
	TEST_F (DataConsistencyTest, DataConsistencyManagerTransactionManagers)
	TEST_F (DataConsistencyTest, DataConsistencyManagerStateValidators)
	TEST_F (DataConsistencyTest, DataConsistencyManagerGlobalOperations)
	TEST_F (DataConsistencyTest, DataConsistencyManagerHealthCheck)
	TEST_F (DataConsistencyTest, DataConsistencyManagerMetrics)
	TEST_F (DataConsistencyTest, TransactionConfigValidation)
	TEST_F (DataConsistencyTest, ValidationConfigValidation)
	TEST_F (DataConsistencyTest, ConcurrentTransactions)
	TEST_F (DataConsistencyTest, FactoryFunctions)

Function Documentation

TEST_F() [1/22]

TEST_F	(	DataConsistencyTest	,
		ConcurrentTransactions	)

Definition at line 500 of file test_data_consistency.cpp.

                                                    {
    transaction_config config;
    transaction_manager manager("concurrent_manager", config);
 
    const int num_threads = 5;
    const int transactions_per_thread = 10;
    std::atomic<int> successful_transactions{0};
 
    std::vector<std::thread> threads;
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([&, i]() {
            for (int j = 0; j < transactions_per_thread; ++j) {
                std::string tx_id = "tx_" + std::to_string(i) + "_" + std::to_string(j);
 
                auto begin_result = manager.begin_transaction(tx_id);
                if (begin_result.is_ok()) {
                    auto tx = begin_result.value();
 
                    auto op = std::make_unique<transaction_operation>(
                        "op", [this]() { return test_operation(); });
                    tx->add_operation(std::move(op));
 
                    auto commit_result = manager.commit_transaction(tx_id);
                    if (commit_result) {
                        successful_transactions++;
                    }
                }
            }
        });
    }
 
    for (auto& thread : threads) {
        thread.join();
    }
 
    EXPECT_EQ(successful_transactions.load(), num_threads * transactions_per_thread);
 
    const auto& metrics = manager.get_metrics();
    EXPECT_EQ(metrics.total_transactions.load(), num_threads * transactions_per_thread);
    EXPECT_EQ(metrics.committed_transactions.load(), num_threads * transactions_per_thread);
}

References kcenon::monitoring::transaction_manager::begin_transaction(), kcenon::monitoring::transaction_manager::commit_transaction(), and kcenon::monitoring::transaction_manager::get_metrics().

Here is the call graph for this function:

TEST_F() [2/22]

TEST_F	(	DataConsistencyTest	,
		DataConsistencyManagerGlobalOperations	)

Definition at line 393 of file test_data_consistency.cpp.

                                                                    {
    data_consistency_manager consistency_manager("test_consistency");
 
    // Add validators
    validation_config config;
    config.validation_interval = std::chrono::milliseconds(100);
 
    consistency_manager.add_state_validator("validator1", config);
    consistency_manager.add_state_validator("validator2", config);
 
    // Start all validators
    auto start_result = consistency_manager.start_all_validators();
    EXPECT_TRUE(start_result.is_ok());
 
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
    // Stop all validators
    auto stop_result = consistency_manager.stop_all_validators();
    EXPECT_TRUE(stop_result.is_ok());
}

References kcenon::monitoring::data_consistency_manager::add_state_validator(), kcenon::monitoring::data_consistency_manager::start_all_validators(), kcenon::monitoring::data_consistency_manager::stop_all_validators(), and kcenon::monitoring::validation_config::validation_interval.

Here is the call graph for this function:

TEST_F() [3/22]

TEST_F	(	DataConsistencyTest	,
		DataConsistencyManagerHealthCheck	)

Definition at line 414 of file test_data_consistency.cpp.

                                                               {
    data_consistency_manager consistency_manager("test_consistency");
 
    // Add components
    transaction_config tx_config;
    consistency_manager.add_transaction_manager("tx_manager", tx_config);
 
    validation_config val_config;
    consistency_manager.add_state_validator("validator", val_config);
 
    // Should be healthy initially
    auto health = consistency_manager.is_healthy();
    EXPECT_TRUE(health.is_ok());
    EXPECT_TRUE(health.value());
}

References kcenon::monitoring::data_consistency_manager::add_state_validator(), kcenon::monitoring::data_consistency_manager::add_transaction_manager(), and kcenon::monitoring::data_consistency_manager::is_healthy().

Here is the call graph for this function:

TEST_F() [4/22]

TEST_F	(	DataConsistencyTest	,
		DataConsistencyManagerMetrics	)

Definition at line 430 of file test_data_consistency.cpp.

                                                           {
    data_consistency_manager consistency_manager("test_consistency");
    
    // Add components
    transaction_config tx_config;
    consistency_manager.add_transaction_manager("tx_manager", tx_config);
    
    validation_config val_config;
    consistency_manager.add_state_validator("validator", val_config);
    
    // Get all metrics
    auto all_metrics = consistency_manager.get_all_metrics();
    EXPECT_EQ(all_metrics.size(), 2);
    EXPECT_TRUE(all_metrics.find("tx_manager_transactions") != all_metrics.end());
    EXPECT_TRUE(all_metrics.find("validator_validation") != all_metrics.end());
}

References kcenon::monitoring::data_consistency_manager::add_state_validator(), kcenon::monitoring::data_consistency_manager::add_transaction_manager(), and kcenon::monitoring::data_consistency_manager::get_all_metrics().

Here is the call graph for this function:

TEST_F() [5/22]

TEST_F	(	DataConsistencyTest	,
		DataConsistencyManagerStateValidators	)

Definition at line 381 of file test_data_consistency.cpp.

                                                                   {
    data_consistency_manager consistency_manager("test_consistency");
 
    validation_config val_config;
    auto add_result = consistency_manager.add_state_validator("validator", val_config);
    EXPECT_TRUE(add_result.is_ok());
 
    auto* validator = consistency_manager.get_state_validator("validator");
    EXPECT_NE(validator, nullptr);
    EXPECT_EQ(validator->get_name(), "validator");
}

References kcenon::monitoring::data_consistency_manager::add_state_validator(), and kcenon::monitoring::data_consistency_manager::get_state_validator().

Here is the call graph for this function:

TEST_F() [6/22]

TEST_F	(	DataConsistencyTest	,
		DataConsistencyManagerTransactionManagers	)

Definition at line 364 of file test_data_consistency.cpp.

                                                                       {
    data_consistency_manager consistency_manager("test_consistency");
 
    transaction_config tx_config;
    auto add_result = consistency_manager.add_transaction_manager("tx_manager", tx_config);
    EXPECT_TRUE(add_result.is_ok());
 
    auto* manager = consistency_manager.get_transaction_manager("tx_manager");
    EXPECT_NE(manager, nullptr);
    EXPECT_EQ(manager->get_name(), "tx_manager");
 
    // Should fail to add duplicate
    auto duplicate_result = consistency_manager.add_transaction_manager("tx_manager", tx_config);
    EXPECT_FALSE(duplicate_result.is_ok());
    EXPECT_EQ(duplicate_result.error().code, static_cast<int>(monitoring_error_code::already_exists));
}

References kcenon::monitoring::data_consistency_manager::add_transaction_manager(), and kcenon::monitoring::data_consistency_manager::get_transaction_manager().

Here is the call graph for this function:

TEST_F() [7/22]

TEST_F	(	DataConsistencyTest	,
		FactoryFunctions	)

Definition at line 543 of file test_data_consistency.cpp.

                                              {
    auto tx_manager = create_transaction_manager("factory_tx_manager");
    EXPECT_NE(tx_manager, nullptr);
    EXPECT_EQ(tx_manager->get_name(), "factory_tx_manager");
    
    auto validator = create_state_validator("factory_validator");
    EXPECT_NE(validator, nullptr);
    EXPECT_EQ(validator->get_name(), "factory_validator");
    
    auto consistency_manager = create_data_consistency_manager("factory_consistency");
    EXPECT_NE(consistency_manager, nullptr);
}

References kcenon::monitoring::create_data_consistency_manager(), kcenon::monitoring::create_state_validator(), and kcenon::monitoring::create_transaction_manager().

Here is the call graph for this function:

TEST_F() [8/22]

TEST_F	(	DataConsistencyTest	,
		StateValidatorBasicValidation	)

Definition at line 176 of file test_data_consistency.cpp.

                                                           {
    validation_config config;
    config.validation_interval = std::chrono::milliseconds(100);
    state_validator validator("test_validator", config);
    
    // Add validation rule
    auto add_result = validator.add_validation_rule(
        "test_rule",
        [this]() { return test_validation(); },
        [this]() { return test_repair(); }
    );
    EXPECT_TRUE(add_result);
    
    // Manual validation
    auto validation_res = validator.validate();
    EXPECT_TRUE(validation_res.is_ok());
 
    auto results = validation_res.value();
    EXPECT_EQ(results.size(), 1);
    EXPECT_EQ(results["test_rule"], validation_result::valid);
 
    auto health = validator.is_healthy();
    EXPECT_TRUE(health.is_ok());
    EXPECT_TRUE(health.value());
}

References kcenon::monitoring::state_validator::add_validation_rule(), kcenon::monitoring::state_validator::is_healthy(), kcenon::monitoring::state_validator::validate(), and kcenon::monitoring::validation_config::validation_interval.

Here is the call graph for this function:

TEST_F() [9/22]

TEST_F	(	DataConsistencyTest	,
		StateValidatorContinuousValidation	)

Definition at line 233 of file test_data_consistency.cpp.

                                                                {
    validation_config config;
    config.validation_interval = std::chrono::milliseconds(50);
    state_validator validator("test_validator", config);
 
    std::atomic<int> validation_calls{0};
    validator.add_validation_rule(
        "continuous_rule",
        [&validation_calls]() {
            validation_calls++;
            return validation_result::valid;
        }
    );
 
    // Start continuous validation
    auto start_result = validator.start();
    EXPECT_TRUE(start_result.is_ok());
 
    // Wait for several validation cycles (400ms with 50ms interval = at least 6-7 cycles)
    // Using 400ms to account for scheduling delays on various platforms (especially macOS)
    std::this_thread::sleep_for(std::chrono::milliseconds(400));
 
    // Stop validation
    auto stop_result = validator.stop();
    EXPECT_TRUE(stop_result.is_ok());
 
    // Should have run multiple validations (at least 2 with 400ms wait)
    // Using >= 2 to be robust against platform-specific scheduling delays
    EXPECT_GE(validation_calls.load(), 2);
}

References kcenon::monitoring::state_validator::add_validation_rule(), kcenon::monitoring::state_validator::start(), kcenon::monitoring::state_validator::stop(), and kcenon::monitoring::validation_config::validation_interval.

Here is the call graph for this function:

TEST_F() [10/22]

TEST_F	(	DataConsistencyTest	,
		StateValidatorFailureAndRepair	)

Definition at line 202 of file test_data_consistency.cpp.

                                                            {
    validation_config config;
    config.enable_auto_repair = true;
    state_validator validator("test_validator", config);
 
    // Add validation rule that fails initially
    std::atomic<bool> should_fail{true};
    validator.add_validation_rule(
        "failing_rule",
        [&should_fail]() {
            return should_fail.load() ? validation_result::invalid : validation_result::valid;
        },
        [&should_fail]() {
            should_fail = false; // Repair fixes the issue
            return common::ok();
        }
    );
 
    // First validation should fail and trigger repair
    auto validation_res = validator.validate();
    EXPECT_TRUE(validation_res.is_ok());
 
    auto results = validation_res.value();
    EXPECT_EQ(results["failing_rule"], validation_result::invalid);
    EXPECT_EQ(results["failing_rule_after_repair"], validation_result::valid);
 
    const auto& metrics = validator.get_metrics();
    EXPECT_EQ(metrics.validation_runs.load(), 1);
    EXPECT_EQ(metrics.repair_operations.load(), 1);
}

References kcenon::monitoring::state_validator::add_validation_rule(), kcenon::monitoring::validation_config::enable_auto_repair, kcenon::monitoring::state_validator::get_metrics(), and kcenon::monitoring::state_validator::validate().

Here is the call graph for this function:

TEST_F() [11/22]

TEST_F	(	DataConsistencyTest	,
		TransactionCommitSuccess	)

Definition at line 87 of file test_data_consistency.cpp.

                                                      {
    transaction_config config;
    transaction tx("test_tx", config);
    
    // Add operations
    auto op1 = std::make_unique<transaction_operation>(
        "op1", [this]() { return test_operation(); });
    auto op2 = std::make_unique<transaction_operation>(
        "op2", [this]() { return test_operation(); });
    
    auto add_result1 = tx.add_operation(std::move(op1));
    auto add_result2 = tx.add_operation(std::move(op2));
    EXPECT_TRUE(add_result1);
    EXPECT_TRUE(add_result2);
    
    EXPECT_EQ(tx.operation_count(), 2);
    EXPECT_EQ(tx.state(), transaction_state::active);
    
    // Commit transaction
    auto commit_result = tx.commit();
    EXPECT_TRUE(commit_result);
    EXPECT_EQ(tx.state(), transaction_state::committed);
    EXPECT_EQ(call_count.load(), 2);
    EXPECT_EQ(success_count.load(), 2);
}

References kcenon::monitoring::transaction::add_operation(), kcenon::monitoring::transaction::commit(), kcenon::monitoring::transaction::operation_count(), and kcenon::monitoring::transaction::state().

Here is the call graph for this function:

TEST_F() [12/22]

TEST_F	(	DataConsistencyTest	,
		TransactionConfigValidation	)

Definition at line 448 of file test_data_consistency.cpp.

                                                         {
    transaction_config config;
    
    // Valid config
    config.timeout = std::chrono::seconds(30);
    config.lock_timeout = std::chrono::seconds(10);
    config.max_retries = 3;
    EXPECT_TRUE(config.validate());
    
    // Invalid timeout
    config.timeout = std::chrono::milliseconds(0);
    EXPECT_FALSE(config.validate());
    
    // Invalid lock timeout
    config.timeout = std::chrono::seconds(30);
    config.lock_timeout = std::chrono::milliseconds(0);
    EXPECT_FALSE(config.validate());
    
    // Invalid max retries
    config.lock_timeout = std::chrono::seconds(10);
    config.max_retries = 0;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::transaction_config::lock_timeout, kcenon::monitoring::transaction_config::max_retries, kcenon::monitoring::transaction_config::timeout, and kcenon::monitoring::transaction_config::validate().

Here is the call graph for this function:

TEST_F() [13/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManagerAbort	)

Definition at line 293 of file test_data_consistency.cpp.

                                                     {
    transaction_config config;
    transaction_manager manager("test_manager", config);
 
    auto begin_result = manager.begin_transaction("tx1");
    EXPECT_TRUE(begin_result.is_ok());
 
    auto abort_result = manager.abort_transaction("tx1");
    EXPECT_TRUE(abort_result);
 
    const auto& metrics = manager.get_metrics();
    EXPECT_EQ(metrics.total_transactions.load(), 1);
    EXPECT_EQ(metrics.committed_transactions.load(), 0);
    EXPECT_EQ(metrics.aborted_transactions.load(), 1);
    EXPECT_NEAR(metrics.get_abort_rate(), 1.0, 0.01);
}

References kcenon::monitoring::transaction_manager::abort_transaction(), kcenon::monitoring::transaction_manager::begin_transaction(), and kcenon::monitoring::transaction_manager::get_metrics().

Here is the call graph for this function:

TEST_F() [14/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManagerBasicOperations	)

Definition at line 265 of file test_data_consistency.cpp.

                                                               {
    transaction_config config;
    transaction_manager manager("test_manager", config);
 
    // Begin transaction
    auto begin_result = manager.begin_transaction("tx1");
    EXPECT_TRUE(begin_result.is_ok());
 
    auto tx = begin_result.value();
    EXPECT_EQ(tx->id(), "tx1");
    EXPECT_EQ(tx->state(), transaction_state::active);
    EXPECT_EQ(manager.active_transaction_count(), 1);
 
    // Add operation and commit
    auto op = std::make_unique<transaction_operation>("op", [this]() { return test_operation(); });
    tx->add_operation(std::move(op));
 
    auto commit_result = manager.commit_transaction("tx1");
    EXPECT_TRUE(commit_result);
    EXPECT_EQ(manager.active_transaction_count(), 0);
    EXPECT_EQ(manager.completed_transaction_count(), 1);
 
    const auto& metrics = manager.get_metrics();
    EXPECT_EQ(metrics.total_transactions.load(), 1);
    EXPECT_EQ(metrics.committed_transactions.load(), 1);
    EXPECT_EQ(metrics.aborted_transactions.load(), 0);
}

References kcenon::monitoring::transaction_manager::active_transaction_count(), kcenon::monitoring::transaction_manager::begin_transaction(), kcenon::monitoring::transaction_manager::commit_transaction(), kcenon::monitoring::transaction_manager::completed_transaction_count(), and kcenon::monitoring::transaction_manager::get_metrics().

Here is the call graph for this function:

TEST_F() [15/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManagerCleanup	)

Definition at line 344 of file test_data_consistency.cpp.

                                                       {
    transaction_config config;
    transaction_manager manager("test_manager", config);
 
    // Create and commit transaction
    auto begin_result = manager.begin_transaction("tx1");
    EXPECT_TRUE(begin_result.is_ok());
 
    auto op = std::make_unique<transaction_operation>("op", [this]() { return test_operation(); });
    begin_result.value()->add_operation(std::move(op));
 
    manager.commit_transaction("tx1");
    EXPECT_EQ(manager.completed_transaction_count(), 1);
 
    // Cleanup should remove old transactions
    manager.cleanup_completed_transactions(std::chrono::milliseconds(0));
    EXPECT_EQ(manager.completed_transaction_count(), 0);
}

References kcenon::monitoring::transaction_manager::begin_transaction(), kcenon::monitoring::transaction_manager::cleanup_completed_transactions(), kcenon::monitoring::transaction_manager::commit_transaction(), and kcenon::monitoring::transaction_manager::completed_transaction_count().

Here is the call graph for this function:

TEST_F() [16/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManagerDeadlockDetection	)

Definition at line 323 of file test_data_consistency.cpp.

                                                                 {
    transaction_config config;
    config.timeout = std::chrono::milliseconds(100);
    transaction_manager manager("test_manager", config);
 
    // Create long-running transaction
    auto begin_result = manager.begin_transaction("long_tx");
    EXPECT_TRUE(begin_result.is_ok());
 
    // Wait longer than timeout
    std::this_thread::sleep_for(std::chrono::milliseconds(250));
 
    auto deadlocks = manager.detect_deadlocks();
    EXPECT_TRUE(deadlocks.is_ok());
    EXPECT_EQ(deadlocks.value().size(), 1);
    EXPECT_EQ(deadlocks.value()[0], "long_tx");
 
    const auto& metrics = manager.get_metrics();
    EXPECT_EQ(metrics.deadlocks_detected.load(), 1);
}

References kcenon::monitoring::transaction_manager::begin_transaction(), kcenon::monitoring::transaction_manager::detect_deadlocks(), kcenon::monitoring::transaction_manager::get_metrics(), and kcenon::monitoring::transaction_config::timeout.

Here is the call graph for this function:

TEST_F() [17/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManagerDuplicateTransaction	)

Definition at line 310 of file test_data_consistency.cpp.

                                                                    {
    transaction_config config;
    transaction_manager manager("test_manager", config);
 
    auto begin_result1 = manager.begin_transaction("tx1");
    EXPECT_TRUE(begin_result1.is_ok());
 
    // Should fail with duplicate ID
    auto begin_result2 = manager.begin_transaction("tx1");
    EXPECT_FALSE(begin_result2.is_ok());
    EXPECT_EQ(begin_result2.error().code, static_cast<int>(monitoring_error_code::already_exists));
}

References kcenon::monitoring::transaction_manager::begin_transaction().

Here is the call graph for this function:

TEST_F() [18/22]

TEST_F	(	DataConsistencyTest	,
		TransactionManualAbort	)

Definition at line 137 of file test_data_consistency.cpp.

                                                    {
    transaction_config config;
    transaction tx("test_tx", config);
    
    auto op = std::make_unique<transaction_operation>(
        "op", 
        [this]() { return test_operation(); },
        [this]() { return rollback_operation(); });
    
    tx.add_operation(std::move(op));
    
    // Manually abort
    auto abort_result = tx.abort();
    EXPECT_TRUE(abort_result);
    EXPECT_EQ(tx.state(), transaction_state::aborted);
    
    // Should not be able to add more operations
    auto op2 = std::make_unique<transaction_operation>("op2", [this]() { return test_operation(); });
    auto add_result = tx.add_operation(std::move(op2));
    EXPECT_FALSE(add_result);
}

References kcenon::monitoring::transaction::abort(), kcenon::monitoring::transaction::add_operation(), and kcenon::monitoring::transaction::state().

Here is the call graph for this function:

TEST_F() [19/22]

TEST_F	(	DataConsistencyTest	,
		TransactionOperationBasic	)

Definition at line 65 of file test_data_consistency.cpp.

                                                       {
    auto op = std::make_unique<transaction_operation>(
        "test_op",
        [this]() { return test_operation(); },
        [this]() { return rollback_operation(); }
    );
    
    EXPECT_EQ(op->name(), "test_op");
    EXPECT_FALSE(op->is_executed());
    
    auto result = op->execute();
    EXPECT_TRUE(result.is_ok());
    EXPECT_TRUE(op->is_executed());
    EXPECT_EQ(call_count.load(), 1);
    EXPECT_EQ(success_count.load(), 1);
    
    auto rollback_result = op->rollback();
    EXPECT_TRUE(rollback_result);
    EXPECT_EQ(rollback_count.load(), 1);
}

TEST_F() [20/22]

TEST_F	(	DataConsistencyTest	,
		TransactionRollbackOnFailure	)

Definition at line 113 of file test_data_consistency.cpp.

                                                          {
    transaction_config config;
    transaction tx("test_tx", config);
    
    // Add operations - second one will fail
    auto op1 = std::make_unique<transaction_operation>(
        "op1", 
        [this]() { return test_operation(); },
        [this]() { return rollback_operation(); });
    auto op2 = std::make_unique<transaction_operation>(
        "op2", [this]() { return failing_operation(); });
    
    tx.add_operation(std::move(op1));
    tx.add_operation(std::move(op2));
    
    // Commit should fail and rollback
    auto commit_result = tx.commit();
    EXPECT_FALSE(commit_result);
    EXPECT_EQ(tx.state(), transaction_state::aborted);
    EXPECT_EQ(call_count.load(), 2); // Both operations attempted
    EXPECT_EQ(success_count.load(), 1); // Only first succeeded
    EXPECT_EQ(rollback_count.load(), 1); // First operation rolled back
}

References kcenon::monitoring::transaction::add_operation(), kcenon::monitoring::transaction::commit(), and kcenon::monitoring::transaction::state().

Here is the call graph for this function:

TEST_F() [21/22]

TEST_F	(	DataConsistencyTest	,
		TransactionTimeout	)

Definition at line 159 of file test_data_consistency.cpp.

                                                {
    transaction_config config;
    config.timeout = std::chrono::milliseconds(50);
    transaction tx("test_tx", config);
    
    auto op = std::make_unique<transaction_operation>("op", [this]() { return test_operation(); });
    tx.add_operation(std::move(op));
    
    // Wait for timeout
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    
    auto commit_result = tx.commit();
    EXPECT_FALSE(commit_result);
    EXPECT_EQ(tx.state(), transaction_state::aborted);
}

References kcenon::monitoring::transaction::add_operation(), kcenon::monitoring::transaction::commit(), kcenon::monitoring::transaction::state(), and kcenon::monitoring::transaction_config::timeout.

Here is the call graph for this function:

TEST_F() [22/22]

TEST_F	(	DataConsistencyTest	,
		ValidationConfigValidation	)

Definition at line 472 of file test_data_consistency.cpp.

                                                        {
    validation_config config;
    
    // Valid config
    config.validation_interval = std::chrono::seconds(60);
    config.max_validation_failures = 5;
    config.corruption_threshold = 0.1;
    EXPECT_TRUE(config.validate());
    
    // Invalid validation interval
    config.validation_interval = std::chrono::milliseconds(0);
    EXPECT_FALSE(config.validate());
    
    // Invalid max failures
    config.validation_interval = std::chrono::seconds(60);
    config.max_validation_failures = 0;
    EXPECT_FALSE(config.validate());
    
    // Invalid corruption threshold
    config.max_validation_failures = 5;
    config.corruption_threshold = -0.1;
    EXPECT_FALSE(config.validate());
    
    config.corruption_threshold = 1.1;
    EXPECT_FALSE(config.validate());
}

References kcenon::monitoring::validation_config::corruption_threshold, kcenon::monitoring::validation_config::max_validation_failures, kcenon::monitoring::validation_config::validate(), and kcenon::monitoring::validation_config::validation_interval.

Here is the call graph for this function: