Struct TestApp 

pub struct TestApp { /* private fields */ }

Builder for constructing a fully-configured Autumn application in tests.

Analogous to Spring Boot’s @SpringBootTest – it wires up routes, middleware, config, and optionally a database pool, then produces a TestClient ready to fire requests.

Examples

use autumn_web::prelude::*;
use autumn_web::test::TestApp;

#[get("/ping")]
async fn ping() -> &'static str { "pong" }

#[tokio::test]
async fn ping_works() {
    let client = TestApp::new()
        .routes(routes![ping])
        .build();

    client.get("/ping").send().await.assert_ok();
}

Implementations

impl TestApp

pub fn new() -> Self

Create a new test app builder with default configuration.

pub fn policy<R, P>(self, policy: P) -> Self

where R: Send + Sync + 'static, P: Policy<R>,

Register a Policy for resource type R. Mirrors AppBuilder::policy.

pub fn scope<R, S>(self, scope: S) -> Self

where R: Send + Sync + 'static, S: Scope<R>,

Register a Scope for resource type R. Mirrors AppBuilder::scope.

pub const fn forbidden_response(self, value: ForbiddenResponse) -> Self

Override the deny-response shape used by #[authorize] and #[repository(policy = ...)] handlers. Useful for round-tripping the 403-vs-404 decision in tests.

pub fn openapi(self, config: OpenApiConfig) -> Self

Enable OpenAPI spec generation for the test app.

Mirrors crate::app::AppBuilder::openapi so integration tests can exercise the /v3/api-docs and /swagger-ui endpoints.

Gated behind the openapi Cargo feature.

pub fn merge(self, router: Router<AppState>) -> Self

Merge a router into the internal application state.

This is useful when testing modular route definitions without building the full application.

pub fn nest(self, path: &str, router: Router<AppState>) -> Self

Nest a router under a specific path prefix for testing.

This is useful for testing sub-applications or API versions.

pub fn layer<L: IntoAppLayer>(self, layer: L) -> Self

Apply a custom tower::Layer to the entire test application.

Mirrors crate::app::AppBuilder::layer so tests can exercise the exact middleware wiring that AppBuilder::run() produces.

pub const fn from_router(router: Router) -> TestClient

Construct a TestClient directly from an axum::Router.

Useful for bypassing TestApp builder if you just want to write requests against a standard axum Router.

pub fn routes(self, routes: Vec<Route>) -> Self

Register a collection of routes to be built into the TestApp.

pub fn config(self, config: AutumnConfig) -> Self

Override the default test configuration.

pub fn profile(self, profile: &str) -> Self

Set the active profile (default is "test").

pub fn with_db(self, pool: Pool<AsyncPgConnection>) -> Self

Attach a database connection pool to the test app.

pub fn build(self) -> TestClient

Build the application and return a TestClient ready for requests.

This constructs the full Axum router with all middleware applied, identical to what AppBuilder::run() produces – without binding a TCP listener.

The process-level global cache is cleared unconditionally so that #[cached] functions inside this test app always use their per-function Moka stores and do not accidentally inherit a Redis or other shared backend installed by a previous test.

Trait Implementations

impl Default for TestApp

fn default() -> Self

Returns the “default value” for a type.