Struct BoxedDatabaseEntryPoint

pub struct BoxedDatabaseEntryPoint<DB>
where
    DB: DatabaseBackend + Send + Sync + Debug + 'static,
{ /* private fields */ }

Entry point for database operations with automatic boxing of closures

This provides functionality for database operations with automatic boxing of future closures to solve lifetime issues. Use the boxed_async! macro to easily create boxed async blocks.

Implementations

impl<DB> BoxedDatabaseEntryPoint<DB>

where DB: DatabaseBackend + Send + Sync + Debug + 'static,

pub fn new(backend: DB) -> Self

Create a new entry point with the given backend

pub fn setup<F>(self, setup_fn: F) -> BoxedSetupHandler<DB>

where F: for<'a> FnOnce(&'a mut <DB::Pool as DatabasePool>::Connection) -> Pin<Box<dyn Future<Output = Result<(), DB::Error>> + Send + 'a>> + Send + Sync + 'static,

Set up the database with the given function

This method takes a closure that will be executed during setup. Use the boxed_async! macro to create an async block that captures variables without lifetime issues.

pub fn with_transaction<F>( self, transaction_fn: F, ) -> BoxedTransactionOnlyHandler<DB>

where F: for<'a> FnOnce(&'a mut <DB as DatabaseBackend>::Connection) -> Pin<Box<dyn Future<Output = Result<(), DB::Error>> + Send + 'a>> + Send + Sync + 'static,

Initialize a database with a transaction

pub async fn execute(self) -> Result<TestContext<DB>, DB::Error>

Execute this handler

pub fn setup_async<F, Fut>(self, setup_fn: F) -> BoxedSetupHandler<DB>

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

Add an async setup function without requiring boxed_async

This method provides a more ergonomic API without requiring manual boxing

pub fn transaction<F, Fut>( self, transaction_fn: F, ) -> BoxedTransactionOnlyHandler<DB>

where F: FnOnce(&mut <DB as DatabaseBackend>::Connection) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), DB::Error>> + Send + 'static,

Add a transaction function without requiring boxed_async

This method provides a more ergonomic API without requiring manual boxing

pub async fn run(self) -> Result<TestContext<DB>, DB::Error>

Run the handler

This is an alias for execute() with a more intuitive name

Trait Implementations

impl<DB> TransactionHandler<DB> for BoxedDatabaseEntryPoint<DB>

where DB: DatabaseBackend + Send + Sync + Debug + 'static,

type Item = TestContext<DB>

The result type of this handler

type Error = <DB as DatabaseBackend>::Error

The error type

fn execute<'life0, 'async_trait>( self, _ctx: &'life0 mut TestContext<DB>, ) -> Pin<Box<dyn Future<Output = Result<Self::Item, Self::Error>> + Send + 'async_trait>>

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

Execute the handler with the given context

fn execute_standalone<'async_trait>( self, backend: DB, ) -> Pin<Box<dyn Future<Output = Result<Self::Item, Self::Error>> + Send + 'async_trait>>

where Self: Sized + 'async_trait,

Execute this handler with a new context

fn and_then<F, B>(self, f: F) -> AndThenHandler<DB, Self, B, F>

where Self: Sized, B: TransactionHandler<DB, Error = Self::Error> + Send + Sync, F: FnOnce(Self::Item) -> B + Send + Sync + 'static,

Chain two handlers together, where the second handler may depend on the result of the first

fn setup<S, Fut, E>( self, setup_fn: S, ) -> impl TransactionHandler<DB, Item = (), Error = Self::Error>

where Self: Sized, E: From<DB::Error> + From<Self::Error> + Send + Sync, Fut: Future<Output = Result<(), DB::Error>> + Send + 'static, S: FnOnce(&mut <DB::Pool as DatabasePool>::Connection) -> Fut + Send + Sync + 'static,

Add a setup operation to this handler

fn with_transaction<F, Fut, E>( self, transaction_fn: F, ) -> impl TransactionHandler<DB, Item = (), Error = Self::Error>

where Self: Sized, E: From<DB::Error> + From<Self::Error> + Send + Sync, Fut: Future<Output = Result<(), DB::Error>> + Send + 'static, F: FnOnce(&mut <DB as DatabaseBackend>::Connection) -> Fut + Send + Sync + 'static,

Add a transaction operation to this handler

fn with_db_transaction<F, Fut, E>( self, db: TestDatabaseInstance<DB>, transaction_fn: F, ) -> impl TransactionHandler<DB, Item = TestContext<DB>, Error = Self::Error>

where Self: Sized, E: From<DB::Error> + From<Self::Error> + Send + Sync, Fut: Future<Output = Result<(), DB::Error>> + Send + 'static, F: FnOnce(&mut <DB as DatabaseBackend>::Connection) -> Fut + Send + Sync + 'static,

Create a database transaction handler from this handler

fn run_with_database<'async_trait>( self, backend: DB, ) -> Pin<Box<dyn Future<Output = Result<TestContext<DB>, Self::Error>> + Send + 'async_trait>>

where Self: Sized + 'async_trait,

Run this handler with a new database instance