Escribe pruebas con un cliente simulado

Aprende a crear código auxiliar para implementaciones de clientes reales para insertar un objeto simulado para las prueba de unidades. Usar un cliente simulado con las Google Cloud bibliotecas cliente de Rust te permite escribir pruebas de unidades controladas y confiables que no realizan llamadas de red ni generan cargos de facturación.

Dependencias

Hay varios frameworks de simulación disponibles para Rust. En esta guía, se usa mockall. Agrégalo como una dependencia de desarrollo:

cargo add --dev mockall

Además, en esta guía, se usa el Speech cliente para que los ejemplos sean más fáciles de seguir (pero estos conceptos se aplican a todos los clientes).

Agrega las dependencias requeridas a tu archivo Cargo.toml:

cargo add google-cloud-speech-v2 google-cloud-lro

Simula un cliente

Para probar tu código con un cliente simulado, define una estructura simulada, configura su comportamiento esperado para tu situación de prueba y, luego, inserta esa simulación en la lógica de tu aplicación. En el siguiente ejemplo, se muestra este flujo de trabajo.

Primero, agrega instrucciones use para simplificar el código:

use google_cloud_gax as gax;
use google_cloud_speech_v2 as speech;

Supongamos que la aplicación tiene una función que usa el cliente Speech para llamar a GetRecognizer, configurar el campo name de la solicitud y procesar la respuesta del servidor.

// An example application function.
//
// It makes an RPC, setting some field. In this case, it is the `GetRecognizer`
// RPC, setting the name field.
//
// It processes the response from the server. In this case, it extracts the
// display name of the recognizer.
async fn my_application_function(client: &speech::client::Speech) -> gax::Result<String> {
    client
        .get_recognizer()
        .set_name("invalid-test-recognizer")
        .send()
        .await
        .map(|r| r.display_name)
}

Puedes probar cómo la aplicación controla diferentes respuestas del servicio.

Luego, define la estructura simulada. Esta estructura implementa el speech::stub::Speech rasgo.

mockall::mock! {
    #[derive(Debug)]
    Speech {}
    impl speech::stub::Speech for Speech {
        async fn get_recognizer(&self, req: speech::model::GetRecognizerRequest, _options: gax::options::RequestOptions) -> gax::Result<gax::response::Response<speech::model::Recognizer>>;
    }
}

Crea una instancia de la simulación. Ten en cuenta que la mockall::mock! macro antepone un Mock prefijo al nombre de la estructura definida anteriormente.

let mut mock = MockSpeech::new();

Establece expectativas sobre la simulación. Por ejemplo, espera que el código llame a GetRecognizer con un nombre en particular y simule una respuesta exitosa del servicio.

mock.expect_get_recognizer()
    .withf(move |r, _|
        // Optionally, verify fields in the request.
        r.name == "invalid-test-recognizer")
    .return_once(|_, _| {
        Ok(gax::response::Response::from(
            speech::model::Recognizer::new().set_display_name("test-display-name"),
        ))
    });

Crea un cliente Speech con la simulación:

let client = speech::client::Speech::from_stub(mock);

Llama a la función:

let display_name = my_application_function(&client).await?;

Verifica los resultados:

assert_eq!(display_name, "test-display-name");

Simula errores

Simular errores es similar a simular éxitos. Para simular un error, modifica el resultado que muestra la simulación.

mock.expect_get_recognizer().return_once(|_, _| {
    // This time, return an error.
    use gax::error::Error;
    use gax::error::rpc::{Code, Status};
    let status = Status::default()
        .set_code(Code::NotFound)
        .set_message("Resource not found");
    Err(Error::service(status))
});

Un cliente compilado con from_stub() no tiene un bucle de reintento interno; muestra todos los errores del código auxiliar directamente a la aplicación.

Próximos pasos

Para ver el código completo de esta guía, consulta el archivo fuente en el google-cloud-rust repositorio en GitHub.