Struct TestDatabaseInstance

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

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::Pool

The connection pool

db_name: DatabaseName

The database name

connection_pool: Option<Arc<Mutex<Vec<B::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<Self, B::Error>

Create a new test database with the given backend

pub async fn new_with_name( backend: B, config: DatabaseConfig, db_name: DatabaseName, ) -> Result<Self, B::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::Connection, B::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::Error>

where F: FnOnce(&B::Connection) -> Pin<Box<dyn Future<Output = Result<R, E>> + Send>> + Send, E: Error + Send + Sync + 'static, B::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::Pool as DatabasePool>::Connection, B::Error>

Get a connection from the pool or acquire a new one

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

Release a connection back to the pool

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

where F: FnOnce(&mut <B::Pool as DatabasePool>::Connection) -> Fut + Send, Fut: Future<Output = Result<(), B::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: DatabaseBackend + 'static + Clone + Debug + Send + Sync + Clone, B::Pool: Clone, B::Connection: Clone,

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

Returns a duplicate 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

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.