Struct TestClient 

pub struct TestClient<A>
where
    A: Application,
{ /* private fields */ }

An in-process HTTP test client that dispatches requests directly through an Application without opening a TCP socket.

Use this in unit and integration tests to exercise controllers and routing without starting the server.

Example

use rust_web_server::app::App;
use rust_web_server::core::New;
use rust_web_server::test_client::TestClient;

let client = TestClient::new(App::new());

let res = client.get("/healthz").send();
assert_eq!(200, res.status());

let res = client.post("/echo")
    .header("Content-Type", "text/plain")
    .body_text("hello")
    .send();
assert_eq!(200, res.status());

Implementations

impl<A> TestClient<A>

where A: Application,

pub fn new(app: A) -> TestClient<A>

Create a test client wrapping app. Requests are dispatched on a synthetic 127.0.0.1:12345 → 127.0.0.1:7878 connection.

pub fn get(&self, path: &str) -> TestRequest<'_, A>

Build a GET request to path.

pub fn post(&self, path: &str) -> TestRequest<'_, A>

Build a POST request to path.

pub fn put(&self, path: &str) -> TestRequest<'_, A>

Build a PUT request to path.

pub fn patch(&self, path: &str) -> TestRequest<'_, A>

Build a PATCH request to path.

pub fn delete(&self, path: &str) -> TestRequest<'_, A>

Build a DELETE request to path.

pub fn options(&self, path: &str) -> TestRequest<'_, A>

Build an OPTIONS request to path.

pub fn websocket(&self, path: &str) -> TestWebSocketRequest<'_, A>

Available on non-WebAssembly only.

Build a WebSocket upgrade request to path; call connect to run the route’s upgrade handler over an in-memory connection (no socket).

use rust_web_server::app::App;
use rust_web_server::test_client::TestClient;
use rust_web_server::websocket::{Message, WebSocket};

let app = App::with_state(()).get("/echo", |request, _params, _conn, _state| {
    WebSocket::upgrade(request, |mut ws| {
        while let Ok(Some(Message::Text(text))) = ws.recv() {
            let _ = ws.send_text(&text);
        }
    })
});
let client = TestClient::new(app);
let mut ws = client.websocket("/echo").connect().expect("a 101");
ws.send_text("hi");
assert_eq!("hi", ws.recv_text());
assert_eq!(Some(1000), ws.close(1000, "bye"));

pub fn app(&self) -> &A

The application under test.

Trait Implementations

impl<A> OpenApiSource for TestClient<A>

where A: Application,

fn openapi_json(&self) -> String

GET /openapi.json through the app — where AppWithState::openapi serves the document.