database::testing::mock_backend Class Reference

Configurable mock for database_backend interface. More...

#include <mock_backend.h>

Inheritance diagram for database::testing::mock_backend:

Collaboration diagram for database::testing::mock_backend:

Public Member Functions
	mock_backend ()
	~mock_backend () override=default
	mock_backend (const mock_backend &)=delete
mock_backend &	operator= (const mock_backend &)=delete
	mock_backend (mock_backend &&other) noexcept
mock_backend &	operator= (mock_backend &&other) noexcept
database_types	type () const override
	Get the database type of this backend.
kcenon::common::VoidResult	initialize (const core::connection_config &config) override
	Initialize the database backend.
kcenon::common::VoidResult	shutdown () override
	Shutdown the database backend gracefully.
bool	is_initialized () const override
	Check if backend is initialized and ready.
kcenon::common::Result< core::database_result >	select_query (const std::string &query_string) override
	Execute a SELECT query.
kcenon::common::VoidResult	execute_query (const std::string &query_string) override
	Execute a general SQL query (DDL, DML)
kcenon::common::VoidResult	begin_transaction () override
	Begin a transaction.
kcenon::common::VoidResult	commit_transaction () override
	Commit the current transaction.
kcenon::common::VoidResult	rollback_transaction () override
	Rollback the current transaction.
bool	in_transaction () const override
	Check if backend is currently in a transaction.
std::string	last_error () const override
	Get last error message from backend.
std::map< std::string, std::string >	connection_info () const override
	Get backend-specific connection information.
mock_backend &	set_database_type (database_types type)
mock_backend &	set_initialize_result (bool result, const std::string &error="")
mock_backend &	set_default_select_result (const core::database_result &result)
mock_backend &	set_default_rows_affected (uint64_t rows)
backend_expectation_builder	expect_query (const std::string &query)
backend_expectation_builder	expect_pattern (const std::string &regex_pattern)
backend_expectation_builder	expect_any ()
mock_backend &	simulate_initialization_failure (const std::string &error="Mock initialization failed")
mock_backend &	simulate_shutdown ()
bool	verify_all_expectations () const
std::vector< std::string >	get_executed_queries () const
size_t	get_query_count () const
size_t	get_query_count (const std::string &pattern) const
void	reset ()
void	clear_expectations ()
void	clear_history ()
std::string	get_connection_string () const
Public Member Functions inherited from database::core::database_backend
virtual	~database_backend ()=default
virtual kcenon::common::Result< database_result >	select_prepared (const std::string &query, const std::vector< database_value > &params)
	Execute a parameterized SELECT query (prepared statement)
virtual kcenon::common::VoidResult	execute_prepared (const std::string &query, const std::vector< database_value > &params)
	Execute a parameterized DML/DDL query (prepared statement)

Private Member Functions
void	record_query (const std::string &query)
backend_expectation *	find_expectation (const std::string &query)

Private Attributes
database_types	db_type_
bool	initialized_
bool	init_result_
std::string	init_error_
std::string	connection_string_
core::database_result	default_result_
uint64_t	default_rows_affected_
std::string	last_error_
bool	in_transaction_
std::vector< backend_expectation >	expectations_
std::vector< std::string >	executed_queries_
std::mutex	mutex_

Friends
class	backend_expectation_builder

Additional Inherited Members
Static Protected Member Functions inherited from database::core::database_backend
static std::string	expand_params (const std::string &query, const std::vector< database_value > &params)
	Expand positional parameters into a SQL string (fallback)

Detailed Description

Configurable mock for database_backend interface.

This is the modern mock class that implements database_backend and returns Result<T> types for proper error handling.

Features:

• Set expected queries and results with Result<T> types
• Simulate errors with proper error messages
• Record all executed queries for verification
• Pattern matching for flexible expectations
• Transaction state tracking

Example usage:

mock_backend db;
 
// Set up expectation
db.expect_query("SELECT * FROM users")
  .will_return(core::database_result{
      {{"id", int64_t(1)}, {"name", std::string("John")}}
  });
 
// Execute query
auto result = db.select_query("SELECT * FROM users");
EXPECT_TRUE(result.is_ok());
 
// Verify
EXPECT_TRUE(db.verify_all_expectations());

Definition at line 48 of file mock_backend.h.

Constructor & Destructor Documentation

mock_backend() [1/3]

database::testing::mock_backend::mock_backend

(

)

Definition at line 11 of file mock_backend.cpp.

    : db_type_(database_types::none)
    , initialized_(false)
    , init_result_(true)
    , default_rows_affected_(1)
    , in_transaction_(false)
{
}

~mock_backend()

database::testing::mock_backend::~mock_backend ( )

overridedefault

mock_backend() [2/3]

database::testing::mock_backend::mock_backend ( const mock_backend & )

delete

mock_backend() [3/3]

database::testing::mock_backend::mock_backend ( mock_backend && other )

noexcept

Definition at line 20 of file mock_backend.cpp.

    : db_type_(other.db_type_)
    , initialized_(other.initialized_)
    , init_result_(other.init_result_)
    , init_error_(std::move(other.init_error_))
    , connection_string_(std::move(other.connection_string_))
    , default_result_(std::move(other.default_result_))
    , default_rows_affected_(other.default_rows_affected_)
    , last_error_(std::move(other.last_error_))
    , in_transaction_(other.in_transaction_)
    , expectations_(std::move(other.expectations_))
    , executed_queries_(std::move(other.executed_queries_))
{
    other.initialized_ = false;
    other.in_transaction_ = false;
}

Member Function Documentation

begin_transaction()

kcenon::common::VoidResult database::testing::mock_backend::begin_transaction ( )

overridevirtual

Begin a transaction.

Returns

VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 102 of file mock_backend.cpp.

                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    if (in_transaction_) {
        last_error_ = "Transaction already in progress";
        return kcenon::common::VoidResult(kcenon::common::error_info{-1, last_error_});
    }
    in_transaction_ = true;
    return kcenon::common::VoidResult(std::monostate{});
}

References in_transaction_, last_error_, and mutex_.

clear_expectations()

void database::testing::mock_backend::clear_expectations

(

)

Definition at line 231 of file mock_backend.cpp.

                                      {
    std::lock_guard<std::mutex> lock(mutex_);
    expectations_.clear();
}

References expectations_, and mutex_.

clear_history()

void database::testing::mock_backend::clear_history

(

)

Definition at line 236 of file mock_backend.cpp.

                                 {
    std::lock_guard<std::mutex> lock(mutex_);
    executed_queries_.clear();
}

References executed_queries_, and mutex_.

commit_transaction()

kcenon::common::VoidResult database::testing::mock_backend::commit_transaction ( )

overridevirtual

Commit the current transaction.

Returns

VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 112 of file mock_backend.cpp.

                                                        {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!in_transaction_) {
        last_error_ = "No transaction in progress";
        return kcenon::common::VoidResult(kcenon::common::error_info{-1, last_error_});
    }
    in_transaction_ = false;
    return kcenon::common::VoidResult(std::monostate{});
}

References in_transaction_, last_error_, and mutex_.

connection_info()

std::map< std::string, std::string > database::testing::mock_backend::connection_info ( ) const

overridevirtual

Get backend-specific connection information.

Returns

Map of connection properties (for debugging/monitoring)

Example keys: "server_version", "connection_id", "protocol_version"

Implements database::core::database_backend.

Definition at line 140 of file mock_backend.cpp.

                                                                 {
    return {
        {"type", "mock"},
        {"connection_string", connection_string_},
        {"initialized", initialized_ ? "true" : "false"}
    };
}

References connection_string_, and initialized_.

execute_query()

kcenon::common::VoidResult database::testing::mock_backend::execute_query ( const std::string & query_string )

overridevirtual

Execute a general SQL query (DDL, DML)

Parameters

query_string

SQL statement

Returns

VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 92 of file mock_backend.cpp.

                                                                                {
    std::lock_guard<std::mutex> lock(mutex_);
    record_query(query_string);
 
    if (auto* exp = find_expectation(query_string)) {
        return exp->get_execute_result();
    }
    return kcenon::common::VoidResult(std::monostate{});
}

References find_expectation(), mutex_, and record_query().

Here is the call graph for this function:

expect_any()

backend_expectation_builder database::testing::mock_backend::expect_any

(

)

Definition at line 181 of file mock_backend.cpp.

                                                     {
    backend_expectation exp;
    exp.for_any();
    return backend_expectation_builder(this, std::move(exp));
}

References backend_expectation_builder, and database::testing::backend_expectation::for_any().

Referenced by database::testing::mock_backend_builder::failing_database().

Here is the call graph for this function:

Here is the caller graph for this function:

expect_pattern()

backend_expectation_builder database::testing::mock_backend::expect_pattern

(

const std::string &

regex_pattern

)

Definition at line 175 of file mock_backend.cpp.

                                                                                       {
    backend_expectation exp;
    exp.for_pattern(regex_pattern);
    return backend_expectation_builder(this, std::move(exp));
}

References backend_expectation_builder, and database::testing::backend_expectation::for_pattern().

Referenced by database::testing::mock_backend_builder::with_data().

Here is the call graph for this function:

Here is the caller graph for this function:

expect_query()

backend_expectation_builder database::testing::mock_backend::expect_query

(

const std::string &

query

)

Definition at line 169 of file mock_backend.cpp.

                                                                             {
    backend_expectation exp;
    exp.for_query(query, backend_match_type::EXACT);
    return backend_expectation_builder(this, std::move(exp));
}

References backend_expectation_builder, database::testing::EXACT, and database::testing::backend_expectation::for_query().

Here is the call graph for this function:

find_expectation()

backend_expectation * database::testing::mock_backend::find_expectation ( const std::string & query )

private

Definition at line 249 of file mock_backend.cpp.

                                                                          {
    for (auto& exp : expectations_) {
        if (exp.matches(query) && exp.can_be_invoked()) {
            return &exp;
        }
    }
    return nullptr;
}

References expectations_.

Referenced by execute_query(), and select_query().

Here is the caller graph for this function:

get_connection_string()

std::string database::testing::mock_backend::get_connection_string

(

)

const

Definition at line 241 of file mock_backend.cpp.

                                                    {
    return connection_string_;
}

References connection_string_.

get_executed_queries()

std::vector< std::string > database::testing::mock_backend::get_executed_queries

(

)

const

Definition at line 204 of file mock_backend.cpp.

                                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    return executed_queries_;
}

References executed_queries_, and mutex_.

get_query_count() [1/2]

size_t database::testing::mock_backend::get_query_count

(

)

const

Definition at line 209 of file mock_backend.cpp.

                                           {
    std::lock_guard<std::mutex> lock(mutex_);
    return executed_queries_.size();
}

References executed_queries_, and mutex_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

get_query_count() [2/2]

size_t database::testing::mock_backend::get_query_count

(

const std::string &

pattern

)

const

Definition at line 214 of file mock_backend.cpp.

                                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
    std::regex re(pattern);
    return std::count_if(executed_queries_.begin(), executed_queries_.end(),
                         [&re](const std::string& q) { return std::regex_search(q, re); });
}

References executed_queries_, and mutex_.

in_transaction()

bool database::testing::mock_backend::in_transaction ( ) const

overridevirtual

Check if backend is currently in a transaction.

Returns

true if transaction is active

Implements database::core::database_backend.

Definition at line 132 of file mock_backend.cpp.

                                        {
    return in_transaction_;
}

References in_transaction_.

initialize()

kcenon::common::VoidResult database::testing::mock_backend::initialize ( const core::connection_config & config )

overridevirtual

Initialize the database backend.

Parameters

config

Connection configuration

Returns

VoidResult::ok() on success, error on failure

This method should:

• Establish database connection
• Validate connection parameters
• Set up connection pooling if applicable
• Initialize backend-specific resources

Implements database::core::database_backend.

Definition at line 60 of file mock_backend.cpp.

                                                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
    connection_string_ = config.host + ":" + std::to_string(config.port) + "/" + config.database;
    if (init_result_) {
        initialized_ = true;
        return kcenon::common::VoidResult(std::monostate{});
    }
    last_error_ = init_error_.empty() ? "Mock initialization failed" : init_error_;
    return kcenon::common::VoidResult(kcenon::common::error_info{-1, last_error_});
}

References connection_string_, database::core::connection_config::database, database::core::connection_config::host, init_error_, init_result_, initialized_, last_error_, mutex_, and database::core::connection_config::port.

Referenced by TEST_F().

Here is the caller graph for this function:

is_initialized()

bool database::testing::mock_backend::is_initialized ( ) const

overridevirtual

Check if backend is initialized and ready.

Returns

true if initialized and can accept queries

Implements database::core::database_backend.

Definition at line 78 of file mock_backend.cpp.

                                        {
    return initialized_;
}

References initialized_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

last_error()

std::string database::testing::mock_backend::last_error ( ) const

overridevirtual

Get last error message from backend.

Returns

Error message, or empty string if no error

Implements database::core::database_backend.

Definition at line 136 of file mock_backend.cpp.

                                         {
    return last_error_;
}

References last_error_.

operator=() [1/2]

mock_backend & database::testing::mock_backend::operator= ( const mock_backend & )

delete

operator=() [2/2]

mock_backend & database::testing::mock_backend::operator= ( mock_backend && other )

noexcept

Definition at line 37 of file mock_backend.cpp.

                                                                   {
    if (this != &other) {
        db_type_ = other.db_type_;
        initialized_ = other.initialized_;
        init_result_ = other.init_result_;
        init_error_ = std::move(other.init_error_);
        connection_string_ = std::move(other.connection_string_);
        default_result_ = std::move(other.default_result_);
        default_rows_affected_ = other.default_rows_affected_;
        last_error_ = std::move(other.last_error_);
        in_transaction_ = other.in_transaction_;
        expectations_ = std::move(other.expectations_);
        executed_queries_ = std::move(other.executed_queries_);
        other.initialized_ = false;
        other.in_transaction_ = false;
    }
    return *this;
}

record_query()

void database::testing::mock_backend::record_query ( const std::string & query )

private

Definition at line 245 of file mock_backend.cpp.

                                                      {
    executed_queries_.push_back(query);
}

References executed_queries_.

Referenced by execute_query(), and select_query().

Here is the caller graph for this function:

reset()

void database::testing::mock_backend::reset

(

)

Definition at line 221 of file mock_backend.cpp.

                         {
    std::lock_guard<std::mutex> lock(mutex_);
    expectations_.clear();
    executed_queries_.clear();
    initialized_ = false;
    in_transaction_ = false;
    connection_string_.clear();
    last_error_.clear();
}

References connection_string_, executed_queries_, expectations_, in_transaction_, initialized_, last_error_, and mutex_.

rollback_transaction()

kcenon::common::VoidResult database::testing::mock_backend::rollback_transaction ( )

overridevirtual

Rollback the current transaction.

Returns

VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 122 of file mock_backend.cpp.

                                                          {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!in_transaction_) {
        last_error_ = "No transaction in progress";
        return kcenon::common::VoidResult(kcenon::common::error_info{-1, last_error_});
    }
    in_transaction_ = false;
    return kcenon::common::VoidResult(std::monostate{});
}

References in_transaction_, last_error_, and mutex_.

select_query()

kcenon::common::Result< core::database_result > database::testing::mock_backend::select_query ( const std::string & query_string )

overridevirtual

Execute a SELECT query.

Parameters

query_string

SQL SELECT statement

Returns

Query results as rows, or error

Implements database::core::database_backend.

Definition at line 82 of file mock_backend.cpp.

                                                                                                {
    std::lock_guard<std::mutex> lock(mutex_);
    record_query(query_string);
 
    if (auto* exp = find_expectation(query_string)) {
        return exp->get_select_result();
    }
    return kcenon::common::Result<core::database_result>::ok(default_result_);
}

References default_result_, find_expectation(), mutex_, and record_query().

Here is the call graph for this function:

set_database_type()

mock_backend & database::testing::mock_backend::set_database_type

(

database_types

type

)

Definition at line 148 of file mock_backend.cpp.

                                                                 {
    db_type_ = type;
    return *this;
}

References db_type_, and type().

Referenced by BackendContractTest::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

set_default_rows_affected()

mock_backend & database::testing::mock_backend::set_default_rows_affected

(

uint64_t

rows

)

Definition at line 164 of file mock_backend.cpp.

                                                                   {
    default_rows_affected_ = rows;
    return *this;
}

References default_rows_affected_.

set_default_select_result()

mock_backend & database::testing::mock_backend::set_default_select_result

(

const core::database_result &

result

)

Definition at line 159 of file mock_backend.cpp.

                                                                                       {
    default_result_ = result;
    return *this;
}

References default_result_.

set_initialize_result()

mock_backend & database::testing::mock_backend::set_initialize_result	(	bool	result,
		const std::string &	error = "" )

Definition at line 153 of file mock_backend.cpp.

                                                                                     {
    init_result_ = result;
    init_error_ = error;
    return *this;
}

References init_error_, and init_result_.

shutdown()

kcenon::common::VoidResult database::testing::mock_backend::shutdown ( )

overridevirtual

Shutdown the database backend gracefully.

Returns

VoidResult::ok() on success, error on failure

This method should:

• Close active connections
• Release connection pool resources
• Flush pending transactions
• Clean up backend-specific resources

Implements database::core::database_backend.

Definition at line 71 of file mock_backend.cpp.

                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    initialized_ = false;
    in_transaction_ = false;
    return kcenon::common::VoidResult(std::monostate{});
}

References in_transaction_, initialized_, and mutex_.

simulate_initialization_failure()

mock_backend & database::testing::mock_backend::simulate_initialization_failure

(

const std::string &

error = "Mock initialization failed"

)

Definition at line 187 of file mock_backend.cpp.

                                                                                  {
    init_result_ = false;
    init_error_ = error;
    return *this;
}

References init_error_, and init_result_.

simulate_shutdown()

mock_backend & database::testing::mock_backend::simulate_shutdown

(

)

Definition at line 193 of file mock_backend.cpp.

                                              {
    initialized_ = false;
    return *this;
}

References initialized_.

type()

database_types database::testing::mock_backend::type ( ) const

overridevirtual

Get the database type of this backend.

Returns

Database type identifier

Implements database::core::database_backend.

Definition at line 56 of file mock_backend.cpp.

                                        {
    return db_type_;
}

References db_type_.

Referenced by set_database_type(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

verify_all_expectations()

bool database::testing::mock_backend::verify_all_expectations

(

)

const

Definition at line 198 of file mock_backend.cpp.

                                                 {
    std::lock_guard<std::mutex> lock(mutex_);
    return std::all_of(expectations_.begin(), expectations_.end(),
                       [](const backend_expectation& exp) { return exp.is_satisfied(); });
}

References expectations_, and mutex_.

Friends And Related Symbol Documentation

backend_expectation_builder

friend class backend_expectation_builder

friend

Definition at line 106 of file mock_backend.h.

Referenced by expect_any(), expect_pattern(), and expect_query().

Member Data Documentation

connection_string_

std::string database::testing::mock_backend::connection_string_

private

Definition at line 112 of file mock_backend.h.

Referenced by connection_info(), get_connection_string(), initialize(), and reset().

db_type_

database_types database::testing::mock_backend::db_type_

private

Definition at line 108 of file mock_backend.h.

Referenced by set_database_type(), and type().

default_result_

core::database_result database::testing::mock_backend::default_result_

private

Definition at line 113 of file mock_backend.h.

Referenced by select_query(), and set_default_select_result().

default_rows_affected_

uint64_t database::testing::mock_backend::default_rows_affected_

private

Definition at line 114 of file mock_backend.h.

Referenced by set_default_rows_affected().

executed_queries_

std::vector<std::string> database::testing::mock_backend::executed_queries_

private

Definition at line 119 of file mock_backend.h.

Referenced by clear_history(), get_executed_queries(), get_query_count(), get_query_count(), record_query(), and reset().

expectations_

std::vector<backend_expectation> database::testing::mock_backend::expectations_

private

Definition at line 118 of file mock_backend.h.

Referenced by database::testing::backend_expectation_builder::any_times(), clear_expectations(), find_expectation(), database::testing::backend_expectation_builder::once(), reset(), database::testing::backend_expectation_builder::times(), verify_all_expectations(), database::testing::backend_expectation_builder::will_fail(), database::testing::backend_expectation_builder::will_return(), database::testing::backend_expectation_builder::will_return_rows(), and database::testing::backend_expectation_builder::will_succeed().

in_transaction_

bool database::testing::mock_backend::in_transaction_

private

Definition at line 116 of file mock_backend.h.

Referenced by begin_transaction(), commit_transaction(), in_transaction(), reset(), rollback_transaction(), and shutdown().

init_error_

std::string database::testing::mock_backend::init_error_

private

Definition at line 111 of file mock_backend.h.

Referenced by initialize(), set_initialize_result(), and simulate_initialization_failure().

init_result_

bool database::testing::mock_backend::init_result_

private

Definition at line 110 of file mock_backend.h.

Referenced by initialize(), set_initialize_result(), and simulate_initialization_failure().

initialized_

bool database::testing::mock_backend::initialized_

private

Definition at line 109 of file mock_backend.h.

Referenced by connection_info(), initialize(), is_initialized(), reset(), shutdown(), and simulate_shutdown().

last_error_

std::string database::testing::mock_backend::last_error_

private

Definition at line 115 of file mock_backend.h.

Referenced by begin_transaction(), commit_transaction(), initialize(), last_error(), reset(), and rollback_transaction().

mutex_

std::mutex database::testing::mock_backend::mutex_

mutableprivate

Definition at line 120 of file mock_backend.h.

Referenced by begin_transaction(), clear_expectations(), clear_history(), commit_transaction(), execute_query(), get_executed_queries(), get_query_count(), get_query_count(), initialize(), reset(), rollback_transaction(), select_query(), shutdown(), and verify_all_expectations().

---

The documentation for this class was generated from the following files:

• tests/mocks/mock_backend.h
• tests/mocks/mock_backend.cpp