Simulez le trafic HTTP à l'aide de la rediffusion statique dans le AWS SDK pour Rust

Dans une invite de commande pour le répertoire de votre projet, ajoutez le aws-smithy-http-clientcrate en tant que dépendance :

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

L'utilisation de --dev cette option ajoute la caisse à la [dev-dependencies] section de votre Cargo.toml fichier. En tant que dépendance de développement, elle n'est pas compilée et incluse dans votre binaire final utilisé pour le code de production.

Cet exemple de code utilise également Amazon Simple Storage Service comme exemple Service AWS.

$ cargo add aws-sdk-s3

Cela ajoute la caisse à la [dependencies] section de votre Cargo.toml fichier.

Dans votre module de code de test, incluez les deux types dont vous aurez besoin.

use aws_smithy_http_client::test_util::{ReplayEvent, StaticReplayClient};
use aws_sdk_s3::primitives::SdkBody;

Le test commence par créer les ReplayEvent structures représentant chacune des transactions HTTP qui doivent avoir lieu pendant le test. Chaque événement contient un objet de requête HTTP et un objet de réponse HTTP représentant les informations auxquelles ils Service AWS répondraient normalement. Ces événements sont transmis dans un appel à 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]);

Le résultat est enregistré dansreplay_client. Cela représente un client HTTP qui peut ensuite être utilisé par le SDK pour Rust en le spécifiant dans la configuration du client.

Pour créer le client Amazon S3, appelez la from_conf() fonction de la classe client pour créer le client à l'aide d'un objet de configuration :

        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'objet de configuration est spécifié à l'aide de la http_client() méthode du générateur, et les informations d'identification sont spécifiées à l'aide de la credentials_provider() méthode. Les informations d'identification sont créées à l'aide d'une fonction appeléemake_s3_test_credentials(), qui renvoie une fausse structure d'informations d'identification :

fn make_s3_test_credentials() -> s3::config::Credentials {
    s3::config::Credentials::new(
        "ATESTCLIENT",
        "astestsecretkey",
        Some("atestsessiontoken".to_string()),
        None,
        "",
    )
}

Ces informations d'identification n'ont pas besoin d'être valides car elles ne seront pas réellement envoyées à AWS.

Exécutez le test en appelant la fonction à tester. Dans cet exemple, le nom de cette fonction estdetermine_prefix_file_size(). Son premier paramètre est l'objet client Amazon S3 à utiliser pour ses demandes. Par conséquent, spécifiez le client créé à l'aide du système StaticReplayClient afin que les demandes soient traitées par celui-ci plutôt que de passer par le réseau :

        let size = determine_prefix_file_size(client, "test-bucket", "test-prefix")
            .await
            .unwrap();

        assert_eq!(19, size);

        replay_client.assert_requests_match(&[]);

Lorsque l'appel à determine_prefix_file_size() est terminé, un assertion est utilisé pour confirmer que la valeur renvoyée correspond à la valeur attendue. Ensuite, la assert_requests_match() fonction de StaticReplayClient méthode est appelée. Cette fonction analyse les requêtes HTTP enregistrées et confirme qu'elles correspondent toutes à celles spécifiées dans le tableau d'ReplayEventobjets fourni lors de la création du client de rediffusion.