Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Simule el tráfico HTTP mediante la reproducción estática en el AWS SDK para Rust
AWS SDK para Rust Proporciona varios enfoques para probar el código con Servicios de AWS el que interactúa. En este tema se describe cómo usar el `StaticReplayClient` para crear un cliente HTTP falso que pueda usarse en lugar del cliente HTTP estándar que suelen usar los Servicios de AWS. Este cliente devuelve las respuestas HTTP que especifique en lugar de comunicarse con el servicio a través de la red, de modo que las pruebas obtengan datos conocidos para fines de prueba.
La caja `aws-smithy-http-client` incluye una clase de utilidad de prueba denominada [https://docs.rs/aws-smithy-http-client/latest/aws_smithy_http_client/test_util/struct.StaticReplayClient.html](https://docs.rs/aws-smithy-http-client/latest/aws_smithy_http_client/test_util/struct.StaticReplayClient.html). Esta clase de cliente HTTP se puede especificar en lugar del cliente HTTP predeterminado al crear un Servicio de AWS objeto.
Al inicializar el `StaticReplayClient`, se proporciona una lista de pares de solicitudes y respuestas HTTP como objetos `ReplayEvent`. Mientras se ejecuta la prueba, se registra cada solicitud HTTP y el cliente devuelve la siguiente respuesta HTTP, que se encuentra en el siguiente `ReplayEvent` de la lista de eventos como respuesta del cliente HTTP. Esto permite que la prueba se ejecute con datos conocidos y sin conexión de red.
## Uso de reproducción estática
Para utilizar la reproducción estática, no es necesario utilizar un encapsulador. En su lugar, determine cómo debe ser el tráfico de red real para los datos que utilizará la prueba y proporcione esos datos de tráfico al `StaticReplayClient` para que los utilice cada vez que el SDK envíe una solicitud desde el cliente del Servicio de AWS .
**nota**
Hay varias formas de recopilar el tráfico de red esperado, incluidos muchos analizadores de AWS CLI tráfico de red y herramientas de detección de paquetes.
+ Cree una lista de objetos `ReplayEvent` que especifiquen las solicitudes HTTP esperadas y las respuestas que deben devolverse.
+ Cree un `StaticReplayClient` mediante la lista de transacciones HTTP creada en el paso anterior.
+ Cree un objeto de configuración para el AWS cliente, especificando el objeto `StaticReplayClient` como `Config` objeto. `http_client`
+ Cree el objeto de Servicio de AWS cliente mediante la configuración creada en el paso anterior.
+ Realice las operaciones que desee probar utilizando el objeto de servicio que está configurado para utilizar el `StaticReplayClient`. Cada vez que el SDK envía una solicitud de API a AWS, se utiliza la siguiente respuesta de la lista.
**nota**
Siempre se devuelve la siguiente respuesta de la lista, incluso si la solicitud enviada no coincide con la del vector de objetos `ReplayEvent`.
+ Cuando se hayan realizado todas las solicitudes deseadas, llame a la función `StaticReplayClient.assert_requests_match()` para comprobar que las solicitudes enviadas por el SDK coinciden con las de la lista de objetos `ReplayEvent`.
## Ejemplo
Veamos las pruebas para la misma función `determine_prefix_file_size()` del ejemplo anterior, pero utilizando la reproducción estática en lugar de la simulación.
1. En una línea de comandos del directorio del proyecto, agregue la caja [https://crates.io/crates/aws-smithy-http-client](https://crates.io/crates/aws-smithy-http-client) como una dependencia:
```
$ cargo add --dev aws-smithy-http-client --features test-util
```
Al usar la [opción](https://doc.rust-lang.org/cargo/commands/cargo-add.html) `--dev`, se agrega la caja a la sección `[dev-dependencies]` del archivo `Cargo.toml`. Como [dependencia de desarrollo](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#development-dependencies), 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`.
1. 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;
```
1. 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.
1. Para crear el cliente de 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.
1. 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.
Puedes [ver el código completo de estos ejemplos](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/testing) en GitHub.