Struct APIClient 

pub struct APIClient { /* private fields */ }

Test client for making API requests

Example

use reinhardt_testkit::APIClient;
use http::StatusCode;
use serde_json::json;

let client = APIClient::with_base_url("http://localhost:8080");
let credentials = json!({"username": "user", "password": "pass"});
client.post("/auth/login", &credentials, "json").await?;
let response = client.get("/api/users/").await?;
assert_eq!(response.status(), StatusCode::OK);

Implementations

impl APIClient

pub fn new() -> Self

Create a new API client

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();
assert_eq!(client.base_url(), "http://testserver");

pub fn with_base_url(base_url: impl Into<String>) -> Self

Create a client with a custom base URL

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::with_base_url("https://api.example.com");
assert_eq!(client.base_url(), "https://api.example.com");

pub fn from_handler(handler: impl HttpHandler + 'static) -> Self

Create a test client that dispatches requests directly to a reinhardt Handler without TCP.

The Handler runs the full middleware stack in-process. Sets base_url to "http://testserver" and injects a default Origin header for OriginGuardMiddleware compatibility.

Panics

Panics if called outside a tokio runtime.

Examples

use reinhardt_testkit::APIClient;

// let router = build_routes(scope).into_server();
// let client = APIClient::from_handler(router);
// let resp = client.get("/api/health/").await.unwrap();

pub fn builder() -> APIClientBuilder

Create a builder for customizing the client configuration

Examples

use reinhardt_testkit::client::APIClient;
use std::time::Duration;

let client = APIClient::builder()
    .base_url("http://localhost:8080")
    .timeout(Duration::from_secs(30))
    .build();

pub fn base_url(&self) -> &str

Get the base URL of this client.

pub fn set_handler<F>(&mut self, handler: F)

where F: Fn(Request<Full<Bytes>>) -> Response<Full<Bytes>> + Send + Sync + 'static,

Set a request handler for testing

Examples

use reinhardt_testkit::client::APIClient;
use http::{Request, Response, StatusCode};
use http_body_util::Full;
use bytes::Bytes;

let mut client = APIClient::new();
client.set_handler(|_req| {
    Response::builder()
        .status(StatusCode::OK)
        .body(Full::new(Bytes::from("test")))
        .unwrap()
});

pub async fn set_header( &self, name: impl AsRef<str>, value: impl AsRef<str>, ) -> ClientResult<()>

Set a default header for all requests

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();
client.set_header("User-Agent", "TestClient/1.0").await.unwrap();

pub async fn force_authenticate(&self, user: Option<Value>)

👎Deprecated since 0.1.0-rc.16:

use client.auth().session() or client.auth().jwt() instead

Force authenticate as a user (for testing)

Examples

use reinhardt_testkit::client::APIClient;
use serde_json::json;

let client = APIClient::new();
let user = json!({"id": 1, "username": "testuser"});
client.force_authenticate(Some(user)).await;

pub async fn credentials( &self, username: &str, password: &str, ) -> ClientResult<()>

Set credentials for Basic Authentication

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();
client.credentials("username", "password").await.unwrap();

pub async fn clear_auth(&self) -> ClientResult<()>

Clear authentication and cookies

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();
client.clear_auth().await.unwrap();

pub async fn set_cookie(&self, name: &str, value: &str) -> ClientResult<()>

Set a cookie that will be sent with subsequent requests.

Panics

Panics if name contains = or ;, or if value contains ;.

pub async fn remove_cookie(&self, name: &str) -> ClientResult<()>

Remove a specific cookie.

pub async fn logout(&self) -> ClientResult<()>

Clear all authentication state (session cookies, auth headers, stored user).

This is the replacement for force_authenticate(None).

pub fn auth(&self) -> AuthBuilder<'_>

Start building an auth configuration for this client.

Examples

client.auth()
    .session(&user, &session_store)
    .with_staff(true)
    .apply().await?;

pub async fn cleanup(&self)

Clean up all client state for teardown

This method performs a complete cleanup of the client state including:

• Clearing authentication
• Clearing cookies
• Clearing default headers

This is typically called during test teardown to ensure clean state between tests.

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();
client.set_header("X-Custom", "value").await.unwrap();
client.cleanup().await;
// All state is now cleared

pub async fn get(&self, path: &str) -> ClientResult<TestResponse>

Make a GET request

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();

pub async fn post<T: Serialize>( &self, path: &str, data: &T, format: &str, ) -> ClientResult<TestResponse>

Make a POST request

Examples

use reinhardt_testkit::client::APIClient;
use serde_json::json;

let client = APIClient::new();
let data = json!({"name": "test"});

pub async fn put<T: Serialize>( &self, path: &str, data: &T, format: &str, ) -> ClientResult<TestResponse>

Make a PUT request

Examples

use reinhardt_testkit::client::APIClient;
use serde_json::json;

let client = APIClient::new();
let data = json!({"name": "updated"});

pub async fn patch<T: Serialize>( &self, path: &str, data: &T, format: &str, ) -> ClientResult<TestResponse>

Make a PATCH request

Examples

use reinhardt_testkit::client::APIClient;
use serde_json::json;

let client = APIClient::new();
let data = json!({"name": "partial_update"});

pub async fn delete(&self, path: &str) -> ClientResult<TestResponse>

Make a DELETE request

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();

pub async fn head(&self, path: &str) -> ClientResult<TestResponse>

Make a HEAD request

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();

pub async fn options(&self, path: &str) -> ClientResult<TestResponse>

Make an OPTIONS request

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::new();

pub async fn get_with_headers( &self, path: &str, headers: &[(&str, &str)], ) -> ClientResult<TestResponse>

Make a GET request with additional per-request headers

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::with_base_url("http://localhost:8080");
// let response = client.get_with_headers("/api/data", &[("Accept", "application/json")]).await;

pub async fn post_raw_with_headers( &self, path: &str, body: &[u8], content_type: &str, headers: &[(&str, &str)], ) -> ClientResult<TestResponse>

Make a POST request with raw body and additional per-request headers

Unlike post(), this method allows setting a raw body without automatic serialization.

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::with_base_url("http://localhost:8080");
// let response = client.post_raw_with_headers(
//     "/api/echo",
//     b"{\"test\":\"data\"}",
//     "application/json",
//     &[("X-Custom-Header", "value")]
// ).await;

pub async fn post_raw( &self, path: &str, body: &[u8], content_type: &str, ) -> ClientResult<TestResponse>

Make a POST request with raw body

Unlike post(), this method allows setting a raw body without automatic serialization.

Examples

use reinhardt_testkit::client::APIClient;

let client = APIClient::with_base_url("http://localhost:8080");
// let response = client.post_raw("/api/echo", b"{\"test\":\"data\"}", "application/json").await;

Trait Implementations

impl Default for APIClient

fn default() -> Self

Returns the “default value” for a type.