Struct MockServer 

pub struct MockServer { /* private fields */ }

Represents a mock server designed to simulate HTTP server behaviors for testing purposes. This server intercepts HTTP requests and can be configured to return predetermined responses. It is used extensively in automated tests to validate client behavior without the need for a live server, ensuring that applications behave as expected in controlled environments.

The mock server allows developers to:

• Specify expected HTTP requests using a variety of matching criteria such as path, method, headers, and body content.
• Define corresponding HTTP responses including status codes, headers, and body data.
• Monitor and verify that the expected requests are made by the client under test.
• Simulate various network conditions and server responses, including errors and latencies.

Implementations

impl MockServer

pub async fn connect_async(address: &str) -> Self

Asynchronously connects to a remote mock server running in standalone mode.

Arguments

• address - A string slice representing the address in the format “:”, e.g., “127.0.0.1:8080”.

Returns

An instance of Self representing the connected mock server.

Panics

This method will panic if the address cannot be parsed, resolved to an IPv4 address, or if the mock server is unreachable.

Note

This method requires the remote feature to be enabled.

pub fn connect(address: &str) -> Self

Synchronously connects to a remote mock server running in standalone mode.

Arguments

• address - A string slice representing the address in the format “:”, e.g., “127.0.0.1:8080”.

Returns

An instance of Self representing the connected mock server.

Panics

This method will panic if the address cannot be parsed, resolved to an IPv4 address, or if the mock server is unreachable.

Note

This method requires the remote feature to be enabled.

pub async fn connect_from_env_async() -> Self

Asynchronously connects to a remote mock server running in standalone mode using connection parameters stored in the HTTPMOCK_HOST and HTTPMOCK_PORT environment variables.

Returns

An instance of Self representing the connected mock server.

Panics

This method will panic if the HTTPMOCK_PORT environment variable cannot be parsed to an integer or if the connection fails.

Note

This method requires the remote feature to be enabled.

Environment Variables

• HTTPMOCK_HOST - The hostname or IP address of the mock server (default: “127.0.0.1”).
• HTTPMOCK_PORT - The port number of the mock server (default: “5050”).

pub fn connect_from_env() -> Self

Synchronously connects to a remote mock server running in standalone mode using connection parameters stored in the HTTPMOCK_HOST and HTTPMOCK_PORT environment variables.

Returns

An instance of Self representing the connected mock server.

Panics

This method will panic if the HTTPMOCK_PORT environment variable cannot be parsed to an integer or if the connection fails.

Note

This method requires the remote feature to be enabled.

pub async fn start_async() -> Self

Starts a new MockServer asynchronously.

Attention

This library manages a pool of MockServer instances in the background. Instead of always starting a new mock server, a MockServer instance is only created on demand if there is no free MockServer instance in the pool and the pool has not reached its maximum size yet. Otherwise, THIS METHOD WILL BLOCK the executing function until a free mock server is available.

This approach allows running many tests in parallel without exhausting the executing machine by creating too many mock servers.

A MockServer instance is automatically taken from the pool whenever this method is called. The instance is put back into the pool automatically when the corresponding MockServer variable goes out of scope.

Returns

An instance of Self representing the started mock server.

pub fn start() -> MockServer

Starts a new MockServer synchronously.

Attention: This library manages a pool of MockServer instances in the background. Instead of always starting a new mock server, a MockServer instance is only created on demand if there is no free MockServer instance in the pool and the pool has not reached a maximum size yet. Otherwise, THIS METHOD WILL BLOCK the executing function until a free mock server is available.

This allows to run many tests in parallel, but will prevent exhaust the executing machine by creating too many mock servers.

A MockServer instance is automatically taken from the pool whenever this method is called. The instance is put back into the pool automatically when the corresponding ‘MockServer’ variable gets out of scope.

pub fn host(&self) -> String

Returns the hostname of the MockServer.

By default, this is 127.0.0.1. In standalone mode, the hostname will be the host where the standalone mock server is running.

Returns

A String representing the hostname of the MockServer.

Example

use httpmock::MockServer;

let server = MockServer::start();
let host = server.host();

assert_eq!(host, "127.0.0.1");

pub fn port(&self) -> u16

Returns the TCP port that the mock server is listening on.

Returns

A u16 representing the port number of the MockServer.

Example

use httpmock::MockServer;

let server = MockServer::start();
let port = server.port();

assert!(port > 0);

pub fn address(&self) -> &SocketAddr

Builds the address for a specific path on the mock server.

Returns

A reference to the SocketAddr representing the address of the MockServer.

Example

// Start a local mock server for exclusive use by this test function.
let server = httpmock::MockServer::start();

let expected_addr_str = format!("127.0.0.1:{}", server.port());

// Get the address of the MockServer.
let addr = server.address();

// Ensure the returned URL is as expected.
assert_eq!(expected_addr_str, addr.to_string());

pub fn url<S: Into<String>>(&self, path: S) -> String

Builds the URL for a specific path on the mock server.

Arguments

• path - A string slice representing the specific path on the mock server.

Returns

A String representing the full URL for the given path on the MockServer.

Example

// Start a local mock server for exclusive use by this test function.
let server = httpmock::MockServer::start();

let expected_url = format!("https://127.0.0.1:{}/hello", server.port());

// Get the URL for path "/hello".
let url = server.url("/hello");

// Ensure the returned URL is as expected.
assert_eq!(expected_url, url);

pub fn base_url(&self) -> String

Builds the base URL for the mock server.

Returns

A String representing the base URL of the MockServer.

Example

use httpmock::MockServer;

// Start a local mock server for exclusive use by this test function.
let server = httpmock::MockServer::start();

// If the "https" feature is enabled, `server.base_url` below will generate a URL
// using the "https" scheme (e.g., https://127.0.0.1:34567). Otherwise, it will
// use "http" (e.g., http://127.0.0.1:34567).
let expected_scheme = if cfg!(feature = "https") { "https" } else { "http" };

let expected_url = format!("{}://127.0.0.1:{}", expected_scheme, server.port());

// Get the base URL of the MockServer.
let base_url = server.base_url();

// Ensure the returned URL is as expected.
assert_eq!(expected_url, base_url);

pub fn mock<F>(&self, config_fn: F) -> Mock<'_>

where F: FnOnce(When, Then),

Creates a Mock object on the mock server.

Arguments

• config_fn - A closure that takes a When and Then to configure the mock.

Returns

A Mock object representing the created mock on the server.

Example

use reqwest::blocking::get;
use httpmock::MockServer;

// Start a local mock server for exclusive use by this test function.
let server = MockServer::start();

// Create a mock on the server.
let mock = server.mock(|when, then| {
    when.path("/hello");
    then.status(200);
});

// Send an HTTP request to the mock server. This simulates your code.
get(&server.url("/hello")).unwrap();

// Ensure the mock was called as expected.
mock.assert();

pub async fn mock_async<'a, SpecFn>(&'a self, spec_fn: SpecFn) -> Mock<'a>

where SpecFn: FnOnce(When, Then),

Creates a Mock object on the mock server asynchronously.

Arguments

• spec_fn - A closure that takes a When and Then to configure the mock.

Returns

A Mock object representing the created mock on the server.

Example

use reqwest::get;
use httpmock::MockServer;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    let server = MockServer::start();

    let mock = server
        .mock_async(|when, then| {
            when.path("/hello");
            then.status(200);
        })
        .await;

    get(&server.url("/hello")).await.unwrap();

    mock.assert_async().await;
});

pub fn reset(&self)

Resets the mock server. More specifically, it deletes all Mock objects from the mock server and clears its request history.

Example

use reqwest::blocking::get;
use httpmock::MockServer;

let server = MockServer::start();

let mock = server.mock(|when, then| {
    when.path("/hello");
    then.status(200);
});

let response = get(&server.url("/hello")).unwrap();
assert_eq!(response.status(), 200);

server.reset();

let response = get(&server.url("/hello")).unwrap();
assert_eq!(response.status(), 404);

pub async fn reset_async(&self)

Resets the mock server. More specifically, it deletes all Mock objects from the mock server and clears its request history.

Example

use reqwest::get;
use httpmock::MockServer;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    let server = MockServer::start_async().await;

    let mock = server.mock_async(|when, then| {
        when.path("/hello");
        then.status(200);
    }).await;

    let response = get(&server.url("/hello")).await.unwrap();
    assert_eq!(response.status(), 200);

    server.reset_async().await;

    let response = get(&server.url("/hello")).await.unwrap();
    assert_eq!(response.status(), 404);
});

pub fn forward_to<IntoString, ForwardingRuleBuilderFn>( &self, to_base_url: IntoString, rule: ForwardingRuleBuilderFn, ) -> ForwardingRule<'_>

where ForwardingRuleBuilderFn: FnOnce(ForwardingRuleBuilder), IntoString: Into<String>,

Configures the mock server to forward the request to the target host by replacing the host name, but only if the request expectations are met. If the request is recorded, the recording will NOT contain the host name as an expectation to allow the recording to be reused.

Arguments

• to_base_url - A string that represents the base URL to which the request should be forwarded.
• rule - A closure that takes a ForwardingRuleBuilder to configure the forwarding rule.

Returns

A ForwardingRule object representing the configured forwarding rule.

Example

use httpmock::prelude::*;
use reqwest::blocking::Client;

// We will create this mock server to simulate a real service (e.g., GitHub, AWS, etc.).
let target_server = MockServer::start();
target_server.mock(|when, then| {
    when.any_request();
    then.status(200).body("Hi from fake GitHub!");
});

// Let's create our mock server for the test
let server = MockServer::start();

// We configure our server to forward the request to the target host instead of
// answering with a mocked response. The 'rule' variable lets you configure
// rules under which forwarding should take place.
server.forward_to(target_server.base_url(), |rule| {
    rule.filter(|when| {
        when.any_request(); // We want all requests to be forwarded.
    });
});

// Now let's send an HTTP request to the mock server. The request will be forwarded
// to the target host, as we configured before.
let client = Client::new();

// Since the request was forwarded, we should see the target host's response.
let response = client.get(&server.url("/get")).send().unwrap();
let status = response.status();

assert_eq!("Hi from fake GitHub!", response.text().unwrap());
assert_eq!(status, 200);

Feature

This method is only available when the proxy feature is enabled.

pub async fn forward_to_async<'a, IntoString, ForwardingRuleBuilderFn>( &'a self, target_base_url: IntoString, rule: ForwardingRuleBuilderFn, ) -> ForwardingRule<'a>

where ForwardingRuleBuilderFn: FnOnce(ForwardingRuleBuilder), IntoString: Into<String>,

Asynchronously configures the mock server to forward the request to the target host by replacing the host name, but only if the request expectations are met. If the request is recorded, the recording will contain the host name as an expectation to allow the recording to be reused.

Arguments

• target_base_url - A string that represents the base URL to which the request should be forwarded.
• rule - A closure that takes a ForwardingRuleBuilder to configure the forwarding rule.

Returns

A ForwardingRule object representing the configured forwarding rule.

Example

use httpmock::prelude::*;
use reqwest::Client;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    // We will create this mock server to simulate a real service (e.g., GitHub, AWS, etc.).
    let target_server = MockServer::start_async().await;
    target_server.mock_async(|when, then| {
        when.any_request();
        then.status(200).body("Hi from fake GitHub!");
    }).await;

    // Let's create our mock server for the test
    let server = MockServer::start_async().await;

    // We configure our server to forward the request to the target host instead of
    // answering with a mocked response. The 'rule' variable lets you configure
    // rules under which forwarding should take place.
    server.forward_to_async(target_server.base_url(), |rule| {
        rule.filter(|when| {
            when.any_request(); // We want all requests to be forwarded.
        });
    }).await;

    // Now let's send an HTTP request to the mock server. The request will be forwarded
    // to the target host, as we configured before.
    let client = Client::new();

    // Since the request was forwarded, we should see the target host's response.
    let response = client.get(&server.url("/get")).send().await.unwrap();
    let status = response.status();
    assert_eq!(status, 200);
    assert_eq!("Hi from fake GitHub!", response.text().await.unwrap());
});

Feature

This method is only available when the proxy feature is enabled.

pub fn proxy<ProxyRuleBuilderFn>( &self, rule: ProxyRuleBuilderFn, ) -> ProxyRule<'_>

where ProxyRuleBuilderFn: FnOnce(ProxyRuleBuilder),

Configures the mock server to proxy HTTP requests based on specified criteria.

This method configures the mock server to forward incoming requests to the target host when the requests meet the defined criteria. If a request matches the criteria, it will be proxied to the target host.

When a recording is active (which records requests and responses), the host name of the request will be stored with the recording as a request expectation.

Arguments

• rule - A closure that takes a ProxyRuleBuilder to configure the proxy rule.

Returns

A ProxyRule object representing the configured proxy rule that is stored on the mock server.

Example

use httpmock::prelude::*;
use reqwest::blocking::Client;

// Create a mock server to simulate a real service (e.g., GitHub, AWS, etc.).
let target_server = MockServer::start();
target_server.mock(|when, then| {
    when.any_request();
    then.status(200).body("Hi from fake GitHub!");
});

// Create a proxy mock server for the test.
let proxy_server = MockServer::start();

// Configure the proxy server to forward requests to the target server.
// The `rule` closure allows specifying criteria for requests that should be proxied.
proxy_server.proxy(|rule| {
    rule.filter(|when| {
        // Only allow requests to the target server to be proxied.
        when.host(target_server.host()).port(target_server.port());
    });
});

// Create an HTTP client configured to use the proxy server.
let client = Client::builder()
    .proxy(reqwest::Proxy::all(proxy_server.base_url()).unwrap()) // Set the proxy server
    .build()
    .unwrap();

// Send a request to the target server through the proxy server.
// The request will be forwarded to the target server as configured.
let response = client.get(&target_server.url("/get")).send().unwrap();
let status = response.status();

// Verify that the response comes from the target server.
assert_eq!(status, 200);
assert_eq!("Hi from fake GitHub!", response.text().unwrap());

Feature

This method is only available when the proxy feature is enabled.

pub async fn proxy_async<'a, ProxyRuleBuilderFn>( &'a self, rule: ProxyRuleBuilderFn, ) -> ProxyRule<'a>

where ProxyRuleBuilderFn: FnOnce(ProxyRuleBuilder),

Asynchronously configures the mock server to proxy HTTP requests based on specified criteria.

This method configures the mock server to forward incoming requests to the target host when the requests meet the defined criteria. If a request matches the criteria, it will be proxied to the target host.

When a recording is active (which records requests and responses), the host name of the request will be stored with the recording to allow the recording to be reused.

Arguments

• rule - A closure that takes a ProxyRuleBuilder to configure the proxy rule.

Returns

A ProxyRule object representing the configured proxy rule.

Example

use httpmock::prelude::*;
use reqwest::Client;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    // We will create this mock server to simulate a real service (e.g., GitHub, AWS, etc.).
    let target_server = MockServer::start_async().await;
    target_server.mock_async(|when, then| {
        when.any_request();
        then.status(200).body("Hi from fake GitHub!");
    }).await;

    // Let's create our proxy mock server for the test
    let proxy_server = MockServer::start_async().await;

    // We configure our proxy server to forward requests to the target server
    // The 'rule' closure allows specifying criteria for requests that should be proxied
    proxy_server.proxy_async(|rule| {
        rule.filter(|when| {
            // Only allow requests to the target server to be proxied
            when.host(target_server.host()).port(target_server.port());
        });
    }).await;

    // Create an HTTP client configured to use the proxy server
    let client = Client::builder()
        .proxy(reqwest::Proxy::all(proxy_server.base_url()).unwrap())
        .build()
        .unwrap();

    // Send a request to the target server through the proxy server
    // The request will be forwarded to the target server as configured
    let response = client.get(&target_server.url("/get")).send().await.unwrap();
    let status = response.status();

    // Verify that the response comes from the target server
    assert_eq!(status, 200);
    assert_eq!("Hi from fake GitHub!", response.text().await.unwrap());
});

Feature

This method is only available when the proxy feature is enabled.

pub fn record<RecordingRuleBuilderFn>( &self, rule: RecordingRuleBuilderFn, ) -> Recording<'_>

where RecordingRuleBuilderFn: FnOnce(RecordingRuleBuilder),

Records all requests matching a given rule and the corresponding responses sent back by the mock server. If requests are forwarded or proxied to another host, the original responses from those target hosts will also be recorded.

Parameters

• rule: A closure that takes a RecordingRuleBuilder as an argument, which defines the conditions under which HTTP requests and their corresponding responses will be recorded.

Returns

• Recording: A reference to the recording object stored on the mock server, which can be used to manage the recording, such as downloading or deleting it. The Recording object provides functionality to download the recording and store it under a file. Users can use these files for later playback by calling the playback method of the mock server.

Example

// Create a mock server to simulate a real service (e.g., GitHub, AWS, etc.).
use reqwest::blocking::Client;
use httpmock::MockServer;

let target_server = MockServer::start();
target_server.mock(|when, then| {
    when.any_request();
    then.status(200).body("Hi from fake GitHub!");
});

// Create the recording server for the test.
let recording_server = MockServer::start();

// Configure the recording server to forward requests to the target host.
recording_server.forward_to(target_server.base_url(), |rule| {
    rule.filter(|when| {
        when.path("/hello"); // Forward all requests with path "/hello".
    });
});

// Record the target server's response.
let recording = recording_server.record(|rule| {
    rule.record_response_delays(true)
        .record_request_headers(vec!["Accept", "Content-Type"]) // Record specific headers.
        .filter(|when| {
            when.path("/hello"); // Only record requests with path "/hello".
        });
});

// Use httpmock as a proxy server.
let github_client = Client::new();

let response = github_client
    .get(&format!("{}/hello", recording_server.base_url()))
    .send()
    .unwrap();
assert_eq!(response.text().unwrap(), "Hi from fake GitHub!");

// Store the recording to a file and create a new mock server to playback the recording.
let target_path = recording.save("my_test_scenario").unwrap();

let playback_server = MockServer::start();

playback_server.playback(target_path);

let response = github_client
    .get(&format!("{}/hello", playback_server.base_url()))
    .send()
    .unwrap();
assert_eq!(response.text().unwrap(), "Hi from fake GitHub!");

Feature

This method is only available when the record feature is enabled.

pub async fn record_async<'a, RecordingRuleBuilderFn>( &'a self, rule: RecordingRuleBuilderFn, ) -> Recording<'a>

where RecordingRuleBuilderFn: FnOnce(RecordingRuleBuilder),

Asynchronously records all requests matching a given rule and the corresponding responses sent back by the mock server. If requests are forwarded or proxied to another host, the original responses from those target hosts will also be recorded.

Parameters

• rule: A closure that takes a RecordingRuleBuilder as an argument, which defines the conditions under which requests will be recorded.

Returns

• Recording: A reference to the recording object stored on the mock server, which can be used to manage the recording, such as downloading or deleting it. The Recording object provides functionality to download the recording and store it under a file. Users can use these files for later playback by calling the playback method of the mock server.

Example

use httpmock::MockServer;
use reqwest::Client;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    // Create a mock server to simulate a real service (e.g., GitHub, AWS, etc.).
    let target_server = MockServer::start_async().await;
    target_server.mock_async(|when, then| {
        when.any_request();
        then.status(200).body("Hi from fake GitHub!");
    }).await;

    // Create the recording server for the test.
    let recording_server = MockServer::start_async().await;

    // Configure the recording server to forward requests to the target host.
    recording_server.forward_to_async(target_server.base_url(), |rule| {
        rule.filter(|when| {
            when.path("/hello"); // Forward all requests with path "/hello".
        });
    }).await;

    // Record the target server's response.
    let recording = recording_server.record_async(|rule| {
        rule.record_response_delays(true)
            .record_request_headers(vec!["Accept", "Content-Type"]) // Record specific headers.
            .filter(|when| {
                when.path("/hello"); // Only record requests with path "/hello".
            });
    }).await;

    // Use httpmock as a proxy server.
    let client = Client::new();

    let response = client
        .get(&format!("{}/hello", recording_server.base_url()))
        .send()
        .await
        .unwrap();
    assert_eq!(response.text().await.unwrap(), "Hi from fake GitHub!");

    // Store the recording to a file and create a new mock server to playback the recording.
    let target_path = recording.save_async("my_test_scenario").await.unwrap();

    let playback_server = MockServer::start_async().await;

    playback_server.playback_async(target_path).await;

    let response = client
        .get(&format!("{}/hello", playback_server.base_url()))
        .send()
        .await
        .unwrap();
    assert_eq!(response.text().await.unwrap(), "Hi from fake GitHub!");
});

Feature

This method is only available when the record feature is enabled.

pub fn playback<IntoPathBuf: Into<PathBuf>>( &self, path: IntoPathBuf, ) -> MockSet<'_>

Reads a recording file and configures the mock server to respond with the recorded responses when an incoming request matches the corresponding recorded HTTP request. This allows users to record responses from a real service and use these recordings for testing later, without needing to be online or having access to the real service during subsequent tests.

Parameters

• path: A path to the file containing the recording. This can be any type that implements Into<PathBuf>, such as a &str or String.

Returns

• MockSet: An object representing the set of mocks that were loaded from the recording file.

Example

// Create a mock server to simulate a real service (e.g., GitHub, AWS, etc.).
use reqwest::blocking::Client;
use httpmock::MockServer;

let target_server = MockServer::start();
target_server.mock(|when, then| {
    when.any_request();
    then.status(200).body("Hi from fake GitHub!");
});

// Create the recording server for the test.
let recording_server = MockServer::start();

// Configure the recording server to forward requests to the target host.
recording_server.forward_to(target_server.base_url(), |rule| {
    rule.filter(|when| {
        when.path("/hello"); // Forward all requests with path "/hello".
    });
});

// Record the target server's response.
let recording = recording_server.record(|rule| {
    rule.record_response_delays(true)
        .record_request_headers(vec!["Accept", "Content-Type"]) // Record specific headers.
        .filter(|when| {
            when.path("/hello"); // Only record requests with path "/hello".
        });
});

// Use httpmock as a proxy server.
let client = Client::new();

let response = client
    .get(&format!("{}/hello", recording_server.base_url()))
    .send()
    .unwrap();
assert_eq!(response.text().unwrap(), "Hi from fake GitHub!");

// Store the recording to a file and create a new mock server to play back the recording.
let target_path = recording.save("my_test_scenario").unwrap();

let playback_server = MockServer::start();

// Play back the recorded interactions from the file.
playback_server.playback(target_path);

let response = client
    .get(&format!("{}/hello", playback_server.base_url()))
    .send()
    .unwrap();
assert_eq!(response.text().unwrap(), "Hi from fake GitHub!");

Feature

This method is only available when the record feature is enabled.

pub async fn playback_async<IntoPathBuf: Into<PathBuf>>( &self, path: IntoPathBuf, ) -> MockSet<'_>

Asynchronously reads a recording file and configures the mock server to respond with the recorded responses when an incoming request matches the corresponding recorded HTTP request. This allows users to record responses from a real service and use these recordings for testing later, without needing to be online or having access to the real service during subsequent tests.

Parameters

• path: A path to the file containing the recorded interactions. This can be any type that implements Into<PathBuf>, such as a &str or String.

Returns

• MockSet: An object representing the set of mocks that were loaded from the recording file.

Example

use httpmock::MockServer;
use reqwest::Client;

let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
    // Create a mock server to simulate a real service (e.g., GitHub, AWS, etc.).
    let target_server = MockServer::start_async().await;
    target_server.mock_async(|when, then| {
        when.any_request();
        then.status(200).body("Hi from fake GitHub!");
    }).await;

    // Create the recording server for the test.
    let recording_server = MockServer::start_async().await;

    // Configure the recording server to forward requests to the target host.
    recording_server.forward_to_async(target_server.base_url(), |rule| {
        rule.filter(|when| {
            when.path("/hello"); // Forward all requests with path "/hello".
        });
    }).await;

    // Record the target server's response.
    let recording = recording_server.record_async(|rule| {
        rule.record_response_delays(true)
            .record_request_headers(vec!["Accept", "Content-Type"]) // Record specific headers.
            .filter(|when| {
                when.path("/hello"); // Only record requests with path "/hello".
            });
    }).await;

    // Use httpmock as a proxy server.
    let client = Client::new();

    let response = client
        .get(&format!("{}/hello", recording_server.base_url()))
        .send()
        .await
        .unwrap();
    assert_eq!(response.text().await.unwrap(), "Hi from fake GitHub!");

    // Store the recording to a file and create a new mock server to play back the recording.
    let target_path = recording.save("my_test_scenario").unwrap();

    let playback_server = MockServer::start_async().await;

    playback_server.playback_async(target_path).await;

    let response = client
        .get(&format!("{}/hello", playback_server.base_url()))
        .send()
        .await
        .unwrap();
    assert_eq!(response.text().await.unwrap(), "Hi from fake GitHub!");
});

Feature

This method is only available when the record feature is enabled.

pub fn playback_from_yaml<AsStrRef: AsRef<str>>( &self, content: AsStrRef, ) -> MockSet<'_>

Configures the mock server to respond with the recorded responses based on a provided recording in the form of a YAML string. This allows users to directly use a YAML string representing the recorded interactions, which can be useful for testing and debugging without needing a physical file.

Parameters

• content: A YAML string that represents the contents of the recording file. This can be any type that implements AsRef<str>, such as a &str or String.

Returns

• MockSet: An object representing the set of mocks that were loaded from the YAML string.

Example

use httpmock::MockServer;
use reqwest::blocking::Client;

// Example YAML content representing recorded interactions.
let yaml_content = r#"
when:
  method: GET
  path: /recorded-mock
then:
  status: 200
  header:
    - name: Content-Type
      value: application/json
  body: '{ "response" : "hello" }'
"#;

// Create the mock server.
let mock_server = MockServer::start();

// Play back the recorded interactions from the YAML string.
mock_server.playback_from_yaml(yaml_content);

// Use the reqwest HTTP client to send a request to the mock server.
let client = Client::new();

let response = client
    .get(&format!("{}/recorded-mock", mock_server.base_url())) // Build the full URL using the mock server's base URL
    .send() // Send the GET request
    .unwrap(); // Unwrap the result, assuming the request is successful

assert_eq!(response.headers().get("Content-Type").unwrap(), "application/json");
assert_eq!(response.text().unwrap(), r#"{ "response" : "hello" }"#);

Feature

This method is only available when the record feature is enabled.

pub async fn playback_from_yaml_async<AsStrRef: AsRef<str>>( &self, content: AsStrRef, ) -> MockSet<'_>

Asynchronously configures the mock server to respond with the recorded responses based on a provided recording in the form of a YAML string. This allows users to directly use a YAML string representing the recorded interactions, which can be useful for testing and debugging without needing a physical file.

Parameters

• content: A YAML string that represents the contents of the recording file. This can be any type that implements AsRef<str>, such as a &str or String.

Returns

• MockSet: An object representing the set of mocks that were loaded from the YAML string.

Example

use tokio::runtime::Runtime; // Import tokio for asynchronous runtime
use httpmock::MockServer;
use reqwest::Client;

// Example YAML content representing a recording.
let yaml_content = r#"
when:
  method: GET
  path: /recorded-mock
then:
  status: 200
  body: '{ "response" : "hello" }'
"#;

let rt = Runtime::new().unwrap();
rt.block_on(async {
    // Create the mock server.
    let mock_server = MockServer::start_async().await;

    // Play back the recorded interactions from the YAML string.
    mock_server.playback_from_yaml_async(yaml_content).await;

    // Use reqwest to send an asynchronous request to the mock server.
    let client = Client::new();

    let response = client
        .get(&format!("{}/recorded-mock", mock_server.base_url()))
        .send()
        .await
        .unwrap();

    assert_eq!(response.text().await.unwrap(), r#"{ "response" : "hello" }"#);
});

Feature

This method is only available when the record feature is enabled.

Trait Implementations

impl Drop for MockServer

Implements the Drop trait for MockServer. When a MockServer instance goes out of scope, this method is called automatically to manage resources.

fn drop(&mut self)

This method will returns the mock server to the pool of mock servers. The mock server is not cleaned immediately. Instead, it will be reset and cleaned when MockServer::start() is called again, preparing it for reuse by another test.

Important Considerations

Users should be aware that when a MockServer instance is dropped, the server is not immediately cleaned. The actual reset and cleaning of the server happen when MockServer::start() is called again, making it ready for reuse.

Feature

This behavior is part of the MockServer struct and does not require any additional features to be enabled.