Struct MockDatabaseBackend 

pub struct MockDatabaseBackend { /* private fields */ }

Mock implementation of DatabaseBackend trait using mockall

This mock provides automatic verification of method calls and arguments.

Usage with rstest Fixtures

For complete examples using rstest fixtures, see the unit tests in this module:

• test_mock_execute_with_verification() - Demonstrates strict argument verification
• test_with_mock_database() - Shows usage with the mock_database fixture
• test_with_mock_connection() - Shows usage with the mock_connection fixture

Direct Usage Example

use reinhardt_testkit::fixtures::MockDatabaseBackend;
use reinhardt_db::backends::types::{QueryResult, QueryValue};
use reinhardt_db::backends::backend::DatabaseBackend as BackendTrait;

#[tokio::main]
async fn main() {
    let mut mock = MockDatabaseBackend::new();

    // Set expectations with strict argument verification
    mock.expect_execute()
        .withf(|sql, params| {
            sql.contains("INSERT INTO users") && params.len() == 2
        })
        .times(1)
        .returning(|_, _| Ok(QueryResult { rows_affected: 1 }));

    // Execute the query (must call to satisfy .times(1) expectation)
    let result = mock.execute(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        vec![
            QueryValue::String("Alice".to_string()),
            QueryValue::String("alice@example.com".to_string()),
        ],
    ).await;

    assert!(result.is_ok());
    // Mock automatically verifies expectations on drop
}

Implementations

impl MockDatabaseBackend

pub fn checkpoint(&mut self)

Validate that all current expectations for all methods have been satisfied, and discard them.

pub fn new() -> Self

Create a new mock object with no expectations.

This method will not be generated if the real struct already has a new method. However, it will be generated if the struct implements a trait with a new method. The trait’s new method can still be called like <MockX as TraitY>::new

impl MockDatabaseBackend

pub fn expect_database_type(&mut self) -> &mut Expectation

Create an Expectation for mocking the database_type method

pub fn expect_placeholder(&mut self) -> &mut Expectation

Create an Expectation for mocking the placeholder method

pub fn expect_supports_returning(&mut self) -> &mut Expectation

Create an Expectation for mocking the supports_returning method

pub fn expect_supports_on_conflict(&mut self) -> &mut Expectation

Create an Expectation for mocking the supports_on_conflict method

pub fn expect_execute(&mut self) -> &mut Expectation

Create an Expectation for mocking the execute method

pub fn expect_fetch_one(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch_one method

pub fn expect_fetch_all(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch_all method

pub fn expect_fetch_optional(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch_optional method

pub fn expect_begin(&mut self) -> &mut Expectation

Create an Expectation for mocking the begin method

pub fn expect_as_any(&mut self) -> &mut Expectation

Create an Expectation for mocking the as_any method

Trait Implementations

impl DatabaseBackend for MockDatabaseBackend

fn database_type(&self) -> DatabaseType

Returns the database type

fn placeholder(&self, index: usize) -> String

Generates a placeholder for the given parameter index (1-based)

fn supports_returning(&self) -> bool

Returns whether the database supports RETURNING clause

fn supports_on_conflict(&self) -> bool

Returns whether the database supports ON CONFLICT clause

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<QueryValue>, ) -> Pin<Box<dyn Future<Output = Result<QueryResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Executes a query that modifies the database

fn fetch_one<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<QueryValue>, ) -> Pin<Box<dyn Future<Output = Result<Row>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetches a single row from the database

fn fetch_all<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<QueryValue>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Row>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetches all matching rows from the database

fn fetch_optional<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, params: Vec<QueryValue>, ) -> Pin<Box<dyn Future<Output = Result<Option<Row>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetches an optional single row from the database

fn begin<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn TransactionExecutor>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Begin a database transaction and return a dedicated executor

fn as_any(&self) -> &dyn Any

Returns self as &dyn std::any::Any for downcasting

fn supports_transactional_ddl(&self) -> bool

Returns whether DDL statements can be rolled back in transactions

fn begin_with_isolation<'life0, 'async_trait>( &'life0 self, isolation_level: IsolationLevel, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn TransactionExecutor>, DatabaseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Begin a database transaction with a specific isolation level

impl Default for MockDatabaseBackend

fn default() -> Self

Returns the “default value” for a type.

impl Send for MockDatabaseBackend

impl Sync for MockDatabaseBackend