Simular tráfego HTTP usando a reprodução estática no AWS SDK para Rust

Em um prompt de comando para o diretório do projeto, adicione a caixa aws-smithy-http-client como uma dependência:

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

Usar a opção --dev adiciona a caixa à seção [dev-dependencies] do seu arquivo Cargo.toml. Como uma dependência de desenvolvimento, 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.

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;

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.

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.

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.