Struct gotham::tls::test::TestServer

pub struct TestServer { /* private fields */ }

The TestServer type, which is used as a harness when writing test cases for Hyper services (which Gotham’s Router is). An instance of TestServer is run asynchronously within the current thread, and is only accessible by a client returned from the TestServer.

Examples

use gotham::tls::test::TestServer;

let test_server = TestServer::new(|| Ok(my_handler)).unwrap();

let response = test_server.client().get("http://localhost/").perform().unwrap();
assert_eq!(response.status(), StatusCode::ACCEPTED);

Implementations

impl TestServer

pub fn new<NH: NewHandler + 'static>(new_handler: NH) -> Result<TestServer>

Creates a TestServer instance for the Handler spawned by new_handler. This server has the same guarantee given by hyper::server::Http::bind, that a new service will be spawned for each connection.

Timeout will be set to 10 seconds.

pub fn with_timeout<NH: NewHandler + 'static>( new_handler: NH, timeout: u64 ) -> Result<TestServer>

Sets the request timeout to timeout seconds and returns a new TestServer.

pub fn client(&self) -> TestClient<Self, TestConnect>

Returns a client connected to the TestServer. The transport is handled internally.

pub fn spawn<F>(&self, future: F)

where F: Future<Output = ()> + Send + 'static,

Spawns the given future on the TestServer’s internal runtime. This allows you to spawn more futures ontop of the TestServer in your tests.

Trait Implementations

impl Clone for TestServer

fn clone(&self) -> TestServer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Server for TestServer

fn run_future<F, O>(&self, future: F) -> O

where F: Future<Output = O>,

Runs a Future until it resolves.

fn request_expiry(&self) -> Sleep

Returns a Delay that will expire when a request should.

fn run_request<F>(&self, f: F) -> Result<F::Ok>

where F: TryFuture + Unpin + Send + 'static, F::Ok: Send, F::Error: Into<Error> + Send,

Runs the event loop until the response future is completed.