Pruebas unitarias

En la línea de comandos del directorio de su proyecto, añada la mockall caja como dependencia:

$ cargo add mockall

Esto añade la caja a la [dependencies] sección de tu Cargo.toml archivo.

Incluya el automock módulo de la mockall caja.

Incluya también cualquier otra biblioteca relacionada con la Servicio de AWS que esté probando, en este caso, Amazon S3.

use aws_sdk_s3 as s3;
#[allow(unused_imports)]
use mockall::automock;

use s3::operation::list_objects_v2::{ListObjectsV2Error, ListObjectsV2Output};

A continuación, añada un código que determine cuál de las dos implementaciones de la estructura contenedora de Amazon S3 de la aplicación debe utilizarse.

En este ejemplo, se le da el nombre a la seleccionadaS3. La selección es condicional y se basa en el test atributo:

#[cfg(test)]
pub use MockS3Impl as S3;
#[cfg(not(test))]
pub use S3Impl as S3;

La S3Impl estructura es la implementación de la estructura contenedora de Amazon S3 a la que realmente envía las solicitudes. AWS

#[allow(dead_code)]
pub struct S3Impl {
    inner: s3::Client,
}

#[cfg_attr(test, automock)]
impl S3Impl {
    #[allow(dead_code)]
    pub fn new(inner: s3::Client) -> Self {
        Self { inner }
    }

    #[allow(dead_code)]
    pub async fn list_objects(
        &self,
        bucket: &str,
        prefix: &str,
        continuation_token: Option<String>,
    ) -> Result<ListObjectsV2Output, s3::error::SdkError<ListObjectsV2Error>> {
        self.inner
            .list_objects_v2()
            .bucket(bucket)
            .prefix(prefix)
            .set_continuation_token(continuation_token)
            .send()
            .await
    }
}

Cree las funciones de prueba en un módulo denominadotest.

#[cfg(test)]
mod test {
    use super::*;
    use mockall::predicate::eq;

    #[tokio::test]
    async fn test_single_page() {
        let mut mock = MockS3Impl::default();
        mock.expect_list_objects()
            .with(eq("test-bucket"), eq("test-prefix"), eq(None))
            .return_once(|_, _, _| {
                Ok(ListObjectsV2Output::builder()
                    .set_contents(Some(vec![
                        // Mock content for ListObjectsV2 response
                        s3::types::Object::builder().size(5).build(),
                        s3::types::Object::builder().size(2).build(),
                    ]))
                    .build())
            });

        // Run the code we want to test with it
        let size = determine_prefix_file_size(mock, "test-bucket", "test-prefix")
            .await
            .unwrap();

        // Verify we got the correct total size back
        assert_eq!(7, size);
    }

    #[tokio::test]
    async fn test_multiple_pages() {
        // Create the Mock instance with two pages of objects now
        let mut mock = MockS3Impl::default();
        mock.expect_list_objects()
            .with(eq("test-bucket"), eq("test-prefix"), eq(None))
            .return_once(|_, _, _| {
                Ok(ListObjectsV2Output::builder()
                    .set_contents(Some(vec![
                        // Mock content for ListObjectsV2 response
                        s3::types::Object::builder().size(5).build(),
                        s3::types::Object::builder().size(2).build(),
                    ]))
                    .set_next_continuation_token(Some("next".to_string()))
                    .build())
            });
        mock.expect_list_objects()
            .with(
                eq("test-bucket"),
                eq("test-prefix"),
                eq(Some("next".to_string())),
            )
            .return_once(|_, _, _| {
                Ok(ListObjectsV2Output::builder()
                    .set_contents(Some(vec![
                        // Mock content for ListObjectsV2 response
                        s3::types::Object::builder().size(3).build(),
                        s3::types::Object::builder().size(9).build(),
                    ]))
                    .build())
            });

        // Run the code we want to test with it
        let size = determine_prefix_file_size(mock, "test-bucket", "test-prefix")
            .await
            .unwrap();

        assert_eq!(19, size);
    }
}

La determine_prefix_file_size() función usa el contenedor Amazon S3 para obtener el tamaño del archivo de prefijos:

#[allow(dead_code)]
pub async fn determine_prefix_file_size(
    // Now we take a reference to our trait object instead of the S3 client
    // s3_list: ListObjectsService,
    s3_list: S3,
    bucket: &str,
    prefix: &str,
) -> Result<usize, s3::Error> {
    let mut next_token: Option<String> = None;
    let mut total_size_bytes = 0;
    loop {
        let result = s3_list
            .list_objects(bucket, prefix, next_token.take())
            .await?;

        // Add up the file sizes we got back
        for object in result.contents() {
            total_size_bytes += object.size().unwrap_or(0) as usize;
        }

        // Handle pagination, and break the loop if there are no more pages
        next_token = result.next_continuation_token.clone();
        if next_token.is_none() {
            break;
        }
    }
    Ok(total_size_bytes)
}

En una línea de comandos para el directorio de tu proyecto, agrega la aws-smithy-runtimecaja como una dependencia:

$ cargo add aws-smithy-runtime --features test-util

Esto añade la caja a la [dependencies] sección de tu Cargo.toml archivo.

En el archivo fuente, incluye los aws_smithy_runtime tipos que necesitarás.

use aws_smithy_runtime::client::http::test_util::{ReplayEvent, StaticReplayClient};
use aws_smithy_types::body::SdkBody;

La prueba comienza con la creación de las ReplayEvent estructuras que representan cada una de las transacciones HTTP que deberían tener lugar durante la prueba. Cada evento contiene un objeto de solicitud HTTP y un objeto de respuesta HTTP que representan la información con la que normalmente Servicio de AWS responderían. Estos eventos se transfieren a una llamada aStaticReplayClient::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]);

El resultado se almacena enreplay_client. Esto representa un cliente HTTP que luego puede ser utilizado por el SDK de Rust especificándolo en la configuración del cliente.

Para crear el cliente Amazon S3, llame a la from_conf() función de la clase de cliente para crear el cliente mediante un objeto de configuración:

        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(),
        );

El objeto de configuración se especifica mediante el http_client() método del generador y las credenciales se especifican mediante el credentials_provider() método. Las credenciales se crean mediante una función llamadamake_s3_test_credentials(), que devuelve una estructura de credenciales falsa:

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

No es necesario que estas credenciales sean válidas porque, en realidad, no se enviarán a AWS.

Ejecute la prueba llamando a la función que necesita probarse. En este ejemplo, el nombre de esa función esdetermine_prefix_file_size(). Su primer parámetro es el objeto de cliente de Amazon S3 que se va a utilizar para sus solicitudes. Por lo tanto, especifique el cliente creado con el StaticReplayClient fin de que las solicitudes sean gestionadas por él en lugar de enviarse a través de la red:

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

        assert_eq!(19, size);

        replay_client.assert_requests_match(&[]);

Cuando finaliza la llamada a, determine_prefix_file_size() se utiliza una afirmación para confirmar que el valor devuelto coincide con el valor esperado. A continuación, se llama a assert_requests_match() la función del StaticReplayClient método. Esta función escanea las solicitudes HTTP grabadas y confirma que todas coinciden con las especificadas en la matriz de ReplayEvent objetos proporcionada al crear el cliente de reproducción.