Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Simulasikan lalu lintas HTTP menggunakan pemutaran ulang statis di AWS SDK untuk Rust
AWS SDK for Rust Ini menyediakan beberapa pendekatan untuk menguji kode Anda yang berinteraksi dengannya Layanan AWS. Topik ini menjelaskan cara menggunakan `StaticReplayClient` untuk membuat klien HTTP palsu yang dapat digunakan sebagai pengganti klien HTTP standar yang biasanya digunakan oleh Layanan AWS. Klien ini mengembalikan respons HTTP yang Anda tentukan daripada berkomunikasi dengan layanan melalui jaringan, sehingga pengujian mendapatkan data yang diketahui untuk tujuan pengujian.
`aws-smithy-http-client`Peti termasuk kelas utilitas uji yang disebut [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). Kelas klien HTTP ini dapat ditentukan bukan klien HTTP default saat membuat Layanan AWS objek.
Saat menginisialisasi`StaticReplayClient`, Anda memberikan daftar permintaan HTTP dan pasangan respons sebagai `ReplayEvent` objek. Saat pengujian berjalan, setiap permintaan HTTP dicatat dan klien mengembalikan respons HTTP berikutnya yang ditemukan `ReplayEvent` di daftar acara berikutnya sebagai respons klien HTTP. Ini memungkinkan pengujian dijalankan menggunakan data yang diketahui dan tanpa koneksi jaringan.
## Menggunakan replay statis
Untuk menggunakan pemutaran ulang statis, Anda tidak perlu menggunakan pembungkus. Sebagai gantinya, tentukan seperti apa tampilan lalu lintas jaringan aktual untuk data yang akan digunakan pengujian Anda, dan berikan data lalu lintas tersebut `StaticReplayClient` kepada yang akan digunakan setiap kali SDK mengeluarkan permintaan dari Layanan AWS klien.
**catatan**
Ada beberapa cara untuk mengumpulkan lalu lintas jaringan yang diharapkan, termasuk AWS CLI dan banyak penganalisis lalu lintas jaringan dan alat packet sniffer.
+ Buat daftar `ReplayEvent` objek yang menentukan permintaan HTTP yang diharapkan dan tanggapan yang harus dikembalikan untuk mereka.
+ Buat `StaticReplayClient` menggunakan daftar transaksi HTTP yang dibuat pada langkah sebelumnya.
+ Buat objek konfigurasi untuk AWS klien, menentukan `StaticReplayClient` sebagai `Config` objek. `http_client`
+ Buat objek Layanan AWS klien, menggunakan konfigurasi yang dibuat pada langkah sebelumnya.
+ Lakukan operasi yang ingin Anda uji, menggunakan objek layanan yang dikonfigurasi untuk menggunakan`StaticReplayClient`. Setiap kali SDK mengirimkan permintaan API AWS, respons berikutnya dalam daftar akan digunakan.
**catatan**
Respons berikutnya dalam daftar selalu dikembalikan, bahkan jika permintaan yang dikirim tidak cocok dengan yang ada di vektor `ReplayEvent` objek.
+ Ketika semua permintaan yang diinginkan telah dibuat, panggil `StaticReplayClient.assert_requests_match()` fungsi untuk memverifikasi bahwa permintaan yang dikirim oleh SDK cocok dengan yang ada dalam daftar `ReplayEvent` objek.
## Contoh
Mari kita lihat tes untuk `determine_prefix_file_size()` fungsi yang sama pada contoh sebelumnya, tetapi menggunakan pemutaran ulang statis alih-alih mengejek.
1. Dalam prompt perintah untuk direktori proyek Anda, tambahkan [https://crates.io/crates/aws-smithy-http-client](https://crates.io/crates/aws-smithy-http-client)peti sebagai dependensi:
```
$ cargo add --dev aws-smithy-http-client --features test-util
```
Menggunakan `--dev` [opsi](https://doc.rust-lang.org/cargo/commands/cargo-add.html) menambahkan peti ke `[dev-dependencies]` bagian `Cargo.toml` file Anda. Sebagai [dependensi pengembangan](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#development-dependencies), itu tidak dikompilasi dan dimasukkan ke dalam biner akhir Anda yang digunakan untuk kode produksi.
Kode contoh ini juga menggunakan Amazon Simple Storage Service sebagai contoh Layanan AWS.
```
$ cargo add aws-sdk-s3
```
Ini menambahkan peti ke `[dependencies]` bagian `Cargo.toml` file Anda.
1. Dalam modul kode pengujian Anda, sertakan kedua jenis yang Anda perlukan.
```
use aws_smithy_http_client::test_util::{ReplayEvent, StaticReplayClient};
use aws_sdk_s3::primitives::SdkBody;
```
1. Tes dimulai dengan membuat `ReplayEvent` struktur yang mewakili setiap transaksi HTTP yang harus dilakukan selama pengujian. Setiap peristiwa berisi objek permintaan HTTP dan objek respons HTTP yang mewakili informasi yang biasanya Layanan AWS akan dibalas. Peristiwa ini diteruskan ke panggilan ke`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]);
```
Hasilnya disimpan di`replay_client`. Ini merupakan klien HTTP yang kemudian dapat digunakan oleh SDK untuk Rust dengan menentukannya dalam konfigurasi klien.
1. Untuk membuat klien Amazon S3, panggil `from_conf()` fungsi kelas klien untuk membuat klien menggunakan objek konfigurasi:
```
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(),
);
```
Objek konfigurasi ditentukan menggunakan `http_client()` metode pembangun, dan kredensialnya ditentukan menggunakan metode. `credentials_provider()` Kredensialnya dibuat menggunakan fungsi yang disebut`make_s3_test_credentials()`, yang mengembalikan struktur kredensial palsu:
```
fn make_s3_test_credentials() -> s3::config::Credentials {
s3::config::Credentials::new(
"ATESTCLIENT",
"astestsecretkey",
Some("atestsessiontoken".to_string()),
None,
"",
)
}
```
Kredensi ini tidak harus valid karena tidak akan benar-benar dikirim ke. AWS
1. Jalankan pengujian dengan memanggil fungsi yang membutuhkan pengujian. Dalam contoh ini, nama fungsi itu adalah`determine_prefix_file_size()`. Parameter pertamanya adalah objek klien Amazon S3 yang akan digunakan untuk permintaannya. Oleh karena itu, tentukan klien yang dibuat menggunakan permintaan `StaticReplayClient` so ditangani oleh itu daripada keluar melalui jaringan:
```
let size = determine_prefix_file_size(client, "test-bucket", "test-prefix")
.await
.unwrap();
assert_eq!(19, size);
replay_client.assert_requests_match(&[]);
```
Ketika panggilan ke `determine_prefix_file_size()` selesai, pernyataan digunakan untuk mengonfirmasi bahwa nilai yang dikembalikan cocok dengan nilai yang diharapkan. Kemudian, `assert_requests_match()` fungsi `StaticReplayClient` metode disebut. Fungsi ini memindai permintaan HTTP yang direkam dan mengonfirmasi bahwa semuanya cocok dengan yang ditentukan dalam array `ReplayEvent` objek yang disediakan saat membuat klien replay.
Anda dapat [melihat kode lengkap untuk contoh-contoh ini](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/testing) di GitHub.