Simulación de tráfico HTTP mediante la reproducción estática en AWS SDK para Rust

En una línea de comandos del directorio del proyecto, agregue la caja aws-smithy-http-client como una dependencia:

$ cargo add --dev aws-smithy-http-client --features test-util

Al usar la opción --dev, se agrega la caja a la sección [dev-dependencies] del archivo Cargo.toml. Como dependencia de desarrollo, no se compila ni se incluye en el binario final que se utiliza para el código de producción.

Este código de ejemplo también utiliza Amazon Simple Storage Service como el Servicio de AWS de ejemplo.

$ cargo add aws-sdk-s3

De esta forma, se agrega la caja a la sección [dependencies] del archivo Cargo.toml.

En el módulo de código de prueba, incluya los dos tipos que necesitará.

use aws_smithy_http_client::test_util::{ReplayEvent, StaticReplayClient};
use aws_sdk_s3::primitives::SdkBody;

La prueba comienza con la creación de las estructuras ReplayEvent que representan cada una de las transacciones HTTP que deben tener lugar durante la prueba. Cada evento contiene un objeto de solicitud HTTP y un objeto de respuesta HTTP que representan la información con la que normalmente respondería el Servicio de AWS. Estos eventos se pasan a una llamada a StaticReplayClient::new():

        let page_1 = ReplayEvent::new(
                http::Request::builder()
                    .method("GET")
                    .uri("https://test-bucket.s3.us-east-1.amazonaws.com/?list-type=2&prefix=test-prefix")
                    .body(SdkBody::empty())
                    .unwrap(),
                http::Response::builder()
                    .status(200)
                    .body(SdkBody::from(include_str!("./testing/response_multi_1.xml")))
                    .unwrap(),
            );
        let page_2 = ReplayEvent::new(
                http::Request::builder()
                    .method("GET")
                    .uri("https://test-bucket.s3.us-east-1.amazonaws.com/?list-type=2&prefix=test-prefix&continuation-token=next")
                    .body(SdkBody::empty())
                    .unwrap(),
                http::Response::builder()
                    .status(200)
                    .body(SdkBody::from(include_str!("./testing/response_multi_2.xml")))
                    .unwrap(),
            );
        let replay_client = StaticReplayClient::new(vec![page_1, page_2]);

El resultado se almacena en replay_client. Esto representa un cliente HTTP que luego puede usar el SDK para Rust especificándolo en la configuración del cliente.

Para crear el cliente Amazon S3, llame a la función from_conf() de la clase del cliente para crear el cliente mediante un objeto de configuración:

        let client: s3::Client = s3::Client::from_conf(
            s3::Config::builder()
                .behavior_version(BehaviorVersion::latest())
                .credentials_provider(make_s3_test_credentials())
                .region(s3::config::Region::new("us-east-1"))
                .http_client(replay_client.clone())
                .build(),
        );

El objeto de configuración se especifica mediante el método http_client() del generador y las credenciales se especifican mediante el método credentials_provider(). Las credenciales se crean mediante una función denominada make_s3_test_credentials(), que devuelve una estructura de credenciales falsa:

fn make_s3_test_credentials() -> s3::config::Credentials {
    s3::config::Credentials::new(
        "ATESTCLIENT",
        "astestsecretkey",
        Some("atestsessiontoken".to_string()),
        None,
        "",
    )
}

No es necesario que estas credenciales sean válidas porque, en realidad, no se enviarán a AWS.

Ejecute la prueba llamando a la función que debe probarse. En este ejemplo, el nombre de esa función es determine_prefix_file_size(). Su primer parámetro es el objeto del cliente de Amazon S3 que se utilizará para sus solicitudes. Por lo tanto, especifique el cliente creado con StaticReplayClient para que este se encargue de gestionar las solicitudes en lugar de que salgan a la red:

        let size = determine_prefix_file_size(client, "test-bucket", "test-prefix")
            .await
            .unwrap();

        assert_eq!(19, size);

        replay_client.assert_requests_match(&[]);

Cuando finaliza la llamada a determine_prefix_file_size(), se utiliza una aserción para confirmar que el valor devuelto coincide con el valor esperado. A continuación, se llama a la función assert_requests_match() del método StaticReplayClient. Esta función analiza las solicitudes HTTP registradas y confirma que todas coinciden con las especificadas en la matriz de objetos ReplayEvent proporcionada al crear el cliente de reproducción.