backend_contract_test.cpp File Reference

#include <atomic>
#include <gtest/gtest.h>
#include <memory>
#include <string>
#include <thread>
#include <vector>
#include "database/core/database_backend.h"
#include "mocks/mock_backend.h"

Include dependency graph for backend_contract_test.cpp:

Go to the source code of this file.

Classes
class	BackendContractTest

Functions
	TEST_F (BackendContractTest, InitializeSucceeds)
	TEST_F (BackendContractTest, InitializeStoresConnectionString)
	TEST_F (BackendContractTest, InitializeFailureSimulation)
	TEST_F (BackendContractTest, InitializeFailureDefaultMessage)
	TEST_F (BackendContractTest, ShutdownClearsState)
	TEST_F (BackendContractTest, SimulateShutdown)
	TEST_F (BackendContractTest, TypeReturnsConfiguredType)
	TEST_F (BackendContractTest, DefaultTypeIsNone)
	TEST_F (BackendContractTest, ExecuteInsertQuerySucceeds)
	TEST_F (BackendContractTest, ExecuteInsertQueryWithError)
	TEST_F (BackendContractTest, ExecuteUpdateQuerySucceeds)
	TEST_F (BackendContractTest, ExecuteDeleteQuerySucceeds)
	TEST_F (BackendContractTest, SelectQueryReturnsResults)
	TEST_F (BackendContractTest, SelectQueryReturnsEmptyResult)
	TEST_F (BackendContractTest, SelectQueryWithDefaultResult)
	TEST_F (BackendContractTest, ExecuteQuerySucceeds)
	TEST_F (BackendContractTest, ExecuteQueryWithExpectedFailure)
	TEST_F (BackendContractTest, TransactionInitiallyInactive)
	TEST_F (BackendContractTest, BeginTransactionActivates)
	TEST_F (BackendContractTest, CommitTransactionDeactivates)
	TEST_F (BackendContractTest, RollbackTransactionDeactivates)
	TEST_F (BackendContractTest, NestedBeginTransactionFails)
	TEST_F (BackendContractTest, CommitWithoutTransactionFails)
	TEST_F (BackendContractTest, RollbackWithoutTransactionFails)
	TEST_F (BackendContractTest, TransactionCycleBeginCommitBeginRollback)
	TEST_F (BackendContractTest, ShutdownClearsTransactionState)
	TEST_F (BackendContractTest, PatternMatchingWithRegex)
	TEST_F (BackendContractTest, AnyMatcherMatchesAll)
	TEST_F (BackendContractTest, RecordsExecutedQueries)
	TEST_F (BackendContractTest, GetQueryCountTotal)
	TEST_F (BackendContractTest, GetQueryCountByPattern)
	TEST_F (BackendContractTest, ClearHistory)
	TEST_F (BackendContractTest, ClearExpectations)
	TEST_F (BackendContractTest, ResetClearsEverything)
	TEST_F (BackendContractTest, VerifyAllExpectationsWhenAllMatched)
	TEST_F (BackendContractTest, VerifyExpectationsFailsWhenUnmatched)
	TEST_F (BackendContractTest, ConnectionInfoReturnsMap)
	TEST_F (BackendContractTest, LastErrorInitiallyEmpty)
	TEST_F (BackendContractTest, EmptyDatabasePreset)
	TEST_F (BackendContractTest, WithDataPreset)
	TEST_F (BackendContractTest, FailingDatabasePreset)
	TEST_F (BackendContractTest, AllDatabaseValueTypesInResult)
	TEST_F (BackendContractTest, ConcurrentQueryExecution)
	TEST_F (BackendContractTest, MoveConstructor)
	TEST_F (BackendContractTest, MoveAssignment)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 546 of file backend_contract_test.cpp.

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

TEST_F() [1/45]

TEST_F	(	BackendContractTest	,
		AllDatabaseValueTypesInResult	)

Definition at line 466 of file backend_contract_test.cpp.

{
    database_result data = {{
        {"string_col", std::string("hello")},
        {"int_col", int64_t(42)},
        {"double_col", double(3.14)},
        {"bool_col", true},
        {"null_col", nullptr}
    }};
 
    backend_.expect_query("SELECT *").will_return(data);
    auto result = backend_.select_query("SELECT *");
    ASSERT_TRUE(result.is_ok());
    ASSERT_EQ(result.value().size(), 1u);
 
    auto& row = result.value()[0];
    EXPECT_EQ(std::get<std::string>(row.at("string_col")), "hello");
    EXPECT_EQ(std::get<int64_t>(row.at("int_col")), 42);
    EXPECT_DOUBLE_EQ(std::get<double>(row.at("double_col")), 3.14);
    EXPECT_EQ(std::get<bool>(row.at("bool_col")), true);
    EXPECT_EQ(std::get<std::nullptr_t>(row.at("null_col")), nullptr);
}

References ASSERT_EQ, and ASSERT_TRUE.

TEST_F() [2/45]

TEST_F	(	BackendContractTest	,
		AnyMatcherMatchesAll	)

Definition at line 313 of file backend_contract_test.cpp.

{
    auto r1 = backend_.execute_query("INSERT INTO a VALUES (1)");
    auto r2 = backend_.execute_query("UPDATE b SET x = 1");
    auto r3 = backend_.execute_query("DELETE FROM c WHERE id = 1");
 
    EXPECT_TRUE(r1.is_ok());
    EXPECT_TRUE(r2.is_ok());
    EXPECT_TRUE(r3.is_ok());
}

TEST_F() [3/45]

TEST_F	(	BackendContractTest	,
		BeginTransactionActivates	)

Definition at line 229 of file backend_contract_test.cpp.

{
    EXPECT_TRUE(backend_.begin_transaction().is_ok());
    EXPECT_TRUE(backend_.in_transaction());
}

TEST_F() [4/45]

TEST_F	(	BackendContractTest	,
		ClearExpectations	)

Definition at line 369 of file backend_contract_test.cpp.

{
    backend_.expect_query("q1").will_return_rows(10);
    backend_.clear_expectations();
 
    // After clearing, should use default behavior (success)
    auto result = backend_.execute_query("q1");
    ASSERT_TRUE(result.is_ok());
}

References ASSERT_TRUE.

TEST_F() [5/45]

TEST_F	(	BackendContractTest	,
		ClearHistory	)

Definition at line 361 of file backend_contract_test.cpp.

{
    backend_.execute_query("q1");
    backend_.clear_history();
    EXPECT_EQ(backend_.get_query_count(), 0u);
    EXPECT_TRUE(backend_.get_executed_queries().empty());
}

TEST_F() [6/45]

TEST_F	(	BackendContractTest	,
		CommitTransactionDeactivates	)

Definition at line 235 of file backend_contract_test.cpp.

{
    backend_.begin_transaction();
    EXPECT_TRUE(backend_.commit_transaction().is_ok());
    EXPECT_FALSE(backend_.in_transaction());
}

TEST_F() [7/45]

TEST_F	(	BackendContractTest	,
		CommitWithoutTransactionFails	)

Definition at line 258 of file backend_contract_test.cpp.

{
    auto result = backend_.commit_transaction();
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [8/45]

TEST_F	(	BackendContractTest	,
		ConcurrentQueryExecution	)

Definition at line 493 of file backend_contract_test.cpp.

{
    constexpr int num_threads = 10;
    constexpr int queries_per_thread = 50;
    std::vector<std::thread> threads;
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, t]() {
            for (int q = 0; q < queries_per_thread; ++q) {
                std::string query = "INSERT INTO t" + std::to_string(t) +
                                    " VALUES (" + std::to_string(q) + ")";
                backend_.execute_query(query);
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_EQ(backend_.get_query_count(),
              static_cast<size_t>(num_threads * queries_per_thread));
}

TEST_F() [9/45]

TEST_F	(	BackendContractTest	,
		ConnectionInfoReturnsMap	)

Definition at line 416 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    auto info = backend_.connection_info();
 
    EXPECT_FALSE(info.empty());
    EXPECT_EQ(info.at("type"), "mock");
    EXPECT_EQ(info.at("initialized"), "true");
}

TEST_F() [10/45]

TEST_F	(	BackendContractTest	,
		DefaultTypeIsNone	)

Definition at line 118 of file backend_contract_test.cpp.

{
    mock_backend fresh_backend;
    EXPECT_EQ(fresh_backend.type(), database_types::none);
}

References database::testing::mock_backend::type().

Here is the call graph for this function:

TEST_F() [11/45]

TEST_F	(	BackendContractTest	,
		EmptyDatabasePreset	)

Definition at line 435 of file backend_contract_test.cpp.

{
    auto db = mock_backend_builder::empty_database();
    auto result = db.select_query("SELECT * FROM anything");
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value().empty());
}

References ASSERT_TRUE, and database::testing::mock_backend_builder::empty_database().

Here is the call graph for this function:

TEST_F() [12/45]

TEST_F	(	BackendContractTest	,
		ExecuteDeleteQuerySucceeds	)

Definition at line 149 of file backend_contract_test.cpp.

{
    auto result = backend_.execute_query("DELETE FROM users WHERE id = 1");
    ASSERT_TRUE(result.is_ok());
}

References ASSERT_TRUE.

TEST_F() [13/45]

TEST_F	(	BackendContractTest	,
		ExecuteInsertQuerySucceeds	)

Definition at line 128 of file backend_contract_test.cpp.

{
    auto result = backend_.execute_query("INSERT INTO users (name) VALUES ('John')");
    ASSERT_TRUE(result.is_ok());
}

References ASSERT_TRUE.

TEST_F() [14/45]

TEST_F	(	BackendContractTest	,
		ExecuteInsertQueryWithError	)

Definition at line 134 of file backend_contract_test.cpp.

{
    backend_.expect_query("INSERT INTO users (name) VALUES ('John')")
        .will_fail("Duplicate key violation");
 
    auto result = backend_.execute_query("INSERT INTO users (name) VALUES ('John')");
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [15/45]

TEST_F	(	BackendContractTest	,
		ExecuteQuerySucceeds	)

Definition at line 205 of file backend_contract_test.cpp.

{
    auto result = backend_.execute_query("CREATE TABLE test (id INTEGER)");
    EXPECT_TRUE(result.is_ok());
}

TEST_F() [16/45]

TEST_F	(	BackendContractTest	,
		ExecuteQueryWithExpectedFailure	)

Definition at line 211 of file backend_contract_test.cpp.

{
    backend_.expect_query("DROP TABLE nonexistent")
        .will_fail("Table does not exist");
 
    auto result = backend_.execute_query("DROP TABLE nonexistent");
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [17/45]

TEST_F	(	BackendContractTest	,
		ExecuteUpdateQuerySucceeds	)

Definition at line 143 of file backend_contract_test.cpp.

{
    auto result = backend_.execute_query("UPDATE users SET name = 'Jane' WHERE id = 1");
    ASSERT_TRUE(result.is_ok());
}

References ASSERT_TRUE.

TEST_F() [18/45]

TEST_F	(	BackendContractTest	,
		FailingDatabasePreset	)

Definition at line 455 of file backend_contract_test.cpp.

{
    auto db = mock_backend_builder::failing_database("DB is down");
    auto result = db.select_query("SELECT * FROM users");
    EXPECT_FALSE(result.is_ok());
}

References database::testing::mock_backend_builder::failing_database().

Here is the call graph for this function:

TEST_F() [19/45]

TEST_F	(	BackendContractTest	,
		GetQueryCountByPattern	)

Definition at line 350 of file backend_contract_test.cpp.

{
    backend_.execute_query("INSERT INTO users VALUES (1)");
    backend_.execute_query("INSERT INTO orders VALUES (1)");
    backend_.select_query("SELECT * FROM users");
 
    EXPECT_EQ(backend_.get_query_count("INSERT"), 2u);
    EXPECT_EQ(backend_.get_query_count("users"), 2u);
    EXPECT_EQ(backend_.get_query_count("orders"), 1u);
}

TEST_F() [20/45]

TEST_F	(	BackendContractTest	,
		GetQueryCountTotal	)

Definition at line 341 of file backend_contract_test.cpp.

{
    backend_.execute_query("q1");
    backend_.execute_query("q2");
    backend_.select_query("q3");
 
    EXPECT_EQ(backend_.get_query_count(), 3u);
}

TEST_F() [21/45]

TEST_F	(	BackendContractTest	,
		InitializeFailureDefaultMessage	)

Definition at line 83 of file backend_contract_test.cpp.

{
    backend_.simulate_initialization_failure();
    auto result = backend_.initialize(test_config_);
    EXPECT_FALSE(result.is_ok());
    EXPECT_EQ(backend_.last_error(), "Mock initialization failed");
}

TEST_F() [22/45]

TEST_F	(	BackendContractTest	,
		InitializeFailureSimulation	)

Definition at line 75 of file backend_contract_test.cpp.

{
    backend_.simulate_initialization_failure("Custom error");
    auto result = backend_.initialize(test_config_);
    EXPECT_FALSE(result.is_ok());
    EXPECT_FALSE(backend_.is_initialized());
}

TEST_F() [23/45]

TEST_F	(	BackendContractTest	,
		InitializeStoresConnectionString	)

Definition at line 66 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    auto conn_str = backend_.get_connection_string();
    EXPECT_FALSE(conn_str.empty());
    EXPECT_NE(conn_str.find("localhost"), std::string::npos);
    EXPECT_NE(conn_str.find("test_db"), std::string::npos);
}

TEST_F() [24/45]

TEST_F	(	BackendContractTest	,
		InitializeSucceeds	)

Definition at line 59 of file backend_contract_test.cpp.

{
    auto result = backend_.initialize(test_config_);
    EXPECT_TRUE(result.is_ok());
    EXPECT_TRUE(backend_.is_initialized());
}

References database::testing::mock_backend::initialize().

Here is the call graph for this function:

TEST_F() [25/45]

TEST_F	(	BackendContractTest	,
		LastErrorInitiallyEmpty	)

Definition at line 426 of file backend_contract_test.cpp.

{
    EXPECT_TRUE(backend_.last_error().empty());
}

TEST_F() [26/45]

TEST_F	(	BackendContractTest	,
		MoveAssignment	)

Definition at line 534 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    backend_.execute_query("q1");
 
    mock_backend target;
    target = std::move(backend_);
 
    EXPECT_TRUE(target.is_initialized());
    EXPECT_EQ(target.get_query_count(), 1u);
}

References database::testing::mock_backend::get_query_count(), and database::testing::mock_backend::is_initialized().

Here is the call graph for this function:

TEST_F() [27/45]

TEST_F	(	BackendContractTest	,
		MoveConstructor	)

Definition at line 521 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    backend_.set_database_type(database_types::sqlite);
    backend_.execute_query("q1");
 
    mock_backend moved(std::move(backend_));
 
    EXPECT_TRUE(moved.is_initialized());
    EXPECT_EQ(moved.type(), database_types::sqlite);
    EXPECT_EQ(moved.get_query_count(), 1u);
}

References database::testing::mock_backend::get_query_count(), database::testing::mock_backend::is_initialized(), and database::testing::mock_backend::type().

Here is the call graph for this function:

TEST_F() [28/45]

TEST_F	(	BackendContractTest	,
		NestedBeginTransactionFails	)

Definition at line 249 of file backend_contract_test.cpp.

{
    backend_.begin_transaction();
    auto result = backend_.begin_transaction();
    EXPECT_FALSE(result.is_ok());
    // Should still be in transaction
    EXPECT_TRUE(backend_.in_transaction());
}

TEST_F() [29/45]

TEST_F	(	BackendContractTest	,
		PatternMatchingWithRegex	)

Definition at line 299 of file backend_contract_test.cpp.

{
    database_result expected = {
        {{"id", int64_t(1)}, {"name", std::string("Test")}}
    };
 
    backend_.expect_pattern("SELECT.*FROM users.*")
        .will_return(expected);
 
    auto result = backend_.select_query("SELECT id, name FROM users WHERE id = 1");
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().size(), 1u);
}

References ASSERT_TRUE.

TEST_F() [30/45]

TEST_F	(	BackendContractTest	,
		RecordsExecutedQueries	)

Definition at line 328 of file backend_contract_test.cpp.

{
    backend_.execute_query("INSERT INTO t1 VALUES (1)");
    backend_.select_query("SELECT * FROM t1");
    backend_.execute_query("UPDATE t1 SET x = 2");
 
    auto queries = backend_.get_executed_queries();
    EXPECT_EQ(queries.size(), 3u);
    EXPECT_EQ(queries[0], "INSERT INTO t1 VALUES (1)");
    EXPECT_EQ(queries[1], "SELECT * FROM t1");
    EXPECT_EQ(queries[2], "UPDATE t1 SET x = 2");
}

TEST_F() [31/45]

TEST_F	(	BackendContractTest	,
		ResetClearsEverything	)

Definition at line 379 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    backend_.begin_transaction();
    backend_.execute_query("q1");
    backend_.expect_query("q2").will_return_rows(5);
 
    backend_.reset();
 
    EXPECT_FALSE(backend_.is_initialized());
    EXPECT_FALSE(backend_.in_transaction());
    EXPECT_EQ(backend_.get_query_count(), 0u);
    EXPECT_TRUE(backend_.get_connection_string().empty());
}

TEST_F() [32/45]

TEST_F	(	BackendContractTest	,
		RollbackTransactionDeactivates	)

Definition at line 242 of file backend_contract_test.cpp.

{
    backend_.begin_transaction();
    EXPECT_TRUE(backend_.rollback_transaction().is_ok());
    EXPECT_FALSE(backend_.in_transaction());
}

TEST_F() [33/45]

TEST_F	(	BackendContractTest	,
		RollbackWithoutTransactionFails	)

Definition at line 264 of file backend_contract_test.cpp.

{
    auto result = backend_.rollback_transaction();
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [34/45]

TEST_F	(	BackendContractTest	,
		SelectQueryReturnsEmptyResult	)

Definition at line 178 of file backend_contract_test.cpp.

{
    backend_.expect_query("SELECT * FROM empty_table")
        .will_return(database_result{});
 
    auto result = backend_.select_query("SELECT * FROM empty_table");
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value().empty());
}

References ASSERT_TRUE.

TEST_F() [35/45]

TEST_F	(	BackendContractTest	,
		SelectQueryReturnsResults	)

Definition at line 159 of file backend_contract_test.cpp.

{
    database_result expected_data = {
        {{"id", int64_t(1)}, {"name", std::string("Alice")}},
        {{"id", int64_t(2)}, {"name", std::string("Bob")}}
    };
 
    backend_.expect_query("SELECT * FROM users")
        .will_return(expected_data);
 
    auto result = backend_.select_query("SELECT * FROM users");
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().size(), 2u);
 
    auto& row0 = result.value()[0];
    EXPECT_EQ(std::get<int64_t>(row0.at("id")), 1);
    EXPECT_EQ(std::get<std::string>(row0.at("name")), "Alice");
}

References ASSERT_TRUE.

TEST_F() [36/45]

TEST_F	(	BackendContractTest	,
		SelectQueryWithDefaultResult	)

Definition at line 188 of file backend_contract_test.cpp.

{
    database_result default_data = {
        {{"count", int64_t(42)}}
    };
    backend_.set_default_select_result(default_data);
 
    auto result = backend_.select_query("SELECT COUNT(*) FROM anything");
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().size(), 1u);
    EXPECT_EQ(std::get<int64_t>(result.value()[0].at("count")), 42);
}

References ASSERT_TRUE.

TEST_F() [37/45]

TEST_F	(	BackendContractTest	,
		ShutdownClearsState	)

Definition at line 91 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    EXPECT_TRUE(backend_.is_initialized());
 
    auto result = backend_.shutdown();
    EXPECT_TRUE(result.is_ok());
    EXPECT_FALSE(backend_.is_initialized());
}

TEST_F() [38/45]

TEST_F	(	BackendContractTest	,
		ShutdownClearsTransactionState	)

Definition at line 285 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    backend_.begin_transaction();
    EXPECT_TRUE(backend_.in_transaction());
 
    backend_.shutdown();
    EXPECT_FALSE(backend_.in_transaction());
}

TEST_F() [39/45]

TEST_F	(	BackendContractTest	,
		SimulateShutdown	)

Definition at line 101 of file backend_contract_test.cpp.

{
    backend_.initialize(test_config_);
    backend_.simulate_shutdown();
    EXPECT_FALSE(backend_.is_initialized());
}

TEST_F() [40/45]

TEST_F	(	BackendContractTest	,
		TransactionCycleBeginCommitBeginRollback	)

Definition at line 270 of file backend_contract_test.cpp.

{
    // First cycle: begin -> commit
    EXPECT_TRUE(backend_.begin_transaction().is_ok());
    EXPECT_TRUE(backend_.in_transaction());
    EXPECT_TRUE(backend_.commit_transaction().is_ok());
    EXPECT_FALSE(backend_.in_transaction());
 
    // Second cycle: begin -> rollback
    EXPECT_TRUE(backend_.begin_transaction().is_ok());
    EXPECT_TRUE(backend_.in_transaction());
    EXPECT_TRUE(backend_.rollback_transaction().is_ok());
    EXPECT_FALSE(backend_.in_transaction());
}

TEST_F() [41/45]

TEST_F	(	BackendContractTest	,
		TransactionInitiallyInactive	)

Definition at line 224 of file backend_contract_test.cpp.

{
    EXPECT_FALSE(backend_.in_transaction());
}

TEST_F() [42/45]

TEST_F	(	BackendContractTest	,
		TypeReturnsConfiguredType	)

Definition at line 112 of file backend_contract_test.cpp.

{
    backend_.set_database_type(database_types::sqlite);
    EXPECT_EQ(backend_.type(), database_types::sqlite);
}

TEST_F() [43/45]

TEST_F	(	BackendContractTest	,
		VerifyAllExpectationsWhenAllMatched	)

Definition at line 398 of file backend_contract_test.cpp.

{
    backend_.expect_query("q1").will_return_rows(1).once();
    backend_.execute_query("q1");
    EXPECT_TRUE(backend_.verify_all_expectations());
}

TEST_F() [44/45]

TEST_F	(	BackendContractTest	,
		VerifyExpectationsFailsWhenUnmatched	)

Definition at line 405 of file backend_contract_test.cpp.

{
    backend_.expect_query("q1").will_return_rows(1).once();
    // Don't execute q1
    EXPECT_FALSE(backend_.verify_all_expectations());
}

TEST_F() [45/45]

TEST_F	(	BackendContractTest	,
		WithDataPreset	)

Definition at line 443 of file backend_contract_test.cpp.

{
    database_result test_data = {
        {{"id", int64_t(1)}, {"name", std::string("Test")}}
    };
    auto db = mock_backend_builder::with_data("users", test_data);
 
    auto result = db.select_query("SELECT * FROM users WHERE id = 1");
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().size(), 1u);
}

References ASSERT_TRUE, and database::testing::mock_backend_builder::with_data().

Here is the call graph for this function: