Struct TestDatabaseInstance

pub struct TestDatabaseInstance<B>
where
    B: DatabaseBackend + 'static + Clone + Debug + Send + Sync,
{
    pub backend: B,
    pub pool: <B as DatabaseBackend>::Pool,
    pub db_name: DatabaseName,
    pub connection_pool: Option<Arc<Mutex<RawMutex, Vec<<B as DatabaseBackend>::Connection>>>>,
}

Re-export the traits from testkit-core A test database that handles setup, connections, and cleanup TODO: Create a TestManager that can handle connection pooling and cleanup

Fields

backend: B

The database backend

pool: <B as DatabaseBackend>::Pool

The connection pool

db_name: DatabaseName

The database name

connection_pool: Option<Arc<Mutex<RawMutex, Vec<<B as DatabaseBackend>::Connection>>>>

The connection pool

Implementations

impl<B> TestDatabaseInstance<B>

where B: DatabaseBackend + 'static + Clone + Debug + Send + Sync,

pub async fn new( backend: B, config: DatabaseConfig, ) -> Result<TestDatabaseInstance<B>, <B as DatabaseBackend>::Error>

Create a new test database with the given backend

pub async fn new_with_name( backend: B, config: DatabaseConfig, db_name: DatabaseName, ) -> Result<TestDatabaseInstance<B>, <B as DatabaseBackend>::Error>

Create a new test database with the given backend and specific name

pub fn backend(&self) -> &B

Returns a reference to the backend

pub fn name(&self) -> &DatabaseName

Returns a reference to the database name

pub async fn connect( &self, ) -> Result<<B as DatabaseBackend>::Connection, <B as DatabaseBackend>::Error>

Create a single connection to the database without using the pool This is useful for cases where a single connection is needed for a specific operation

pub async fn with_connection<F, R, E>( &self, operation: F, ) -> Result<R, <B as DatabaseBackend>::Error>

where F: FnOnce(&<B as DatabaseBackend>::Connection) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send>> + Send, E: Error + Send + Sync + 'static, <B as DatabaseBackend>::Error: From<E>,

Execute a function with a one-off connection and automatically close it after use This is the most efficient way to perform a one-off database operation

pub async fn acquire_connection( &self, ) -> Result<<<B as DatabaseBackend>::Pool as DatabasePool>::Connection, <B as DatabaseBackend>::Error>

Get a connection from the pool or acquire a new one

pub async fn release_connection( &self, conn: <<B as DatabaseBackend>::Pool as DatabasePool>::Connection, ) -> Result<(), <B as DatabaseBackend>::Error>

Release a connection back to the pool

pub async fn setup<F, Fut>( &self, setup_fn: F, ) -> Result<(), <B as DatabaseBackend>::Error>

where F: FnOnce(&mut <<B as DatabaseBackend>::Pool as DatabasePool>::Connection) -> Fut + Send, Fut: Future<Output = Result<(), <B as DatabaseBackend>::Error>> + Send,

Setup the database with a function The connection handling approach needs to match the expected B::Connection type

Trait Implementations

impl<B> Clone for TestDatabaseInstance<B>

where B: Clone + DatabaseBackend + 'static + Debug + Send + Sync, <B as DatabaseBackend>::Pool: Clone, <B as DatabaseBackend>::Connection: Clone,

fn clone(&self) -> TestDatabaseInstance<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B> Debug for TestDatabaseInstance<B>

where B: DatabaseBackend + 'static + Clone + Debug + Send + Sync,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<B> Drop for TestDatabaseInstance<B>

where B: DatabaseBackend + Clone + Debug + Send + Sync + 'static,

fn drop(&mut self)

Executes the destructor for this type.

impl TransactionManager for TestDatabaseInstance<PostgresBackend>

Implementation of TransactionManager for PostgreSQL

type Error = PostgresError

type Tx = PostgresTransaction

type Connection = PostgresConnection

fn begin_transaction<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Self::Tx, Self::Error>> + Send + 'async_trait>>

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

fn commit_transaction<'life0, 'async_trait>( tx: &'life0 mut Self::Tx, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

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

fn rollback_transaction<'life0, 'async_trait>( tx: &'life0 mut Self::Tx, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

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