Struct DatabaseTransactionHandler

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

Handler that combines a database instance with transaction management

Trait Implementations

impl<DB, F, Fut> IntoTransactionHandler<DB> for DatabaseTransactionHandler<DB, F>

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

type Handler = DatabaseTransactionHandler<DB, F>

The handler type

type Item = TestContext<DB>

The result type

type Error = <DB as DatabaseBackend>::Error

The error type

fn into_transaction_handler(self) -> Self::Handler

Convert this type into a transaction handler

impl<DB, F, Fut> TransactionHandler<DB> for DatabaseTransactionHandler<DB, F>

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