Hola a todos, hoy vine a presentarles una nueva biblioteca de pruebas unitarias llamada Sheepy, pero primero hablemos de la importancia de las pruebas unitarias. Esta biblioteca no es para principiantes; para realizar pruebas unitarias con ella deberá prestar un poco más de atención. Tiene afirmaciones solo para pruebas de API con módulos de verificación de errores de punto final y http.

Enlace de Github: github
Enlace PyPi: pypi

Todo software maduro y que se precie en producción tiene pruebas unitarias, ya sea para tener una idea de si lo que ya estaba en el código sigue funcionando, para evitar errores que ya se han informado y corregido antes o para probar nuevas funciones, Es un buen indicativo de que las cosas van avanzando y no habiendo acumulado deuda técnica. Usemos el navegador Firefox como ejemplo, cada directorio tiene un subdirectorio de pruebas, con pruebas específicas para errores que ya han sido reportados, de esta manera garantizan que los errores arreglados no volverán a aparecer de la nada, los errores que ya fueron arreglados aparecen De la nada otra vez. Se llama tirar dinero. Con el tiempo, estás perdiendo tiempo, dinero, eficiencia y participación de mercado frente a un competidor que lo está haciendo mejor que tú con menos recursos.

Todo el que se siente incapaz de hacer algo intenta difamar ese algo, y las pruebas unitarias no son diferentes. Crear mejores pruebas unitarias que cubran cada caso de uso lleva tiempo, como todo en la vida, tu backend. Dudo que hayas leído solo un tutorial y hayas creado API perfectas, lo mismo para tu front-end, dudo que hayas visto un curso y hayas llegado. perfeccionar las interfaces. ¡Así que no creas que con las pruebas unitarias será diferente!

Métodos de afirmación

 ----------------------- ------------------------------------------------------- 
| Assertion Method       | Description                                           |
 ----------------------- ------------------------------------------------------- 
| assertEqual(a, b)      | Checks if two values are equal.                       |
| assertNotEqual(a, b)   | Checks if two values are not equal.                   |
| assertTrue(expr)       | Verifies that the expression is True.                 |
| assertFalse(expr)      | Verifies that the expression is False.                |
| assertRaises(exc, fn)  | Asserts that a function raises a specific exception.  |
| assertStatusCode(resp) | Verifies if the response has the expected status code.|
| assertJsonResponse(resp)| Confirms the response is in JSON format.             |
| assertResponseContains(resp, key) | Ensures the response contains a given key. |
 ----------------------- ------------------------------------------------------- 

Instalación

Para instalarlo es muy sencillo, simplemente abre una terminal de tu elección, con pip instalado y escribe pip install shey

Ejemplo de uso

from sheepy.sheeptest import SheepyTestCase

class ExampleTest(SheepyTestCase):
    def test_success(self):
        self.assertTrue(True)

    def test_failure(self):
        self.assertEqual(1, 2)

    def test_error(self):
        raise Exception("Forced error")

    @SheepyTestCase.skip("Reason to ignore")
    def test_skipped(self):
        pass

    @SheepyTestCase.expectedFailure
    def test_expected_failure(self):
        self.assertEqual(1, 2)

La clase SheepyTestCase proporciona varias funcionalidades para crear y ejecutar pruebas unitarias, incluidos métodos de asertividad y mecanismos para configurar comportamientos especiales, como omitir pruebas o manejar fallas esperadas.

Dentro de la clase EjemploTest, se definen cinco métodos de prueba:

test_success: esta prueba verifica si la expresión pasada al método afirmarTrue es verdadera. Dado que el valor Verdadero se pasa explícitamente, esta prueba será exitosa.

test_failure: Esta prueba verifica la igualdad entre dos valores usando el método afirmarEqual. Sin embargo, los valores comparados, 1 y 2, son diferentes, lo que resulta en una prueba fallida. Esto demuestra un caso de falla esperada, donde la prueba debe detectar la inconsistencia.

test_error: este método genera una excepción intencionada con el mensaje "Error forzado". El objetivo es probar el comportamiento del sistema cuando se trata de errores que ocurren durante la ejecución de la prueba. Como el método arroja una excepción sin manejarla, el resultado será un error en la prueba.

test_skipped: Esta prueba ha sido decorada con el método skip de la clase SheepyTestCase, lo que significa que se omitirá mientras se ejecutan las pruebas. El motivo para omitir la prueba se proporcionó como "Motivo para ignorar" y esta justificación se puede mostrar en el informe final de la prueba.

test_expected_failure: este método utiliza el decorador expectedFailure, que indica que se espera una falla. Dentro del método, hay una verificación de igualdad entre 1 y 2, que normalmente resultaría en un error, pero como se aplicó el decorador, el marco considera que este error es parte del comportamiento esperado y no será tratado como un error, sino como un "fracaso esperado".

Producción

Resultados de la prueba:
EjemploTest.test_error: FAIL - Error forzado
EjemploTest.test_expected_failure: FALLO ESPERADO
EjemploTest.test_failure: FALLO - 1! = 2
EjemploTest.test_skipped: SALTADO -
EjemploTest.test_success: OK

Caso de prueba de API

Las pruebas de API en Sheepy Test Framework están diseñadas para ser sencillas pero poderosas, lo que permite a los evaluadores interactuar con las API utilizando métodos HTTP comunes como GET, POST, PUT y DELETE. El marco proporciona una clase dedicada, ApiRequests, para simplificar el envío de solicitudes y el manejo de respuestas, con gestión de errores incorporada a través de la clase de excepción HttpError.

Al probar una API, la clase de prueba hereda de SheepyTestCase, que está equipada con varios métodos de aserción para verificar el comportamiento de la API. Estos incluyen afirmarStatusCode para validar códigos de estado HTTP, afirmarJsonResponse para garantizar que la respuesta esté en formato JSON y afirmarResponseContains para comprobar si existen claves específicas en el cuerpo de la respuesta.

Por ejemplo, el marco le permite enviar una solicitud POST a una API, verificar que el código de estado coincida con el valor esperado y afirmar que la respuesta JSON contiene los datos correctos. Las solicitudes de API se manejan a través de la clase ApiRequests, que se encarga de construir y enviar las solicitudes, mientras que el manejo de errores se agiliza generando errores específicos de HTTP cuando el servidor devuelve códigos de estado inesperados.

Al proporcionar aserciones integradas y manejo de errores, el marco automatiza gran parte de las tareas repetitivas en las pruebas de API, lo que garantiza tanto la corrección como la simplicidad al escribir pruebas. Este sistema permite a los desarrolladores centrarse en verificar el comportamiento y la lógica de la API, lo que lo convierte en una herramienta eficiente para garantizar la confiabilidad de las interacciones de la API.

from sheepy.sheeptest import SheepyTestCase  

class TestHttpBinApi(SheepyTestCase):
    def __init__(self):

        super().__init__(base_url="https://httpbin.org")

    def test_get_status(self):

        response = self.api.get("/status/200")
        self.assertStatusCode(response, 200)  

    def test_get_json(self):

        response = self.api.get("/json")
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "slideshow")  

    def test_post_data(self):

        payload = {"name": "SheepyTest", "framework": "unittest"}
        response = self.api.post("/post", json=payload)
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "json") 
        self.assertEqual(response.json()["json"], payload)  

    def test_put_data(self):

        payload = {"key": "value"}
        response = self.api.put("/put", json=payload)
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "json")  
        self.assertEqual(response.json()["json"], payload)  

    def test_delete_resource(self):

        response = self.api.delete("/delete")
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  

Ejemplo de salida

Test Results:
TestHttpBinApi.test_delete_resource: OK
TestHttpBinApi.test_get_json: OK
TestHttpBinApi.test_get_status: OK
TestHttpBinApi.test_post_data: OK
TestHttpBinApi.test_put_data: OK

Resumen:

La nueva biblioteca Sheepy es una increíble biblioteca de pruebas unitarias, que tiene varios métodos de acceso a pruebas, incluido un módulo solo para pruebas de API, en mi opinión, no es una biblioteca para principiantes, requiere conocimientos básicos de programación orientada a objetos. como métodos, clases y herencia.