Struct aws_smithy_runtime::client::http::test_util::dvr::RecordingClient

pub struct RecordingClient { /* private fields */ }

Available on crate features client and test-util and connector-hyper-0-14-x only.

Recording client

RecordingClient wraps an inner connection and records all traffic, enabling traffic replay.

Example

use aws_smithy_async::rt::sleep::default_async_sleep;
use aws_smithy_runtime::client::http::hyper_014::default_connector;
use aws_smithy_runtime::client::http::test_util::dvr::RecordingClient;
use aws_smithy_runtime_api::client::http::HttpConnectorSettingsBuilder;
use aws_sdk_s3::{Client, Config};

#[tokio::test]
async fn test_content_length_enforcement_is_not_applied_to_head_request() {
    let settings = HttpConnectorSettingsBuilder::default().build();
    let http_client = default_connector(&settings, default_async_sleep()).unwrap();
    let http_client = RecordingClient::new(http_client);

    // Since we need to send a real request for this,
    // you'll need to use your real credentials.
    let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
    let config = Config::from(&config).to_builder()
        .http_client(http_client.clone())
        .region(Region::new("us-east-1"))
        .build();

    let client = Client::from_conf(config);
    let _resp = client
        .head_object()
        .key("some-test-file.txt")
        .bucket("your-test-bucket")
        .send()
        .await
        .unwrap();

    // If the request you want to record has a body, don't forget to poll
    // the body to completion BEFORE calling `dump_to_file`. Otherwise, your
    // test json won't include the body.
    // let _body = _resp.body.collect().await.unwrap();

    // This path is relative to your project or workspace `Cargo.toml` file.
    http_client.dump_to_file("tests/data/content-length-enforcement/head-object.json").unwrap();
}

Implementations

impl RecordingClient

pub fn https() -> Self

Available on crate feature tls-rustls only.

Construct a recording connection wrapping a default HTTPS implementation without any timeouts.

impl RecordingClient

pub fn new(underlying_connector: impl HttpConnector + 'static) -> Self

Create a new recording connection from a connection

pub fn events(&self) -> MutexGuard<'_, Vec<Event>>

Return the traffic recorded by this connection

pub fn network_traffic(&self) -> NetworkTraffic

NetworkTraffic struct suitable for serialization

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

Dump the network traffic to a file

Trait Implementations

impl Clone for RecordingClient

fn clone(&self) -> RecordingClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RecordingClient

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

Formats the value using the given formatter.

impl HttpClient for RecordingClient

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

Returns a HTTP connector based on the requested connector settings.

fn connector_metadata(&self) -> Option<ConnectorMetadata>

Provide metadata about the crate that this HttpClient uses to make connectors.

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 RecordingClient

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

Asynchronously converts a request into a response.