Struct ResponseSnapshot 

pub struct ResponseSnapshot {
    pub status: u16,
    pub headers: Vec<(String, String)>,
    pub body: String,
    pub body_json: Option<Value>,
}

A serializable snapshot of an HTTP response for fixture-based testing.

Snapshots capture status code, selected headers, and body content, enabling API contract verification by comparing responses against stored fixtures.

Usage

let response = client.get("/api/users").send();
let snapshot = ResponseSnapshot::from_test_response(&response);

// First run: save the snapshot
snapshot.save("tests/snapshots/get_users.json").unwrap();

// Subsequent runs: compare against saved snapshot
let expected = ResponseSnapshot::load("tests/snapshots/get_users.json").unwrap();
assert_eq!(snapshot, expected, "{}", snapshot.diff(&expected));

Fields

status: u16

HTTP status code.

headers: Vec<(String, String)>

Selected response headers (name, value) — sorted for determinism.

body: String

Response body as a string.

body_json: Option<Value>

If the body is valid JSON, the parsed value for structural comparison.

Implementations

impl ResponseSnapshot

pub fn from_test_response(resp: &TestResponse) -> Self

Create a snapshot from a TestResponse.

Captures the status code, all response headers, and body text. If the body is valid JSON, it’s also parsed for structural comparison.

pub fn from_test_response_with_headers( resp: &TestResponse, header_names: &[&str], ) -> Self

Create a snapshot with only specific headers (for ignoring dynamic headers).

pub fn mask_fields(self, paths: &[&str], placeholder: &str) -> Self

Mask dynamic fields in the JSON body (replace with a placeholder).

This is useful for fields like timestamps, UUIDs, or auto-increment IDs that change between test runs.

paths are dot-separated JSON paths, e.g. ["id", "created_at", "items.0.id"].

pub fn save(&self, path: impl AsRef<Path>) -> Result<()>

Save the snapshot to a JSON file.

pub fn load(path: impl AsRef<Path>) -> Result<Self>

Load a snapshot from a JSON file.

pub fn diff(&self, other: &Self) -> String

Compare two snapshots and return a human-readable diff.

pub fn matches_ignoring_headers(&self, other: &Self, ignore: &[&str]) -> bool

Check if two snapshots match, optionally ignoring specific headers.

Trait Implementations

impl Clone for ResponseSnapshot

fn clone(&self) -> ResponseSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResponseSnapshot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResponseSnapshot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ResponseSnapshot

fn eq(&self, other: &ResponseSnapshot) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ResponseSnapshot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ResponseSnapshot