Struct IntegrationTestBuilder 

pub struct IntegrationTestBuilder { /* private fields */ }

Integration test builder

Implementations

impl IntegrationTestBuilder

pub fn new(name: impl Into<String>) -> Self

Create new integration test builder

pub fn before_each<F, Fut>(self, f: F) -> Self

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Add before_each hook

pub fn after_each<F, Fut>(self, f: F) -> Self

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Add after_each hook

pub async fn run_test<F, Fut, T>(&self, body: F) -> T

where F: FnOnce() -> Fut, Fut: Future<Output = T>,

Run body with the collected hooks around it: every before_each hook is awaited (in registration order), then body, then every after_each hook (in registration order). after_each hooks run whenever body returns normally; if body panics, the panic unwinds through this function and after_each hooks do not run (matching TestFixture::run_test’s non-catching behavior).

Examples

use armature_testing::integration::IntegrationTestBuilder;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

let order = Arc::new(AtomicUsize::new(0));
let before_slot = order.clone();
let after_slot = order.clone();

let builder = IntegrationTestBuilder::new("example")
    .before_each(move || {
        let before_slot = before_slot.clone();
        async move { before_slot.store(1, Ordering::SeqCst); }
    })
    .after_each(move || {
        let after_slot = after_slot.clone();
        async move { after_slot.store(3, Ordering::SeqCst); }
    });

let seen_during_body = builder
    .run_test(|| async { order.load(Ordering::SeqCst) })
    .await;

assert_eq!(seen_during_body, 1); // before_each already ran
assert_eq!(order.load(Ordering::SeqCst), 3); // after_each ran too