database::testing::mock_connection_pool Class Reference

Mock connection pool for testing pool-related functionality. More...

#include <mock_connection_pool.h>

Collaboration diagram for database::testing::mock_connection_pool:

Classes
struct	config
struct	stats
	Get current pool statistics. More...

Public Member Functions
	mock_connection_pool (const config &cfg={})
	~mock_connection_pool ()
mock_database *	acquire ()
	Acquire a connection from the pool.
mock_database *	acquire (std::chrono::milliseconds timeout)
	Acquire a connection with timeout.
void	release (mock_database *conn)
	Release a connection back to the pool.
stats	get_stats () const
void	simulate_exhaustion ()
	Simulate pool exhaustion.
void	reset ()
	Reset pool to normal operation.
void	configure_all (std::function< void(mock_database &)> configurator)
	Configure all connections with same expectation.

Private Member Functions
void	create_connection ()

Private Attributes
config	config_
std::vector< std::unique_ptr< mock_database > >	connections_
std::queue< mock_database * >	available_
std::set< mock_database * >	in_use_
std::mutex	mutex_
std::condition_variable	cv_
std::atomic< bool >	exhausted_ {false}
std::atomic< size_t >	total_acquisitions_ {0}
std::atomic< size_t >	total_releases_ {0}
std::atomic< size_t >	acquisition_timeouts_ {0}

Detailed Description

Mock connection pool for testing pool-related functionality.

Features:

• Configurable pool size
• Simulated connection acquisition delays
• Connection leak detection
• Pool exhaustion simulation

Definition at line 28 of file mock_connection_pool.h.

Constructor & Destructor Documentation

mock_connection_pool()

database::testing::mock_connection_pool::mock_connection_pool ( const config & cfg = {} )

inlineexplicit

Definition at line 148 of file mock_connection_pool.h.

    : config_(cfg)
{
    for (size_t i = 0; i < config_.min_size; ++i) {
        create_connection();
    }
}

References config_, create_connection(), and database::testing::mock_connection_pool::config::min_size.

Here is the call graph for this function:

~mock_connection_pool()

database::testing::mock_connection_pool::~mock_connection_pool ( )

inlinedefault

Member Function Documentation

acquire() [1/2]

mock_database * database::testing::mock_connection_pool::acquire ( )

inline

Acquire a connection from the pool.

Returns

Pointer to mock_database, or nullptr if pool is exhausted

Definition at line 164 of file mock_connection_pool.h.

                                                    {
    return acquire(config_.acquire_timeout);
}

References acquire(), database::testing::mock_connection_pool::config::acquire_timeout, and config_.

Referenced by acquire().

Here is the call graph for this function:

Here is the caller graph for this function:

acquire() [2/2]

mock_database * database::testing::mock_connection_pool::acquire ( std::chrono::milliseconds timeout )

inline

Acquire a connection with timeout.

Parameters

timeout

Maximum time to wait

Returns

Pointer to mock_database, or nullptr if timeout

Definition at line 168 of file mock_connection_pool.h.

                                                                                 {
    std::unique_lock<std::mutex> lock(mutex_);
 
    if (exhausted_) {
        ++acquisition_timeouts_;
        return nullptr;
    }
 
    // Wait for available connection or create new one
    auto deadline = std::chrono::steady_clock::now() + timeout;
    while (available_.empty()) {
        if (connections_.size() < config_.max_size) {
            create_connection();
            break;
        }
 
        if (cv_.wait_until(lock, deadline) == std::cv_status::timeout) {
            ++acquisition_timeouts_;
            return nullptr;
        }
 
        if (exhausted_) {
            ++acquisition_timeouts_;
            return nullptr;
        }
    }
 
    if (available_.empty()) {
        ++acquisition_timeouts_;
        return nullptr;
    }
 
    auto* conn = available_.front();
    available_.pop();
    in_use_.insert(conn);
    ++total_acquisitions_;
 
    // Simulate slow acquisition if configured
    if (config_.simulate_slow_acquire) {
        lock.unlock();
        std::this_thread::sleep_for(config_.slow_acquire_delay);
    }
 
    return conn;
}

References acquisition_timeouts_, available_, config_, connections_, create_connection(), cv_, exhausted_, in_use_, database::testing::mock_connection_pool::config::max_size, mutex_, database::testing::mock_connection_pool::config::simulate_slow_acquire, database::testing::mock_connection_pool::config::slow_acquire_delay, database::timeout, and total_acquisitions_.

Here is the call graph for this function:

configure_all()

void database::testing::mock_connection_pool::configure_all ( std::function< void(mock_database &)> configurator )

inline

Configure all connections with same expectation.

Definition at line 250 of file mock_connection_pool.h.

                                                                                              {
    std::lock_guard<std::mutex> lock(mutex_);
    for (auto& conn : connections_) {
        configurator(*conn);
    }
}

References connections_, and mutex_.

create_connection()

void database::testing::mock_connection_pool::create_connection ( )

inlineprivate

Definition at line 158 of file mock_connection_pool.h.

                                                    {
    auto conn = std::make_unique<mock_database>();
    available_.push(conn.get());
    connections_.push_back(std::move(conn));
}

References available_, and connections_.

Referenced by acquire(), and mock_connection_pool().

Here is the caller graph for this function:

get_stats()

mock_connection_pool::stats database::testing::mock_connection_pool::get_stats ( ) const

inline

Definition at line 223 of file mock_connection_pool.h.

                                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    return {
        connections_.size(),
        available_.size(),
        in_use_.size(),
        total_acquisitions_.load(),
        total_releases_.load(),
        acquisition_timeouts_.load(),
        total_acquisitions_.load() - total_releases_.load()
    };
}

References acquisition_timeouts_, available_, connections_, in_use_, mutex_, total_acquisitions_, and total_releases_.

release()

void database::testing::mock_connection_pool::release ( mock_database * conn )

inline

Release a connection back to the pool.

Parameters

conn	Connection to release

Definition at line 214 of file mock_connection_pool.h.

                                                             {
    std::lock_guard<std::mutex> lock(mutex_);
    if (in_use_.erase(conn)) {
        available_.push(conn);
        ++total_releases_;
        cv_.notify_one();
    }
}

References available_, cv_, in_use_, mutex_, and total_releases_.

Referenced by database::testing::scoped_connection::~scoped_connection().

Here is the caller graph for this function:

reset()

void database::testing::mock_connection_pool::reset ( )

inline

Reset pool to normal operation.

Definition at line 240 of file mock_connection_pool.h.

                                        {
    std::lock_guard<std::mutex> lock(mutex_);
    exhausted_ = false;
    // Return all in-use to available
    for (auto* conn : in_use_) {
        available_.push(conn);
    }
    in_use_.clear();
}

References available_, exhausted_, in_use_, and mutex_.

simulate_exhaustion()

void database::testing::mock_connection_pool::simulate_exhaustion ( )

inline

Simulate pool exhaustion.

Definition at line 236 of file mock_connection_pool.h.

                                                      {
    exhausted_ = true;
}

References exhausted_.

Member Data Documentation

acquisition_timeouts_

std::atomic<size_t> database::testing::mock_connection_pool::acquisition_timeouts_ {0}

private

Definition at line 101 of file mock_connection_pool.h.

{0};

Referenced by acquire(), and get_stats().

available_

std::queue<mock_database*> database::testing::mock_connection_pool::available_

private

Definition at line 92 of file mock_connection_pool.h.

Referenced by acquire(), create_connection(), get_stats(), release(), and reset().

config_

config database::testing::mock_connection_pool::config_

private

Definition at line 90 of file mock_connection_pool.h.

Referenced by acquire(), acquire(), and mock_connection_pool().

connections_

std::vector<std::unique_ptr<mock_database> > database::testing::mock_connection_pool::connections_

private

Definition at line 91 of file mock_connection_pool.h.

Referenced by acquire(), configure_all(), create_connection(), and get_stats().

cv_

std::condition_variable database::testing::mock_connection_pool::cv_

private

Definition at line 95 of file mock_connection_pool.h.

Referenced by acquire(), and release().

exhausted_

std::atomic<bool> database::testing::mock_connection_pool::exhausted_ {false}

private

Definition at line 96 of file mock_connection_pool.h.

{false};

Referenced by acquire(), reset(), and simulate_exhaustion().

in_use_

std::set<mock_database*> database::testing::mock_connection_pool::in_use_

private

Definition at line 93 of file mock_connection_pool.h.

Referenced by acquire(), get_stats(), release(), and reset().

mutex_

std::mutex database::testing::mock_connection_pool::mutex_

mutableprivate

Definition at line 94 of file mock_connection_pool.h.

Referenced by acquire(), configure_all(), get_stats(), release(), and reset().

total_acquisitions_

std::atomic<size_t> database::testing::mock_connection_pool::total_acquisitions_ {0}

private

Definition at line 99 of file mock_connection_pool.h.

{0};

Referenced by acquire(), and get_stats().

total_releases_

std::atomic<size_t> database::testing::mock_connection_pool::total_releases_ {0}

private

Definition at line 100 of file mock_connection_pool.h.

{0};

Referenced by get_stats(), and release().

---

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

• tests/mocks/mock_connection_pool.h