Struct TestServer 

pub struct TestServer<H> { /* private fields */ }

A testing interface that wraps a trillium handler, providing a high-level API for making requests and asserting on responses.

This runs a full request-response cycle against an in-memory virtual transport using trillium-client. No ports are bound and the tests are fully parallelizable.

A fluent set of assertions are provided that chain off of a borrow.

use test_harness::test;
use trillium::{Conn, Status};
use trillium_testing::{TestResult, TestServer, harness};

#[test(harness)]
async fn basic_test() {
    let app = TestServer::new(|conn: Conn| async move { conn.ok("hello") }).await;

    app.get("/").await.assert_ok().assert_body("hello");

    // or if you prefer:

    let conn = app.post("/").with_body("body").await;
    conn.assert_ok();
    conn.assert_body("hello");
}

// also an option, but not preferred:

#[test]
fn sync_test() {
    let app = TestServer::new_blocking(|conn: Conn| async move { conn.ok("hello") });

    app.get("/").block().assert_ok().assert_body("hello");

    let conn = app.post("/").with_body("body").block();
    conn.assert_ok();
    conn.assert_body("hello");
}

Implementations

impl<H: Handler> TestServer<H>

pub async fn new(handler: H) -> Self

Creates a new TestServer.

Note that this is async because it initializes the handler with Handler::init.

pub fn new_blocking(handler: H) -> Self

construct a new TestServer and block on initialization

pub fn build<M: TryInto<Method>>(&self, method: M, path: &str) -> ConnTest

where M::Error: Debug,

Build a new ConnTest

pub fn shared_state<T: Send + Sync + 'static>(&self) -> Option<&T>

borrow from shared state configured by the handler

pub fn assert_shared_state<T>(&self, expected: T) -> &Self

where T: Send + Sync + Debug + PartialEq + 'static,

assert that a given type is in shared state

pub fn assert_shared_state_with<T, F>(&self, f: F) -> &Self

where T: Send + Sync + 'static, F: FnOnce(&T),

assert that a given type is in shared and make further assertions on it

pub fn handler(&self) -> &H

Borrow the handler

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

Add a default host/authority for this virtual server (eg pretend this server is running at example.com with .with_host("example.com")

pub fn set_host(&mut self, host: &str) -> &mut Self

Set the default host/authority for this virtual server (eg pretend this server is running at example.com with .set_host("example.com")

pub fn with_base(self, base: impl IntoUrl) -> Self

Set the url for this virtual server (eg pretend this server is running at https://example.com with .with_base("https://example.com")

pub fn set_base(&mut self, base: impl IntoUrl) -> &mut Self

Set the url for this virtual server (eg pretend this server is running at https://example.com with .set_base("https://example.com")

pub fn get(&self, path: &str) -> ConnTest

Builds a GET ConnTest for the given path.

pub fn post(&self, path: &str) -> ConnTest

Builds a POST ConnTest for the given path.

pub fn put(&self, path: &str) -> ConnTest

Builds a PUT ConnTest for the given path.

pub fn delete(&self, path: &str) -> ConnTest

Builds a DELETE ConnTest for the given path.

pub fn patch(&self, path: &str) -> ConnTest

Builds a PATCH ConnTest for the given path.

Trait Implementations

impl<H: Clone> Clone for TestServer<H>

fn clone(&self) -> TestServer<H>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H: Debug> Debug for TestServer<H>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.