mae 0.3.12

Opinionated async Rust framework for building Mae-Technologies micro-services — app scaffolding, repo layer, middleware, and test utilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! [`TestContext`] — a generic test context for Mae-based services.
//!
//! `TestContext<C>` wraps a service-specific custom context type `C` and
//! provides access to a shared Postgres pool.  Per-test isolation is achieved
//! via transaction rollback (`pool.begin()` + drop) rather than DDL-based
//! schema creation, which avoids requiring elevated database permissions.

use anyhow::Result;
use sqlx::PgPool;
use std::sync::Arc;

use crate::context::RequestContext;
use crate::session::Session;
use crate::testing::container::postgres;

/// Re-export the Postgres singleton helper.
pub use postgres::pg_singleton as pg_container;

/// Generic test context wrapping a service-specific type `C`.
#[derive(Clone)]
pub struct TestContext<C = ()> {
    /// Service-specific context, accessible from within tests.
    pub inner: C,
    /// Shared Postgres pool for this test run.
    pub pool: PgPool
}

impl<C: Default + Clone> TestContext<C> {
    /// Build a new [`TestContext`] backed by the shared Postgres pool.
    ///
    /// Per-test isolation is achieved via transaction rollback — call
    /// `pool.begin()` at the start of each test and let the transaction
    /// drop (auto-rollback) when the test finishes.
    pub async fn new() -> Result<Self> {
        let pool = postgres::shared_pool().await?.clone();
        Ok(Self { inner: C::default(), pool })
    }
}

/// Convenience type alias matching the downstream service pattern.
pub type Ctx<C> = RequestContext<TestContext<C>>;

/// Build a [`Ctx<C>`] backed by the shared Postgres pool.
pub async fn get_context<C: Default + Clone>() -> Result<RequestContext<TestContext<C>>> {
    let base_pool = postgres::shared_pool().await?.clone();
    let pool = Arc::new(base_pool.clone());
    let session = Arc::new(Session(Some(1)));
    let ctx = RequestContext::<TestContext<C>>::new(
        pool,
        session,
        Arc::new(TestContext { inner: C::default(), pool: base_pool })
    )
    .await?;

    Ok(ctx)
}