As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Simule o tráfego HTTP usando a reprodução estática no AWS SDK para Rust
O AWS SDK para Rust fornece várias abordagens para testar seu código que interage com Serviços da AWS. Este tópico descreve como usar o `StaticReplayClient` para criar um cliente HTTP falso que pode ser usado em vez do cliente HTTP padrão que normalmente é usado pelos Serviços da AWS. Esse cliente retorna as respostas HTTP especificadas em vez de se comunicar com o serviço pela rede, para que os testes obtenham dados conhecidos para fins de teste.
A caixa `aws-smithy-http-client` inclui uma classe de utilitário de teste chamada [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). Essa classe de cliente HTTP pode ser especificada em vez do cliente HTTP padrão ao criar um AWS service (Serviço da AWS) objeto.
Ao inicializar o `StaticReplayClient`, você fornece uma lista de pares de solicitações e respostas HTTP como objetos `ReplayEvent`. Enquanto o teste está em execução, cada solicitação HTTP é registrada e o cliente retorna a próxima resposta HTTP encontrada no `ReplayEvent` seguinte na lista de eventos como a resposta do cliente HTTP. Isso permite que o teste seja executado usando dados conhecidos e sem uma conexão de rede.
## Usar a reprodução estática
Para usar a reprodução estática, não é preciso usar um wrapper. Em vez disso, determine como o tráfego de rede real deveria ser para os dados que seu teste usará e forneça esses dados de tráfego ao `StaticReplayClient` para uso sempre que o SDK emitir uma solicitação do cliente dos AWS service (Serviço da AWS) .
**nota**
Há várias maneiras de coletar o tráfego de rede esperado, incluindo muitos analisadores de tráfego de rede e ferramentas de detecção de pacotes. AWS CLI
+ Crie uma lista de objetos `ReplayEvent` que especifique as solicitações HTTP esperadas e as respostas que devem ser retornadas para elas.
+ Crie um `StaticReplayClient` usando a lista de transações HTTP criada na etapa anterior.
+ Crie um objeto de configuração para o AWS cliente, especificando o `StaticReplayClient` como `Config` objeto. `http_client`
+ Crie o objeto AWS service (Serviço da AWS) cliente usando a configuração criada na etapa anterior.
+ Execute as operações que deseja testar usando o objeto de serviço que está configurado para usar o `StaticReplayClient`. Sempre que o SDK envia uma solicitação de API para AWS, a próxima resposta na lista é usada.
**nota**
A próxima resposta na lista é sempre retornada, mesmo que a solicitação enviada não corresponda à do vetor de objetos de `ReplayEvent`.
+ Quando todas as solicitações desejadas tiverem sido feitas, chame a função `StaticReplayClient.assert_requests_match()` para verificar se as solicitações enviadas pelo SDK correspondem às da lista de objetos de `ReplayEvent`.
## Exemplo
Vejamos os testes da mesma função `determine_prefix_file_size()` no exemplo anterior, mas usando repetição estática em vez de simulação.
1. Em um prompt de comando para o diretório do projeto, adicione a caixa [https://crates.io/crates/aws-smithy-http-client](https://crates.io/crates/aws-smithy-http-client) como uma dependência:
```
$ cargo add --dev aws-smithy-http-client --features test-util
```
Usar a [opção](https://doc.rust-lang.org/cargo/commands/cargo-add.html) `--dev` adiciona a caixa à seção `[dev-dependencies]` do seu arquivo `Cargo.toml`. Como uma [dependência de desenvolvimento](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#development-dependencies), ela não é compilada e incluída no binário final usado para o código de produção.
Esse código de exemplo também usa o Amazon Simple Storage Service como o AWS service (Serviço da AWS) de exemplo.
```
$ cargo add aws-sdk-s3
```
Isso adiciona a caixa à seção `[dependencies]` do seu arquivo `Cargo.toml`.
1. Em seu módulo de código de teste, inclua ambos os tipos necessários.
```
use aws_smithy_http_client::test_util::{ReplayEvent, StaticReplayClient};
use aws_sdk_s3::primitives::SdkBody;
```
1. O teste começa criando as estruturas de `ReplayEvent` que representam cada uma das transações HTTP que devem ocorrer durante o teste. Cada evento contém um objeto de solicitação HTTP e um objeto de resposta HTTP representando as informações com as quais os AWS service (Serviço da AWS) normalmente responderiam. Esses eventos são passados para uma chamada para `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]);
```
O resultado é armazenado em `replay_client`. Isso representa um cliente HTTP que pode então ser usado pelo SDK para Rust especificando-o na configuração do cliente.
1. Para criar o cliente do Amazon S3, chame a função `from_conf()` da classe cliente para criar o cliente usando um objeto de configuração:
```
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(),
);
```
O objeto de configuração é especificado usando o método `http_client()` do construtor e as credenciais são especificadas usando o método `credentials_provider()`. As credenciais são criadas usando uma função chamada `make_s3_test_credentials()`, que retorna uma estrutura de credenciais falsa:
```
fn make_s3_test_credentials() -> s3::config::Credentials {
s3::config::Credentials::new(
"ATESTCLIENT",
"astestsecretkey",
Some("atestsessiontoken".to_string()),
None,
"",
)
}
```
Essas credenciais não precisam ser válidas porque, na verdade, não serão enviadas para a AWS.
1. Execute o teste chamando a função que precisa ser testada. Neste exemplo, o nome dessa função é `determine_prefix_file_size()`. Seu primeiro parâmetro é o objeto cliente do Amazon S3 a ser usado para as solicitações. Portanto, especifique o cliente criado usando o `StaticReplayClient` para que as solicitações sejam tratadas por ele, em vez de serem enviadas pela rede:
```
let size = determine_prefix_file_size(client, "test-bucket", "test-prefix")
.await
.unwrap();
assert_eq!(19, size);
replay_client.assert_requests_match(&[]);
```
Quando a chamada para `determine_prefix_file_size()` é concluída, uma declaração é usada para confirmar se o valor retornado corresponde ao valor esperado. Em seguida, a função `assert_requests_match()` do método `StaticReplayClient` é chamada. Essa função verifica as solicitações HTTP gravadas e confirma que todas correspondem às especificadas na matriz de objetos de `ReplayEvent` fornecida ao criar o cliente de reprodução.
Você pode [ver o código completo desses exemplos](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/testing) em GitHub.