Struct DynamicStub 

pub struct DynamicStub {
    pub method: String,
    pub path: String,
    pub status: Arc<RwLock<u16>>,
    pub headers: Arc<RwLock<HashMap<String, String>>>,
    pub response_fn: DynamicResponseFn,
    pub latency_ms: Option<u64>,
}

Dynamic stub with runtime response generation

Fields

method: String

HTTP method

path: String

Path pattern

status: Arc<RwLock<u16>>

HTTP status code (can be dynamic)

headers: Arc<RwLock<HashMap<String, String>>>

Response headers (can be dynamic)

response_fn: DynamicResponseFn

Dynamic response function

latency_ms: Option<u64>

Optional latency in milliseconds

Implementations

impl DynamicStub

pub fn new<F>( method: impl Into<String>, path: impl Into<String>, response_fn: F, ) -> Self

where F: Fn(&RequestContext) -> Value + Send + Sync + 'static,

Create a new dynamic stub

pub async fn set_status(&self, status: u16)

Set the HTTP status code

pub async fn get_status(&self) -> u16

Get the current status code

pub async fn add_header(&self, key: String, value: String)

Add a response header

pub async fn remove_header(&self, key: &str)

Remove a response header

pub async fn get_headers(&self) -> HashMap<String, String>

Get all headers (returns a clone)

For more efficient read-only access, consider using with_headers() instead.

pub async fn with_headers<F, R>(&self, f: F) -> R

where F: FnOnce(&HashMap<String, String>) -> R,

Access headers without cloning via a callback

This is more efficient than get_headers() when you only need to read header values without modifying them.

Examples

let stub = DynamicStub::new("GET", "/test", |_| json!({}));
stub.add_header("X-Custom".to_string(), "value".to_string()).await;

// Efficient read-only access
let has_custom = stub.with_headers(|headers| {
    headers.contains_key("X-Custom")
}).await;

pub fn generate_response(&self, ctx: &RequestContext) -> Value

Generate a response for a given request context

pub fn with_latency(self, ms: u64) -> Self

Set latency