#include <gtest/gtest.h>
#include <atomic>
#include <chrono>
#include <future>
#include <string>
#include <thread>
#include <vector>
#include "database/async/async_operations.h"
#include "database/core/database_backend.h"

Include dependency graph for test_async_operations.cpp:

Classes
class	AsyncResultTest

class	AsyncExecutorTest

class	AsyncDatabaseTest

class	TransactionCoordinatorTest

class	SagaBuilderTest

class	StreamProcessorTest

Functions
	TEST_F (AsyncResultTest, ConstructsFromFuture)

	TEST_F (AsyncResultTest, GetReturnsValue)

	TEST_F (AsyncResultTest, GetReturnsStringValue)

	TEST_F (AsyncResultTest, GetRethrowsException)

	TEST_F (AsyncResultTest, GetInvokesSuccessCallback)

	TEST_F (AsyncResultTest, GetInvokesErrorCallback)

	TEST_F (AsyncResultTest, GetForReturnsValueWithinTimeout)

	TEST_F (AsyncResultTest, GetForThrowsOnTimeout)

	TEST_F (AsyncResultTest, IsReadyReturnsFalseBeforeCompletion)

	TEST_F (AsyncResultTest, IsReadyReturnsTrueWhenReady)

	TEST_F (AsyncResultTest, WaitForReturnsReadyWhenComplete)

	TEST_F (AsyncResultTest, WaitForReturnsTimeoutWhenNotReady)

	TEST_F (AsyncResultTest, ThenWithLambda)

	TEST_F (AsyncResultTest, OnErrorWithLambda)

	TEST_F (AsyncResultTest, ThenLegacyOverload)

	TEST_F (AsyncResultTest, OnErrorLegacyOverload)

	TEST_F (AsyncResultTest, NoCallbackDoesNotCrashOnSuccess)

	TEST_F (AsyncResultTest, NoErrorCallbackDoesNotCrashOnFailure)

	TEST_F (AsyncResultTest, GetBlocksUntilValueAvailable)

	TEST_F (AsyncExecutorTest, ConstructsWithCustomThreadCount)

	TEST_F (AsyncExecutorTest, ConstructsWithDefaultThreadCount)

	TEST_F (AsyncExecutorTest, IsNotUsingThreadSystem)

	TEST_F (AsyncExecutorTest, SubmitExecutesCallable)

	TEST_F (AsyncExecutorTest, SubmitWithArguments)

	TEST_F (AsyncExecutorTest, SubmitReturnsString)

	TEST_F (AsyncExecutorTest, SubmitPropagatesException)

	TEST_F (AsyncExecutorTest, MultipleConcurrentSubmissions)

	TEST_F (AsyncExecutorTest, WaitForCompletionBlocksUntilDone)

	TEST_F (AsyncExecutorTest, ShutdownAfterSubmitCompletesGracefully)

	TEST_F (AsyncExecutorTest, SubmitAfterShutdownThrows)

	TEST_F (AsyncExecutorTest, ThreadCountReturnsConfigured)

	TEST (AsyncHelpersTest, MakeReadyResultIsImmediatelyAvailable)

	TEST (AsyncHelpersTest, MakeReadyResultWithString)

	TEST (AsyncHelpersTest, MakeErrorResultThrowsOnGet)

	TEST (AsyncHelpersTest, MakeErrorResultInvokesOnErrorCallback)

	TEST_F (AsyncDatabaseTest, ConstructsWithBackendAndExecutor)

	TEST_F (AsyncDatabaseTest, ExecuteAsyncReturnsTrue)

	TEST_F (AsyncDatabaseTest, ExecuteAsyncDelegatesToBackend)

	TEST_F (AsyncDatabaseTest, ExecuteAsyncThrowsOnBackendFailure)

	TEST_F (AsyncDatabaseTest, SelectAsyncReturnsRows)

	TEST_F (AsyncDatabaseTest, ExecuteBatchAsyncProcessesAllQueries)

	TEST_F (AsyncDatabaseTest, ExecuteBatchAsyncReportsFailures)

	TEST_F (AsyncDatabaseTest, SelectBatchAsyncReturnsMultipleResults)

	TEST_F (AsyncDatabaseTest, BeginTransactionAsyncSucceeds)

	TEST_F (AsyncDatabaseTest, CommitTransactionAsyncSucceeds)

	TEST_F (AsyncDatabaseTest, RollbackTransactionAsyncSucceeds)

	TEST_F (AsyncDatabaseTest, ConnectAsyncInitializesBackend)

	TEST_F (AsyncDatabaseTest, DisconnectAsyncShutsDownBackend)

	TEST_F (AsyncDatabaseTest, ConcurrentExecuteAsyncOperations)

	TEST_F (AsyncDatabaseTest, ExecuteAsyncWithThenCallback)

	TEST_F (AsyncDatabaseTest, ExecuteAsyncWithOnErrorCallback)

	TEST_F (TransactionCoordinatorTest, BeginCreatesTransaction)

	TEST_F (TransactionCoordinatorTest, BeginGeneratesUniqueIds)

	TEST_F (TransactionCoordinatorTest, PreparePhaseSuccess)

	TEST_F (TransactionCoordinatorTest, PreparePhaseThrowsForUnknownTransaction)

	TEST_F (TransactionCoordinatorTest, PreparePhaseRollsBackOnPartialFailure)

	TEST_F (TransactionCoordinatorTest, CommitPhaseSuccess)

	TEST_F (TransactionCoordinatorTest, CommitPhaseFailsIfNotPrepared)

	TEST_F (TransactionCoordinatorTest, CommitDistributedTransactionFull2PC)

	TEST_F (TransactionCoordinatorTest, CommitDistributedTransactionFailsOnPrepare)

	TEST_F (TransactionCoordinatorTest, RollbackDistributedTransaction)

	TEST_F (TransactionCoordinatorTest, RollbackThrowsForUnknownTransaction)

	TEST_F (TransactionCoordinatorTest, RecoverCleansUpCompletedTransactions)

	TEST_F (TransactionCoordinatorTest, CreateSagaReturnsSagaBuilder)

	TEST_F (SagaBuilderTest, EmptySagaSucceeds)

	TEST_F (SagaBuilderTest, AllStepsSucceed)

	TEST_F (SagaBuilderTest, CompensatesOnActionFailure)

	TEST_F (SagaBuilderTest, CompensatesOnException)

	TEST_F (SagaBuilderTest, SingleStepSuccess)

	TEST_F (SagaBuilderTest, CompensationExceptionDoesNotBreakChain)

	TEST_F (SagaBuilderTest, AddStepReturnsSelfForChaining)

	TEST_F (StreamProcessorTest, ConstructsWithBackend)

	TEST_F (StreamProcessorTest, StartStreamReturnsTrue)

	TEST_F (StreamProcessorTest, StartStreamDuplicateReturnsFalse)

	TEST_F (StreamProcessorTest, StopStreamReturnsTrue)

	TEST_F (StreamProcessorTest, StopStreamNonExistentReturnsFalse)

	TEST_F (StreamProcessorTest, StopAllStreamsStopsMultiple)

	TEST_F (StreamProcessorTest, EventHandlerReceivesConnectedEvent)

	TEST_F (StreamProcessorTest, EventHandlerReceivesCorrectChannel)

	TEST_F (StreamProcessorTest, EventHandlerReceivesCorrectType)

	TEST_F (StreamProcessorTest, GlobalHandlerReceivesAllEvents)

	TEST_F (StreamProcessorTest, EventFilterRejectsEvent)

	TEST_F (StreamProcessorTest, EventFilterAcceptsEvent)

	TEST_F (StreamProcessorTest, FilterDoesNotAffectGlobalHandler)

	TEST_F (StreamProcessorTest, StopOneStreamDoesNotAffectOthers)

	TEST_F (StreamProcessorTest, DestructorStopsAllStreams)

	TEST_F (StreamProcessorTest, TemplateEventHandlerWithLambda)

	TEST_F (StreamProcessorTest, TemplateGlobalHandlerWithLambda)

	TEST_F (StreamProcessorTest, TemplateEventFilterWithLambda)

Function Documentation

◆ TEST() [1/4]

TEST	(	AsyncHelpersTest	,
		MakeErrorResultInvokesOnErrorCallback	)

Definition at line 378 of file test_async_operations.cpp.

                                                              {
    auto result = make_error_result<int>(std::runtime_error("callback_err"));
 
    bool error_caught = false;
    result.on_error([&error_caught](const std::exception&) {
        error_caught = true;
    });
 
    EXPECT_THROW(result.get(), std::exception);
    EXPECT_TRUE(error_caught);
}

References database::async::make_error_result().

Here is the call graph for this function:

◆ TEST() [2/4]

TEST	(	AsyncHelpersTest	,
		MakeErrorResultThrowsOnGet	)

Definition at line 369 of file test_async_operations.cpp.

                                                   {
    // Note: make_error_result takes const std::exception& which causes
    // object slicing — the thrown exception is std::exception, not the
    // derived type. This tests the actual API behavior.
    auto result = make_error_result<int>(std::runtime_error("err"));
    EXPECT_TRUE(result.is_ready());
    EXPECT_THROW(result.get(), std::exception);
}

References database::async::make_error_result().

Here is the call graph for this function:

◆ TEST() [3/4]

TEST	(	AsyncHelpersTest	,
		MakeReadyResultIsImmediatelyAvailable	)

Definition at line 357 of file test_async_operations.cpp.

                                                              {
    auto result = make_ready_result<int>(42);
    EXPECT_TRUE(result.is_ready());
    EXPECT_EQ(result.get(), 42);
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST() [4/4]

TEST	(	AsyncHelpersTest	,
		MakeReadyResultWithString	)

Definition at line 363 of file test_async_operations.cpp.

                                                  {
    auto result = make_ready_result<std::string>("hello");
    EXPECT_TRUE(result.is_ready());
    EXPECT_EQ(result.get(), "hello");
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [1/85]

TEST_F	(	AsyncDatabaseTest	,
		BeginTransactionAsyncSucceeds	)

Definition at line 596 of file test_async_operations.cpp.

                                                         {
    auto result = db_->begin_transaction_async();
    EXPECT_TRUE(result.get());
    EXPECT_TRUE(backend_->in_transaction());
}

◆ TEST_F() [2/85]

TEST_F	(	AsyncDatabaseTest	,
		CommitTransactionAsyncSucceeds	)

Definition at line 602 of file test_async_operations.cpp.

                                                          {
    db_->begin_transaction_async().get();
    auto result = db_->commit_transaction_async();
    EXPECT_TRUE(result.get());
    EXPECT_FALSE(backend_->in_transaction());
}

◆ TEST_F() [3/85]

TEST_F	(	AsyncDatabaseTest	,
		ConcurrentExecuteAsyncOperations	)

Definition at line 633 of file test_async_operations.cpp.

                                                            {
    // async_result<T> is non-movable (contains std::mutex), so we call
    // get() immediately per operation rather than collecting into a vector.
    constexpr int NUM_OPS = 20;
    std::atomic<int> success_count{0};
 
    // Submit all operations, each getting its result in a detached context
    std::vector<std::future<bool>> futures;
    futures.reserve(NUM_OPS);
    for (int i = 0; i < NUM_OPS; ++i) {
        futures.push_back(executor_->submit([this, i]() -> bool {
            auto result = backend_->execute_query(
                "INSERT INTO t VALUES (" + std::to_string(i) + ")");
            return result.is_ok();
        }));
    }
 
    for (auto& f : futures) {
        if (f.get()) {
            success_count.fetch_add(1);
        }
    }
    EXPECT_EQ(success_count.load(), NUM_OPS);
}

◆ TEST_F() [4/85]

TEST_F	(	AsyncDatabaseTest	,
		ConnectAsyncInitializesBackend	)

Definition at line 618 of file test_async_operations.cpp.

                                                          {
    auto result = db_->connect_async("host=localhost dbname=test");
    EXPECT_TRUE(result.get());
    EXPECT_TRUE(backend_->is_initialized());
}

◆ TEST_F() [5/85]

TEST_F	(	AsyncDatabaseTest	,
		ConstructsWithBackendAndExecutor	)

Definition at line 519 of file test_async_operations.cpp.

                                                            {
    EXPECT_NE(db_, nullptr);
}

◆ TEST_F() [6/85]

TEST_F	(	AsyncDatabaseTest	,
		DisconnectAsyncShutsDownBackend	)

Definition at line 624 of file test_async_operations.cpp.

                                                           {
    db_->connect_async("host=localhost").get();
    auto result = db_->disconnect_async();
    EXPECT_TRUE(result.get());
    EXPECT_FALSE(backend_->is_initialized());
}

◆ TEST_F() [7/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteAsyncDelegatesToBackend	)

Definition at line 530 of file test_async_operations.cpp.

                                                          {
    auto result = db_->execute_async("DROP TABLE IF EXISTS t");
    result.get();
    EXPECT_EQ(backend_->get_last_query(), "DROP TABLE IF EXISTS t");
}

◆ TEST_F() [8/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteAsyncReturnsTrue	)

Definition at line 525 of file test_async_operations.cpp.

                                                   {
    auto result = db_->execute_async("CREATE TABLE t (id INT)");
    EXPECT_TRUE(result.get());
}

◆ TEST_F() [9/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteAsyncThrowsOnBackendFailure	)

Definition at line 536 of file test_async_operations.cpp.

                                                              {
    backend_->set_fail_execute(true);
    auto result = db_->execute_async("BAD QUERY");
    EXPECT_THROW(result.get(), std::runtime_error);
}

◆ TEST_F() [10/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteAsyncWithOnErrorCallback	)

Definition at line 673 of file test_async_operations.cpp.

                                                           {
    backend_->set_fail_execute(true);
    auto result = db_->execute_async("BAD");
 
    std::string error_msg;
    result.on_error([&error_msg](const std::exception& e) {
        error_msg = e.what();
    });
 
    EXPECT_THROW(result.get(), std::runtime_error);
    EXPECT_EQ(error_msg, "execute_failed");
}

◆ TEST_F() [11/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteAsyncWithThenCallback	)

Definition at line 660 of file test_async_operations.cpp.

                                                        {
    auto result = db_->execute_async("CREATE TABLE t2 (id INT)");
 
    bool callback_invoked = false;
    result.then([&callback_invoked](bool success) {
        callback_invoked = true;
        EXPECT_TRUE(success);
    });
 
    result.get();
    EXPECT_TRUE(callback_invoked);
}

◆ TEST_F() [12/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteBatchAsyncProcessesAllQueries	)

Definition at line 553 of file test_async_operations.cpp.

                                                                {
    std::vector<std::string> queries = {
        "INSERT INTO t VALUES (1)",
        "INSERT INTO t VALUES (2)",
        "INSERT INTO t VALUES (3)"
    };
    auto result = db_->execute_batch_async(queries);
    auto results = result.get();
 
    ASSERT_EQ(results.size(), 3u);
    EXPECT_TRUE(results[0]);
    EXPECT_TRUE(results[1]);
    EXPECT_TRUE(results[2]);
}

References ASSERT_EQ.

◆ TEST_F() [13/85]

TEST_F	(	AsyncDatabaseTest	,
		ExecuteBatchAsyncReportsFailures	)

Definition at line 568 of file test_async_operations.cpp.

                                                            {
    backend_->set_fail_execute(true);
    std::vector<std::string> queries = {"Q1", "Q2"};
    auto result = db_->execute_batch_async(queries);
    auto results = result.get();
 
    ASSERT_EQ(results.size(), 2u);
    EXPECT_FALSE(results[0]);
    EXPECT_FALSE(results[1]);
}

References ASSERT_EQ.

◆ TEST_F() [14/85]

TEST_F	(	AsyncDatabaseTest	,
		RollbackTransactionAsyncSucceeds	)

Definition at line 609 of file test_async_operations.cpp.

                                                            {
    db_->begin_transaction_async().get();
    auto result = db_->rollback_transaction_async();
    EXPECT_TRUE(result.get());
    EXPECT_FALSE(backend_->in_transaction());
}

◆ TEST_F() [15/85]

TEST_F	(	AsyncDatabaseTest	,
		SelectAsyncReturnsRows	)

Definition at line 544 of file test_async_operations.cpp.

                                                  {
    auto result = db_->select_async("SELECT * FROM t");
    auto rows = result.get();
    ASSERT_EQ(rows.size(), 1u);
    EXPECT_EQ(std::get<std::string>(rows[0].at("name")), "stub_row");
}

References ASSERT_EQ.

◆ TEST_F() [16/85]

TEST_F	(	AsyncDatabaseTest	,
		SelectBatchAsyncReturnsMultipleResults	)

Definition at line 581 of file test_async_operations.cpp.

                                                                  {
    std::vector<std::string> queries = {
        "SELECT * FROM t",
        "SELECT * FROM t"
    };
    auto result = db_->select_batch_async(queries);
    auto results = result.get();
 
    ASSERT_EQ(results.size(), 2u);
    EXPECT_EQ(results[0].size(), 1u);
    EXPECT_EQ(results[1].size(), 1u);
}

References ASSERT_EQ.

◆ TEST_F() [17/85]

TEST_F	(	AsyncExecutorTest	,
		ConstructsWithCustomThreadCount	)

Definition at line 255 of file test_async_operations.cpp.

                                                           {
    EXPECT_EQ(executor_->thread_count(), 2u);
}

◆ TEST_F() [18/85]

TEST_F	(	AsyncExecutorTest	,
		ConstructsWithDefaultThreadCount	)

Definition at line 259 of file test_async_operations.cpp.

                                                            {
    auto exec = std::make_unique<async_executor>();
    EXPECT_EQ(exec->thread_count(), std::thread::hardware_concurrency());
    exec->shutdown();
}

◆ TEST_F() [19/85]

TEST_F	(	AsyncExecutorTest	,
		IsNotUsingThreadSystem	)

Definition at line 265 of file test_async_operations.cpp.

                                                  {
    EXPECT_FALSE(executor_->is_using_thread_system());
}

◆ TEST_F() [20/85]

TEST_F	(	AsyncExecutorTest	,
		MultipleConcurrentSubmissions	)

Definition at line 297 of file test_async_operations.cpp.

                                                         {
    constexpr int NUM_TASKS = 100;
    std::vector<std::future<int>> futures;
    futures.reserve(NUM_TASKS);
 
    for (int i = 0; i < NUM_TASKS; ++i) {
        futures.push_back(executor_->submit([i]() { return i * 2; }));
    }
 
    for (int i = 0; i < NUM_TASKS; ++i) {
        EXPECT_EQ(futures[i].get(), i * 2);
    }
}

◆ TEST_F() [21/85]

TEST_F	(	AsyncExecutorTest	,
		ShutdownAfterSubmitCompletesGracefully	)

Definition at line 332 of file test_async_operations.cpp.

                                                                  {
    auto future = executor_->submit([]() { return 1; });
    executor_->shutdown();
    EXPECT_EQ(future.get(), 1);
}

◆ TEST_F() [22/85]

TEST_F	(	AsyncExecutorTest	,
		SubmitAfterShutdownThrows	)

Definition at line 338 of file test_async_operations.cpp.

                                                     {
    executor_->shutdown();
    EXPECT_THROW(
        executor_->submit([]() { return 0; }),
        std::runtime_error);
}

◆ TEST_F() [23/85]

TEST_F	(	AsyncExecutorTest	,
		SubmitExecutesCallable	)

Definition at line 271 of file test_async_operations.cpp.

                                                  {
    auto future = executor_->submit([]() { return 42; });
    EXPECT_EQ(future.get(), 42);
}

◆ TEST_F() [24/85]

TEST_F	(	AsyncExecutorTest	,
		SubmitPropagatesException	)

Definition at line 288 of file test_async_operations.cpp.

                                                     {
    auto future = executor_->submit([]() -> int {
        throw std::runtime_error("task_failed");
    });
    EXPECT_THROW(future.get(), std::runtime_error);
}

◆ TEST_F() [25/85]

TEST_F	(	AsyncExecutorTest	,
		SubmitReturnsString	)

Definition at line 281 of file test_async_operations.cpp.

                                               {
    auto future = executor_->submit([]() -> std::string {
        return "async_result";
    });
    EXPECT_EQ(future.get(), "async_result");
}

◆ TEST_F() [26/85]

TEST_F	(	AsyncExecutorTest	,
		SubmitWithArguments	)

Definition at line 276 of file test_async_operations.cpp.

                                               {
    auto future = executor_->submit([](int a, int b) { return a + b; }, 3, 7);
    EXPECT_EQ(future.get(), 10);
}

◆ TEST_F() [27/85]

TEST_F	(	AsyncExecutorTest	,
		ThreadCountReturnsConfigured	)

Definition at line 347 of file test_async_operations.cpp.

                                                        {
    async_executor exec4(4);
    EXPECT_EQ(exec4.thread_count(), 4u);
    exec4.shutdown();
}

References database::async::async_executor::shutdown(), and database::async::async_executor::thread_count().

Here is the call graph for this function:

◆ TEST_F() [28/85]

TEST_F	(	AsyncExecutorTest	,
		WaitForCompletionBlocksUntilDone	)

Definition at line 313 of file test_async_operations.cpp.

                                                            {
    std::atomic<int> counter{0};
 
    for (int i = 0; i < 10; ++i) {
        executor_->submit([&counter]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
            counter.fetch_add(1);
        });
    }
 
    executor_->wait_for_completion();
    // Allow brief settling time for tasks that are executing but haven't
    // decremented the queue yet
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    EXPECT_EQ(counter.load(), 10);
}

◆ TEST_F() [29/85]

TEST_F	(	AsyncResultTest	,
		ConstructsFromFuture	)

Definition at line 60 of file test_async_operations.cpp.

                                              {
    std::promise<int> p;
    auto future = p.get_future();
    p.set_value(42);
 
    async_result<int> result(std::move(future));
    EXPECT_TRUE(result.is_ready());
}

References database::async::async_result< T >::is_ready().

Here is the call graph for this function:

◆ TEST_F() [30/85]

TEST_F	(	AsyncResultTest	,
		GetBlocksUntilValueAvailable	)

Definition at line 221 of file test_async_operations.cpp.

                                                      {
    std::promise<int> p;
    async_result<int> result(p.get_future());
 
    std::thread setter([&p]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        p.set_value(123);
    });
 
    EXPECT_EQ(result.get(), 123);
    setter.join();
}

References database::async::async_result< T >::get().

Here is the call graph for this function:

◆ TEST_F() [31/85]

TEST_F	(	AsyncResultTest	,
		GetForReturnsValueWithinTimeout	)

Definition at line 110 of file test_async_operations.cpp.

                                                         {
    auto result = make_ready<int>(77);
    EXPECT_EQ(result.get_for(std::chrono::milliseconds(100)), 77);
}

◆ TEST_F() [32/85]

TEST_F	(	AsyncResultTest	,
		GetForThrowsOnTimeout	)

Definition at line 115 of file test_async_operations.cpp.

                                               {
    std::promise<int> p;
    async_result<int> result(p.get_future());
 
    EXPECT_THROW(
        result.get_for(std::chrono::milliseconds(10)),
        std::runtime_error);
}

References database::async::async_result< T >::get_for().

Here is the call graph for this function:

◆ TEST_F() [33/85]

TEST_F	(	AsyncResultTest	,
		GetInvokesErrorCallback	)

Definition at line 96 of file test_async_operations.cpp.

                                                 {
    auto result = make_failing<int>();
 
    std::string captured_msg;
    result.on_error([&captured_msg](const std::exception& e) {
        captured_msg = e.what();
    });
 
    EXPECT_THROW(result.get(), std::runtime_error);
    EXPECT_EQ(captured_msg, "test_error");
}

◆ TEST_F() [34/85]

TEST_F	(	AsyncResultTest	,
		GetInvokesSuccessCallback	)

Definition at line 86 of file test_async_operations.cpp.

                                                   {
    auto result = make_ready<int>(42);
 
    int captured = 0;
    result.then([&captured](int v) { captured = v; });
 
    EXPECT_EQ(result.get(), 42);
    EXPECT_EQ(captured, 42);
}

◆ TEST_F() [35/85]

TEST_F	(	AsyncResultTest	,
		GetRethrowsException	)

Definition at line 81 of file test_async_operations.cpp.

                                              {
    auto result = make_failing<int>();
    EXPECT_THROW(result.get(), std::runtime_error);
}

◆ TEST_F() [36/85]

TEST_F	(	AsyncResultTest	,
		GetReturnsStringValue	)

Definition at line 76 of file test_async_operations.cpp.

                                               {
    auto result = make_ready<std::string>("hello");
    EXPECT_EQ(result.get(), "hello");
}

◆ TEST_F() [37/85]

TEST_F	(	AsyncResultTest	,
		GetReturnsValue	)

Definition at line 71 of file test_async_operations.cpp.

                                         {
    auto result = make_ready<int>(99);
    EXPECT_EQ(result.get(), 99);
}

◆ TEST_F() [38/85]

TEST_F	(	AsyncResultTest	,
		IsReadyReturnsFalseBeforeCompletion	)

Definition at line 126 of file test_async_operations.cpp.

                                                             {
    std::promise<int> p;
    async_result<int> result(p.get_future());
    EXPECT_FALSE(result.is_ready());
 
    p.set_value(1);
    EXPECT_TRUE(result.is_ready());
}

References database::async::async_result< T >::is_ready().

Here is the call graph for this function:

◆ TEST_F() [39/85]

TEST_F	(	AsyncResultTest	,
		IsReadyReturnsTrueWhenReady	)

Definition at line 135 of file test_async_operations.cpp.

                                                     {
    auto result = make_ready<int>(1);
    EXPECT_TRUE(result.is_ready());
}

◆ TEST_F() [40/85]

TEST_F	(	AsyncResultTest	,
		NoCallbackDoesNotCrashOnSuccess	)

Definition at line 209 of file test_async_operations.cpp.

                                                         {
    auto result = make_ready<int>(42);
    EXPECT_NO_THROW(result.get());
}

◆ TEST_F() [41/85]

TEST_F	(	AsyncResultTest	,
		NoErrorCallbackDoesNotCrashOnFailure	)

Definition at line 214 of file test_async_operations.cpp.

                                                              {
    auto result = make_failing<int>();
    EXPECT_THROW(result.get(), std::runtime_error);
}

◆ TEST_F() [42/85]

TEST_F	(	AsyncResultTest	,
		OnErrorLegacyOverload	)

Definition at line 195 of file test_async_operations.cpp.

                                               {
    auto result = make_failing<int>();
 
    std::string msg;
    std::function<void(const std::exception&)> cb =
        [&msg](const std::exception& e) { msg = e.what(); };
    result.on_error(cb);
 
    EXPECT_THROW(result.get(), std::runtime_error);
    EXPECT_EQ(msg, "test_error");
}

◆ TEST_F() [43/85]

TEST_F	(	AsyncResultTest	,
		OnErrorWithLambda	)

Definition at line 170 of file test_async_operations.cpp.

                                           {
    auto result = make_failing<int>();
 
    bool error_caught = false;
    result.on_error([&error_caught](const std::exception&) {
        error_caught = true;
    });
 
    EXPECT_THROW(result.get(), std::runtime_error);
    EXPECT_TRUE(error_caught);
}

◆ TEST_F() [44/85]

TEST_F	(	AsyncResultTest	,
		ThenLegacyOverload	)

Definition at line 184 of file test_async_operations.cpp.

                                            {
    auto result = make_ready<int>(5);
 
    int captured = 0;
    std::function<void(int)> cb = [&captured](int v) { captured = v; };
    result.then(cb);
    result.get();
 
    EXPECT_EQ(captured, 5);
}

◆ TEST_F() [45/85]

TEST_F	(	AsyncResultTest	,
		ThenWithLambda	)

Definition at line 160 of file test_async_operations.cpp.

                                        {
    auto result = make_ready<int>(10);
 
    int captured = 0;
    result.then([&captured](int v) { captured = v; });
    result.get();
 
    EXPECT_EQ(captured, 10);
}

◆ TEST_F() [46/85]

TEST_F	(	AsyncResultTest	,
		WaitForReturnsReadyWhenComplete	)

Definition at line 142 of file test_async_operations.cpp.

                                                         {
    auto result = make_ready<int>(1);
    auto status = result.wait_for(std::chrono::milliseconds(0));
    EXPECT_EQ(status, std::future_status::ready);
}

◆ TEST_F() [47/85]

TEST_F	(	AsyncResultTest	,
		WaitForReturnsTimeoutWhenNotReady	)

Definition at line 148 of file test_async_operations.cpp.

                                                           {
    std::promise<int> p;
    async_result<int> result(p.get_future());
 
    auto status = result.wait_for(std::chrono::milliseconds(1));
    EXPECT_EQ(status, std::future_status::timeout);
 
    p.set_value(0); // cleanup
}

References database::async::async_result< T >::wait_for().

Here is the call graph for this function:

◆ TEST_F() [48/85]

TEST_F	(	SagaBuilderTest	,
		AddStepReturnsSelfForChaining	)

Definition at line 1145 of file test_async_operations.cpp.

                                                       {
    auto saga = coord_.create_saga();
    auto& ref = saga.add_step(
        []() -> async_result<bool> { return make_ready_result(true); },
        []() -> async_result<bool> { return make_ready_result(true); }
    );
    EXPECT_EQ(&ref, &saga);
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [49/85]

TEST_F	(	SagaBuilderTest	,
		AllStepsSucceed	)

Definition at line 979 of file test_async_operations.cpp.

                                         {
    std::vector<int> execution_order;
 
    auto saga = coord_.create_saga();
    saga.add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(1);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-1);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(2);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-2);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(3);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-3);
            return make_ready_result(true);
        }
    );
 
    bool result = saga.execute().get();
    EXPECT_TRUE(result);
    EXPECT_EQ(execution_order, (std::vector<int>{1, 2, 3}));
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [50/85]

TEST_F	(	SagaBuilderTest	,
		CompensatesOnActionFailure	)

Definition at line 1017 of file test_async_operations.cpp.

                                                    {
    std::vector<int> execution_order;
 
    auto saga = coord_.create_saga();
    saga.add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(1);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-1);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(2);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-2);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(3);
            return make_ready_result(false); // Step 3 fails
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-3);
            return make_ready_result(true);
        }
    );
 
    bool result = saga.execute().get();
    EXPECT_FALSE(result);
    // Steps 1,2 executed; step 3 failed; compensate 2,1 in reverse
    EXPECT_EQ(execution_order, (std::vector<int>{1, 2, 3, -2, -1}));
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [51/85]

TEST_F	(	SagaBuilderTest	,
		CompensatesOnException	)

Definition at line 1056 of file test_async_operations.cpp.

                                                {
    std::vector<int> execution_order;
 
    auto saga = coord_.create_saga();
    saga.add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(1);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-1);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(2);
            throw std::runtime_error("step 2 exploded");
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-2);
            return make_ready_result(true);
        }
    );
 
    bool result = saga.execute().get();
    EXPECT_FALSE(result);
    // Step 1 executed; step 2 threw; compensate 1 in reverse
    EXPECT_EQ(execution_order, (std::vector<int>{1, 2, -1}));
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [52/85]

TEST_F	(	SagaBuilderTest	,
		CompensationExceptionDoesNotBreakChain	)

Definition at line 1105 of file test_async_operations.cpp.

                                                                {
    std::vector<int> execution_order;
 
    auto saga = coord_.create_saga();
    saga.add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(1);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-1);
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(2);
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-2);
            throw std::runtime_error("compensation 2 failed");
            return make_ready_result(true);
        }
    ).add_step(
        [&]() -> async_result<bool> {
            execution_order.push_back(3);
            return make_ready_result(false); // fails
        },
        [&]() -> async_result<bool> {
            execution_order.push_back(-3);
            return make_ready_result(true);
        }
    );
 
    bool result = saga.execute().get();
    EXPECT_FALSE(result);
    // Compensation -2 throws, but -1 still executes
    EXPECT_EQ(execution_order, (std::vector<int>{1, 2, 3, -2, -1}));
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [53/85]

TEST_F	(	SagaBuilderTest	,
		EmptySagaSucceeds	)

Definition at line 973 of file test_async_operations.cpp.

                                           {
    auto saga = coord_.create_saga();
    bool result = saga.execute().get();
    EXPECT_TRUE(result);
}

References database::async::transaction_coordinator::create_saga(), and database::async::saga_builder::execute().

Here is the call graph for this function:

◆ TEST_F() [54/85]

TEST_F	(	SagaBuilderTest	,
		SingleStepSuccess	)

Definition at line 1087 of file test_async_operations.cpp.

                                           {
    bool action_called = false;
    auto saga = coord_.create_saga();
    saga.add_step(
        [&]() -> async_result<bool> {
            action_called = true;
            return make_ready_result(true);
        },
        [&]() -> async_result<bool> {
            return make_ready_result(true);
        }
    );
 
    bool result = saga.execute().get();
    EXPECT_TRUE(result);
    EXPECT_TRUE(action_called);
}

References database::async::make_ready_result().

Here is the call graph for this function:

◆ TEST_F() [55/85]

TEST_F	(	StreamProcessorTest	,
		ConstructsWithBackend	)

Definition at line 1197 of file test_async_operations.cpp.

                                                   {
    EXPECT_NE(processor_, nullptr);
}

◆ TEST_F() [56/85]

TEST_F	(	StreamProcessorTest	,
		DestructorStopsAllStreams	)

Definition at line 1433 of file test_async_operations.cpp.

                                                       {
    auto local_backend = std::make_shared<async_stub_backend>();
    {
        stream_processor sp(local_backend);
        sp.start_stream(
            stream_processor::stream_type::custom, "ch1");
        sp.start_stream(
            stream_processor::stream_type::custom, "ch2");
        // Destructor runs here — must not crash or hang
    }
    SUCCEED();
}

References database::async::stream_processor::start_stream().

Here is the call graph for this function:

◆ TEST_F() [57/85]

TEST_F	(	StreamProcessorTest	,
		EventFilterAcceptsEvent	)

Definition at line 1355 of file test_async_operations.cpp.

                                                     {
    std::atomic<bool> handler_called{false};
 
    processor_->add_event_filter("ch1",
        [](const stream_processor::stream_event& event) {
            return event.payload == "stream_connected";
        });
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event&) {
            handler_called.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    ASSERT_TRUE(wait_for_flag(handler_called));
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [58/85]

TEST_F	(	StreamProcessorTest	,
		EventFilterRejectsEvent	)

Definition at line 1333 of file test_async_operations.cpp.

                                                     {
    std::atomic<bool> handler_called{false};
 
    processor_->add_event_filter("ch1",
        [](const stream_processor::stream_event&) {
            return false;  // Reject all events
        });
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event&) {
            handler_called.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    // Give enough time for the event to potentially arrive
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    EXPECT_FALSE(handler_called.load());
    processor_->stop_all_streams();
}

◆ TEST_F() [59/85]

TEST_F	(	StreamProcessorTest	,
		EventHandlerReceivesConnectedEvent	)

Definition at line 1246 of file test_async_operations.cpp.

                                                                {
    std::atomic<bool> received{false};
    std::string captured_payload;
    std::mutex capture_mutex;
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event& event) {
            std::lock_guard<std::mutex> lock(capture_mutex);
            captured_payload = event.payload;
            received.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    ASSERT_TRUE(wait_for_flag(received));
    {
        std::lock_guard<std::mutex> lock(capture_mutex);
        EXPECT_EQ(captured_payload, "stream_connected");
    }
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [60/85]

TEST_F	(	StreamProcessorTest	,
		EventHandlerReceivesCorrectChannel	)

Definition at line 1269 of file test_async_operations.cpp.

                                                                {
    std::atomic<bool> received{false};
    std::string captured_channel;
    std::mutex capture_mutex;
 
    processor_->register_event_handler("notifications",
        [&](const stream_processor::stream_event& event) {
            std::lock_guard<std::mutex> lock(capture_mutex);
            captured_channel = event.channel;
            received.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::postgresql_notify, "notifications");
 
    ASSERT_TRUE(wait_for_flag(received));
    {
        std::lock_guard<std::mutex> lock(capture_mutex);
        EXPECT_EQ(captured_channel, "notifications");
    }
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [61/85]

TEST_F	(	StreamProcessorTest	,
		EventHandlerReceivesCorrectType	)

Definition at line 1292 of file test_async_operations.cpp.

                                                             {
    std::atomic<bool> received{false};
    stream_processor::stream_type captured_type;
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event& event) {
            captured_type = event.type;
            received.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::mongodb_change_stream, "ch1");
 
    ASSERT_TRUE(wait_for_flag(received));
    EXPECT_EQ(captured_type,
        stream_processor::stream_type::mongodb_change_stream);
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [62/85]

TEST_F	(	StreamProcessorTest	,
		FilterDoesNotAffectGlobalHandler	)

Definition at line 1375 of file test_async_operations.cpp.

                                                              {
    std::atomic<bool> global_called{false};
 
    processor_->add_event_filter("ch1",
        [](const stream_processor::stream_event&) {
            return false;  // Reject
        });
 
    processor_->register_global_handler(
        [&](const stream_processor::stream_event&) {
            global_called.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    // Global handler should NOT be called when filter rejects
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    EXPECT_FALSE(global_called.load());
    processor_->stop_all_streams();
}

◆ TEST_F() [63/85]

TEST_F	(	StreamProcessorTest	,
		GlobalHandlerReceivesAllEvents	)

Definition at line 1313 of file test_async_operations.cpp.

                                                            {
    std::atomic<int> event_count{0};
 
    processor_->register_global_handler(
        [&](const stream_processor::stream_event&) {
            event_count.fetch_add(1);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch2");
 
    ASSERT_TRUE(wait_for_count(event_count, 2));
    EXPECT_GE(event_count.load(), 2);
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [64/85]

TEST_F	(	StreamProcessorTest	,
		StartStreamDuplicateReturnsFalse	)

Definition at line 1209 of file test_async_operations.cpp.

                                                              {
    EXPECT_TRUE(processor_->start_stream(
        stream_processor::stream_type::custom, "ch1"));
    EXPECT_FALSE(processor_->start_stream(
        stream_processor::stream_type::custom, "ch1"));
    processor_->stop_all_streams();
}

◆ TEST_F() [65/85]

TEST_F	(	StreamProcessorTest	,
		StartStreamReturnsTrue	)

Definition at line 1203 of file test_async_operations.cpp.

                                                    {
    EXPECT_TRUE(processor_->start_stream(
        stream_processor::stream_type::custom, "test_channel"));
    processor_->stop_all_streams();
}

◆ TEST_F() [66/85]

TEST_F	(	StreamProcessorTest	,
		StopAllStreamsStopsMultiple	)

Definition at line 1227 of file test_async_operations.cpp.

                                                         {
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
    processor_->start_stream(
        stream_processor::stream_type::redis_pubsub, "ch2");
    processor_->start_stream(
        stream_processor::stream_type::postgresql_notify, "ch3");
 
    // Should not hang or crash
    processor_->stop_all_streams();
 
    // All stopped — stopping again returns false
    EXPECT_FALSE(processor_->stop_stream("ch1"));
    EXPECT_FALSE(processor_->stop_stream("ch2"));
    EXPECT_FALSE(processor_->stop_stream("ch3"));
}

◆ TEST_F() [67/85]

TEST_F	(	StreamProcessorTest	,
		StopOneStreamDoesNotAffectOthers	)

Definition at line 1399 of file test_async_operations.cpp.

                                                              {
    std::atomic<int> ch1_count{0};
    std::atomic<int> ch2_count{0};
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event&) {
            ch1_count.fetch_add(1);
        });
    processor_->register_event_handler("ch2",
        [&](const stream_processor::stream_event&) {
            ch2_count.fetch_add(1);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch2");
 
    // Wait for both connected events
    ASSERT_TRUE(wait_for_count(ch1_count, 1));
    ASSERT_TRUE(wait_for_count(ch2_count, 1));
 
    // Stop only ch1 — ch2 should still be alive
    EXPECT_TRUE(processor_->stop_stream("ch1"));
 
    // Verify ch1 is stopped
    EXPECT_FALSE(processor_->stop_stream("ch1"));
 
    // ch2 stream should still be running (can be stopped)
    EXPECT_TRUE(processor_->stop_stream("ch2"));
}

References ASSERT_TRUE.

◆ TEST_F() [68/85]

TEST_F	(	StreamProcessorTest	,
		StopStreamNonExistentReturnsFalse	)

Definition at line 1223 of file test_async_operations.cpp.

                                                               {
    EXPECT_FALSE(processor_->stop_stream("no_such_channel"));
}

◆ TEST_F() [69/85]

TEST_F	(	StreamProcessorTest	,
		StopStreamReturnsTrue	)

Definition at line 1217 of file test_async_operations.cpp.

                                                   {
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
    EXPECT_TRUE(processor_->stop_stream("ch1"));
}

◆ TEST_F() [70/85]

TEST_F	(	StreamProcessorTest	,
		TemplateEventFilterWithLambda	)

Definition at line 1479 of file test_async_operations.cpp.

                                                           {
    std::atomic<bool> handler_called{false};
 
    auto filter = [](const stream_processor::stream_event& event) {
        return event.payload == "stream_connected";
    };
    processor_->add_event_filter("ch1", filter);
 
    processor_->register_event_handler("ch1",
        [&](const stream_processor::stream_event&) {
            handler_called.store(true);
        });
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    ASSERT_TRUE(wait_for_flag(handler_called));
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [71/85]

TEST_F	(	StreamProcessorTest	,
		TemplateEventHandlerWithLambda	)

Definition at line 1448 of file test_async_operations.cpp.

                                                            {
    std::atomic<bool> received{false};
 
    // Uses the concept-constrained template overload
    auto handler = [&](const stream_processor::stream_event&) {
        received.store(true);
    };
    processor_->register_event_handler("ch1", handler);
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    ASSERT_TRUE(wait_for_flag(received));
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [72/85]

TEST_F	(	StreamProcessorTest	,
		TemplateGlobalHandlerWithLambda	)

Definition at line 1464 of file test_async_operations.cpp.

                                                             {
    std::atomic<int> count{0};
 
    auto handler = [&](const stream_processor::stream_event&) {
        count.fetch_add(1);
    };
    processor_->register_global_handler(handler);
 
    processor_->start_stream(
        stream_processor::stream_type::custom, "ch1");
 
    ASSERT_TRUE(wait_for_count(count, 1));
    processor_->stop_all_streams();
}

References ASSERT_TRUE.

◆ TEST_F() [73/85]

TEST_F	(	TransactionCoordinatorTest	,
		BeginCreatesTransaction	)

Definition at line 812 of file test_async_operations.cpp.

                                                            {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    EXPECT_FALSE(txn_id.empty());
 
    auto active = coord_.get_active_transactions();
    ASSERT_EQ(active.size(), 1u);
    EXPECT_EQ(active[0].transaction_id, txn_id);
    EXPECT_EQ(active[0].participants.size(), 3u);
    EXPECT_EQ(active[0].state, transaction_coordinator::transaction_state::active);
}

References ASSERT_EQ.

◆ TEST_F() [74/85]

TEST_F	(	TransactionCoordinatorTest	,
		BeginGeneratesUniqueIds	)

Definition at line 823 of file test_async_operations.cpp.

                                                            {
    auto id1 = coord_.begin_distributed_transaction(participants_);
    auto id2 = coord_.begin_distributed_transaction(participants_);
    EXPECT_NE(id1, id2);
    EXPECT_EQ(coord_.get_active_transactions().size(), 2u);
}

◆ TEST_F() [75/85]

TEST_F	(	TransactionCoordinatorTest	,
		CommitDistributedTransactionFailsOnPrepare	)

Definition at line 904 of file test_async_operations.cpp.

                                                                               {
    p3_->set_fail_begin(true);
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    bool result = coord_.commit_distributed_transaction(txn_id).get();
    EXPECT_FALSE(result);
 
    // p1, p2 prepared then rolled back
    EXPECT_EQ(p1_->rollback_count(), 1);
    EXPECT_EQ(p2_->rollback_count(), 1);
    EXPECT_EQ(p3_->commit_count(), 0);
}

◆ TEST_F() [76/85]

TEST_F	(	TransactionCoordinatorTest	,
		CommitDistributedTransactionFull2PC	)

Definition at line 893 of file test_async_operations.cpp.

                                                                        {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    bool result = coord_.commit_distributed_transaction(txn_id).get();
    EXPECT_TRUE(result);
 
    EXPECT_EQ(p1_->begin_count(), 1);
    EXPECT_EQ(p1_->commit_count(), 1);
    EXPECT_EQ(p2_->begin_count(), 1);
    EXPECT_EQ(p2_->commit_count(), 1);
}

◆ TEST_F() [77/85]

TEST_F	(	TransactionCoordinatorTest	,
		CommitPhaseFailsIfNotPrepared	)

Definition at line 883 of file test_async_operations.cpp.

                                                                  {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    // Skip prepare_phase — state is still "active"
    bool result = coord_.commit_phase(txn_id).get();
    EXPECT_FALSE(result);
    EXPECT_EQ(p1_->commit_count(), 0);
}

◆ TEST_F() [78/85]

TEST_F	(	TransactionCoordinatorTest	,
		CommitPhaseSuccess	)

Definition at line 868 of file test_async_operations.cpp.

                                                       {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    coord_.prepare_phase(txn_id).get();
 
    bool result = coord_.commit_phase(txn_id).get();
    EXPECT_TRUE(result);
 
    EXPECT_EQ(p1_->commit_count(), 1);
    EXPECT_EQ(p2_->commit_count(), 1);
    EXPECT_EQ(p3_->commit_count(), 1);
 
    auto txns = coord_.get_active_transactions();
    EXPECT_EQ(txns[0].state, transaction_coordinator::transaction_state::committed);
}

◆ TEST_F() [79/85]

TEST_F	(	TransactionCoordinatorTest	,
		CreateSagaReturnsSagaBuilder	)

Definition at line 957 of file test_async_operations.cpp.

                                                                 {
    auto saga = coord_.create_saga();
    // Verify the saga builder can execute (empty saga succeeds)
    bool result = saga.execute().get();
    EXPECT_TRUE(result);
}

◆ TEST_F() [80/85]

TEST_F	(	TransactionCoordinatorTest	,
		PreparePhaseRollsBackOnPartialFailure	)

Definition at line 849 of file test_async_operations.cpp.

                                                                          {
    p2_->set_fail_begin(true);
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    bool result = coord_.prepare_phase(txn_id).get();
    EXPECT_FALSE(result);
 
    // p1 was prepared then rolled back; p2 failed; p3 never reached
    EXPECT_EQ(p1_->begin_count(), 1);
    EXPECT_EQ(p1_->rollback_count(), 1);
    EXPECT_EQ(p2_->begin_count(), 0);
    EXPECT_EQ(p3_->begin_count(), 0);
 
    auto txns = coord_.get_active_transactions();
    ASSERT_EQ(txns.size(), 1u);
    EXPECT_EQ(txns[0].state, transaction_coordinator::transaction_state::aborted);
}

References ASSERT_EQ.

◆ TEST_F() [81/85]

TEST_F	(	TransactionCoordinatorTest	,
		PreparePhaseSuccess	)

Definition at line 832 of file test_async_operations.cpp.

                                                        {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    bool result = coord_.prepare_phase(txn_id).get();
    EXPECT_TRUE(result);
 
    auto txns = coord_.get_active_transactions();
    ASSERT_EQ(txns.size(), 1u);
    EXPECT_EQ(txns[0].state, transaction_coordinator::transaction_state::prepared);
    EXPECT_EQ(p1_->begin_count(), 1);
    EXPECT_EQ(p2_->begin_count(), 1);
    EXPECT_EQ(p3_->begin_count(), 1);
}

References ASSERT_EQ.

◆ TEST_F() [82/85]

TEST_F	(	TransactionCoordinatorTest	,
		PreparePhaseThrowsForUnknownTransaction	)

Definition at line 845 of file test_async_operations.cpp.

                                                                            {
    EXPECT_THROW(coord_.prepare_phase("nonexistent").get(), std::exception);
}

◆ TEST_F() [83/85]

TEST_F	(	TransactionCoordinatorTest	,
		RecoverCleansUpCompletedTransactions	)

Definition at line 941 of file test_async_operations.cpp.

                                                                         {
    auto id1 = coord_.begin_distributed_transaction(participants_);
    auto id2 = coord_.begin_distributed_transaction(participants_);
    coord_.commit_distributed_transaction(id1).get();
 
    EXPECT_EQ(coord_.get_active_transactions().size(), 2u);
    coord_.recover_transactions();
 
    // id1 is committed → cleaned up; id2 is still active
    auto remaining = coord_.get_active_transactions();
    ASSERT_EQ(remaining.size(), 1u);
    EXPECT_EQ(remaining[0].transaction_id, id2);
}

References ASSERT_EQ.

◆ TEST_F() [84/85]

TEST_F	(	TransactionCoordinatorTest	,
		RollbackDistributedTransaction	)

Definition at line 918 of file test_async_operations.cpp.

                                                                   {
    auto txn_id = coord_.begin_distributed_transaction(participants_);
    coord_.prepare_phase(txn_id).get();
 
    bool result = coord_.rollback_distributed_transaction(txn_id).get();
    EXPECT_TRUE(result);
 
    EXPECT_EQ(p1_->rollback_count(), 1);
    EXPECT_EQ(p2_->rollback_count(), 1);
    EXPECT_EQ(p3_->rollback_count(), 1);
 
    auto txns = coord_.get_active_transactions();
    EXPECT_EQ(txns[0].state, transaction_coordinator::transaction_state::aborted);
}

◆ TEST_F() [85/85]

TEST_F	(	TransactionCoordinatorTest	,
		RollbackThrowsForUnknownTransaction	)

Definition at line 933 of file test_async_operations.cpp.

                                                                        {
    EXPECT_THROW(
        coord_.rollback_distributed_transaction("nonexistent").get(),
        std::exception);
}

Classes

Functions

Function Documentation

◆ TEST() [1/4]

◆ TEST() [2/4]

◆ TEST() [3/4]

◆ TEST() [4/4]

◆ TEST_F() [1/85]

◆ TEST_F() [2/85]

◆ TEST_F() [3/85]

◆ TEST_F() [4/85]

◆ TEST_F() [5/85]

◆ TEST_F() [6/85]

◆ TEST_F() [7/85]

◆ TEST_F() [8/85]

◆ TEST_F() [9/85]

◆ TEST_F() [10/85]

◆ TEST_F() [11/85]

◆ TEST_F() [12/85]

◆ TEST_F() [13/85]

◆ TEST_F() [14/85]

◆ TEST_F() [15/85]

◆ TEST_F() [16/85]

◆ TEST_F() [17/85]

◆ TEST_F() [18/85]

◆ TEST_F() [19/85]

◆ TEST_F() [20/85]

◆ TEST_F() [21/85]

◆ TEST_F() [22/85]

◆ TEST_F() [23/85]

◆ TEST_F() [24/85]

◆ TEST_F() [25/85]

◆ TEST_F() [26/85]

◆ TEST_F() [27/85]

◆ TEST_F() [28/85]

◆ TEST_F() [29/85]

◆ TEST_F() [30/85]

◆ TEST_F() [31/85]

◆ TEST_F() [32/85]

◆ TEST_F() [33/85]

◆ TEST_F() [34/85]

◆ TEST_F() [35/85]

◆ TEST_F() [36/85]

◆ TEST_F() [37/85]

◆ TEST_F() [38/85]

◆ TEST_F() [39/85]

◆ TEST_F() [40/85]

◆ TEST_F() [41/85]

◆ TEST_F() [42/85]

◆ TEST_F() [43/85]

◆ TEST_F() [44/85]

◆ TEST_F() [45/85]

◆ TEST_F() [46/85]

◆ TEST_F() [47/85]

◆ TEST_F() [48/85]

◆ TEST_F() [49/85]

◆ TEST_F() [50/85]

◆ TEST_F() [51/85]

◆ TEST_F() [52/85]

◆ TEST_F() [53/85]

◆ TEST_F() [54/85]

◆ TEST_F() [55/85]

◆ TEST_F() [56/85]

◆ TEST_F() [57/85]

◆ TEST_F() [58/85]

◆ TEST_F() [59/85]

◆ TEST_F() [60/85]

◆ TEST_F() [61/85]

◆ TEST_F() [62/85]

◆ TEST_F() [63/85]

◆ TEST_F() [64/85]

◆ TEST_F() [65/85]

◆ TEST_F() [66/85]

◆ TEST_F() [67/85]

◆ TEST_F() [68/85]

◆ TEST_F() [69/85]

◆ TEST_F() [70/85]

◆ TEST_F() [71/85]

◆ TEST_F() [72/85]

◆ TEST_F() [73/85]