Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Simula il traffico HTTP utilizzando la riproduzione statica nell' AWS SDK per Rust
AWS SDK per Rust Fornisce diversi approcci per testare il codice con cui interagisce. Servizi AWS Questo argomento descrive come utilizzare per `StaticReplayClient` creare un client HTTP falso che può essere utilizzato al posto del client HTTP standard normalmente utilizzato da Servizi AWS. Questo client restituisce le risposte HTTP specificate anziché comunicare con il servizio tramite la rete, in modo che i test ottengano dati noti a scopo di test.
La `aws-smithy-http-client` cassa include una classe di utilità di test denominata. [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) Questa classe client HTTP può essere specificata al posto del client HTTP predefinito durante la creazione di un Servizio AWS oggetto.
Quando si inizializza`StaticReplayClient`, si fornisce un elenco di coppie di richieste e risposte HTTP come `ReplayEvent` oggetti. Durante l'esecuzione del test, ogni richiesta HTTP viene registrata e il client restituisce la risposta HTTP successiva trovata nella successiva `ReplayEvent` nell'elenco degli eventi come risposta del client HTTP. Ciò consente l'esecuzione del test utilizzando dati noti e senza una connessione di rete.
## Utilizzo della riproduzione statica
Per utilizzare la riproduzione statica, non è necessario utilizzare un wrapper. Invece, stabilisci come dovrebbe essere l'effettivo traffico di rete per i dati che verranno utilizzati dal test e fornisci tali dati sul traffico all'utente da utilizzare ogni volta che l'SDK invia una richiesta dal client. `StaticReplayClient` Servizio AWS
**Nota**
Esistono diversi modi per raccogliere il traffico di rete previsto, tra cui numerosi analizzatori del traffico di rete AWS CLI e strumenti di analisi dei pacchetti.
+ Crea un elenco di `ReplayEvent` oggetti che specificano le richieste HTTP previste e le risposte che devono essere restituite per esse.
+ Crea un elenco di transazioni `StaticReplayClient` utilizzando l'elenco di transazioni HTTP creato nel passaggio precedente.
+ Crea un oggetto di configurazione per il AWS client, specificandolo `StaticReplayClient` come `Config` oggetto. `http_client`
+ Create l'oggetto Servizio AWS client, utilizzando la configurazione creata nel passaggio precedente.
+ Eseguite le operazioni che desiderate testare utilizzando l'oggetto servizio configurato per utilizzare il`StaticReplayClient`. Ogni volta che l'SDK invia una richiesta API a AWS, viene utilizzata la risposta successiva nell'elenco.
**Nota**
La risposta successiva nell'elenco viene sempre restituita, anche se la richiesta inviata non corrisponde a quella nel vettore di `ReplayEvent` oggetti.
+ Una volta effettuate tutte le richieste desiderate, chiamate la `StaticReplayClient.assert_requests_match()` funzione per verificare che le richieste inviate dall'SDK corrispondano a quelle nell'elenco degli `ReplayEvent` oggetti.
## Esempio
Diamo un'occhiata ai test per la stessa `determine_prefix_file_size()` funzione nell'esempio precedente, ma utilizziamo la riproduzione statica anziché la simulazione.
1. In un prompt dei comandi per la directory del progetto, aggiungi la [https://crates.io/crates/aws-smithy-http-client](https://crates.io/crates/aws-smithy-http-client)cassa come dipendenza:
```
$ cargo add --dev aws-smithy-http-client --features test-util
```
L'utilizzo dell'`--dev`[opzione](https://doc.rust-lang.org/cargo/commands/cargo-add.html) aggiunge la cassa alla `[dev-dependencies]` sezione del file. `Cargo.toml` Come [dipendenza di sviluppo](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#development-dependencies), non viene compilato e incluso nel file binario finale utilizzato per il codice di produzione.
Questo codice di esempio utilizza anche Amazon Simple Storage Service come esempio Servizio AWS.
```
$ cargo add aws-sdk-s3
```
Questo aggiunge la cassa alla `[dependencies]` sezione del `Cargo.toml` file.
1. Nel modulo di codice di test, includi entrambi i tipi di cui avrai bisogno.
```
use aws_smithy_http_client::test_util::{ReplayEvent, StaticReplayClient};
use aws_sdk_s3::primitives::SdkBody;
```
1. Il test inizia creando le `ReplayEvent` strutture che rappresentano ciascuna delle transazioni HTTP che dovrebbero avvenire durante il test. Ogni evento contiene un oggetto di richiesta HTTP e un oggetto di risposta HTTP che rappresentano le informazioni con cui normalmente Servizio AWS risponderebbero. Questi eventi vengono passati in una chiamata 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]);
```
Il risultato viene memorizzato in`replay_client`. Rappresenta un client HTTP che può quindi essere utilizzato dall'SDK per Rust specificandolo nella configurazione del client.
1. Per creare il client Amazon S3, chiama la `from_conf()` funzione della classe client per creare il client utilizzando un oggetto di configurazione:
```
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(),
);
```
L'oggetto di configurazione viene specificato utilizzando il `http_client()` metodo del generatore e le credenziali vengono specificate utilizzando il metodo. `credentials_provider()` Le credenziali vengono create utilizzando una funzione chiamata`make_s3_test_credentials()`, che restituisce una struttura di credenziali false:
```
fn make_s3_test_credentials() -> s3::config::Credentials {
s3::config::Credentials::new(
"ATESTCLIENT",
"astestsecretkey",
Some("atestsessiontoken".to_string()),
None,
"",
)
}
```
Queste credenziali non devono essere valide perché non verranno effettivamente inviate a. AWS
1. Esegui il test chiamando la funzione che deve essere testata. In questo esempio, il nome di quella funzione è`determine_prefix_file_size()`. Il suo primo parametro è l'oggetto client Amazon S3 da utilizzare per le sue richieste. Pertanto, specifica il client creato utilizzando il sistema `StaticReplayClient` in modo che le richieste vengano gestite da quello anziché essere inviate in rete:
```
let size = determine_prefix_file_size(client, "test-bucket", "test-prefix")
.await
.unwrap();
assert_eq!(19, size);
replay_client.assert_requests_match(&[]);
```
Al termine della chiamata a, `determine_prefix_file_size()` viene utilizzata un'asserzione per confermare che il valore restituito corrisponde al valore previsto. Quindi, viene chiamata la `assert_requests_match()` funzione del `StaticReplayClient` metodo. Questa funzione analizza le richieste HTTP registrate e conferma che corrispondono tutte a quelle specificate nell'array di `ReplayEvent` oggetti fornito durante la creazione del client di replay.
È possibile [visualizzare il codice completo per questi esempi](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/testing) su. GitHub