Struct aws_smithy_runtime::client::http::test_util::StaticReplayClient

pub struct StaticReplayClient { /* private fields */ }

Available on crate features client and test-util only.

Request/response replaying client for use in tests.

This mock client takes a list of request/response pairs named ReplayEvent. While the client is in use, the responses will be given in the order they appear in the list regardless of what the actual request was. The actual request is recorded, but otherwise not validated against what is in the ReplayEvent. Later, after the client is finished being used, the assert_requests_match method can be used to validate the requests.

This utility is simpler than DVR, and thus, is good for tests that don’t need to record and replay real traffic.

Example

use aws_smithy_runtime::client::http::test_util::{ReplayEvent, StaticReplayClient};
use aws_smithy_types::body::SdkBody;

let http_client = StaticReplayClient::new(vec![
    // Event that covers the first request/response
    ReplayEvent::new(
        // If `assert_requests_match` is called later, then this request will be matched
        // against the actual request that was made.
        http::Request::builder().uri("http://localhost:1234/foo").body(SdkBody::empty()).unwrap(),
        // This response will be given to the first request regardless of whether it matches the request above.
        http::Response::builder().status(200).body(SdkBody::empty()).unwrap(),
    ),
    // The next ReplayEvent covers the second request/response pair...
]);

let config = my_generated_client::Config::builder()
    .http_client(http_client.clone())
    .build();
let client = my_generated_client::Client::from_conf(config);

// Do stuff with client...

// When you're done, assert the requests match what you expected
http_client.assert_requests_match(&[]);

Implementations

impl StaticReplayClient

pub fn new(data: Vec<ReplayEvent>) -> Self

Creates a new event connector.

pub fn actual_requests(&self) -> impl Iterator<Item = &HttpRequest> + '_

Returns an iterator over the actual requests that were made.

pub fn assert_requests_match(&self, ignore_headers: &[&str])

Asserts the expected requests match the actual requests.

The expected requests are given as the connection events when the EventConnector is created. The EventConnector will record the actual requests and assert that they match the expected requests.

A list of headers that should be ignored when comparing requests can be passed for cases where headers are non-deterministic or are irrelevant to the test.

Trait Implementations

impl Clone for StaticReplayClient

fn clone(&self) -> StaticReplayClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StaticReplayClient

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

Formats the value using the given formatter.

impl HttpClient for StaticReplayClient

fn http_connector( &self, _: &HttpConnectorSettings, _: &RuntimeComponents ) -> SharedHttpConnector

Returns a HTTP connector based on the requested connector settings.

fn validate_base_client_config( &self, runtime_components: &RuntimeComponentsBuilder, cfg: &ConfigBag ) -> Result<(), Box<dyn Error + Sync + Send>>

Validate the base client configuration.

fn validate_final_config( &self, runtime_components: &RuntimeComponents, cfg: &ConfigBag ) -> Result<(), Box<dyn Error + Sync + Send>>

Validate the final client configuration.

impl HttpConnector for StaticReplayClient

fn call(&self, request: HttpRequest) -> HttpConnectorFuture

Asynchronously converts a request into a response.