Struct AndThenHandler

pub struct AndThenHandler<DB, A, B, F>
where
    DB: DatabaseBackend + Send + Sync + Debug + 'static,
    A: TransactionHandler<DB> + Send + Sync,
    B: TransactionHandler<DB, Error = A::Error> + Send + Sync,
    F: FnOnce(A::Item) -> B + Send + Sync + 'static,
{ /* private fields */ }

Handler that executes two handlers in sequence

Trait Implementations

impl<DB, A, B, F> TransactionHandler<DB> for AndThenHandler<DB, A, B, F>

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

type Item = <B as TransactionHandler<DB>>::Item

The result type of this handler

type Error = <A as TransactionHandler<DB>>::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