Struct axum_test::TestServer

pub struct TestServer { /* private fields */ }

The TestServer runs your Axum application, allowing you to make HTTP requests against it.

You can make a request by calling TestServer::get(), TestServer::post(), TestServer::put(), TestServer::delete(), and TestServer::patch() methods. They will return a TestRequest for building the request.

use ::axum::Json;
use ::axum::routing::Router;
use ::axum::routing::get;
use ::serde::Deserialize;
use ::serde::Serialize;

use ::axum_test::TestServer;

let app = Router::new()
    .route(&"/todo", get(|| async { "hello!" }));

let server = TestServer::new(app)?;

// The different responses one can make:
let get_response = server.get(&"/todo").await;
let post_response = server.post(&"/todo").await;
let put_response = server.put(&"/todo").await;
let delete_response = server.delete(&"/todo").await;
let patch_response = server.patch(&"/todo").await;

Implementations

impl TestServer

pub fn new<A>(app: A) -> Result<Self>

where A: IntoTransportLayer,

This will run the given Axum app, allowing you to make requests against it.

This is the same as creating a new TestServer with a configuration, and passing TestServerConfig::default().

pub fn new_with_config<A>(app: A, config: TestServerConfig) -> Result<Self>

where A: IntoTransportLayer,

This very similar to TestServer::new(), however you can customise some of the configuration. This includes which port to run on, or default settings.

See the TestServerConfig for more information on each configuration setting.

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

Creates a HTTP GET request to the path.

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

Creates a HTTP POST request to the given path.

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

Creates a HTTP PATCH request to the path.

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

Creates a HTTP PUT request to the path.

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

Creates a HTTP DELETE request to the path.

pub fn method(&self, method: Method, path: &str) -> TestRequest

Creates a HTTP request, to the method and path provided.

pub fn server_address(&self) -> Option<Url>

Returns the local web address for the test server, if an address is available.

The address is available when running as a real web server, by setting the TestServerConfig transport field to Transport::HttpRandomPort or Transport::HttpIpPort.

This will return None when there is mock HTTP transport (the default).

pub fn add_cookie(&mut self, cookie: Cookie<'_>)

Adds a single cookie to be included on all future requests.

If a cookie with the same name already exists, then it will be replaced.

pub fn add_cookies(&mut self, cookies: CookieJar)

Adds extra cookies to be used on all future requests.

Any cookies which have the same name as the new cookies, will get replaced.

pub fn clear_cookies(&mut self)

Clears all of the cookies stored internally.

pub fn do_save_cookies(&mut self)

Requests made using this TestServer will save their cookies for future requests to send.

This behaviour is off by default.

pub fn do_not_save_cookies(&mut self)

Requests made using this TestServer will not save their cookies for future requests to send up.

This is the default behaviour.

pub fn expect_success(&mut self)

Requests made using this TestServer will assert a HTTP status in the 2xx range will be returned, unless marked otherwise.

By default this behaviour is off.

pub fn expect_failure(&mut self)

Requests made using this TestServer will assert a HTTP status is outside the 2xx range will be returned, unless marked otherwise.

By default this behaviour is off.

pub fn add_query_param<V>(&mut self, key: &str, value: V)

where V: Serialize,

Adds a query parameter to be sent on all future requests.

pub fn add_query_params<V>(&mut self, query_params: V)

where V: Serialize,

Adds query parameters to be sent on all future requests.

pub fn add_raw_query_param(&mut self, raw_query_param: &str)

Adds a raw query param, with no urlencoding of any kind, to be send on all future requests.

pub fn clear_query_params(&mut self)

Clears all query params set.

pub fn add_header<'c>(&mut self, name: HeaderName, value: HeaderValue)

Adds a header to be sent with all future requests built from this TestServer.

pub fn clear_headers(&mut self)

Clears all headers set so far.

pub fn scheme(&mut self, scheme: &str)

Sets the scheme to use when making all requests from the TestServer. i.e. http or https.

The default scheme is ‘http’.

use ::axum::Router;
use ::axum_test::TestServer;

let app = Router::new();
let mut server = TestServer::new(app)?;
server
    .scheme(&"https");

let response = server
    .get(&"/my-end-point")
    .await;

Trait Implementations

impl Debug for TestServer

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

Formats the value using the given formatter.