Tests unitaires en Python avec Sheepy

Bonjour à tous, aujourd'hui je suis venu vous présenter une nouvelle bibliothèque de tests unitaires appelée Sheepy, mais parlons d'abord de l'importance des tests unitaires. Cette bibliothèque n'est pas destinée aux débutants, pour faire des tests unitaires avec elle, vous devrez faire un peu plus attention. Il a des assertions uniquement pour les tests d'API avec des modules de vérification des points de terminaison et des erreurs http.

Lien Github : github
Lien PyPi : pypi

Tous les logiciels en production matures et qui se respectent disposent de tests unitaires, que ce soit pour savoir si ce qui était déjà dans le code continue de fonctionner, pour éviter des bugs déjà signalés et corrigés auparavant ou pour tester de nouvelles fonctionnalités, il C'est une bonne indication qu'ils avancent et qu'ils n'ont pas accumulé de dette technique. Prenons l'exemple du navigateur Firefox, chaque répertoire a un sous-répertoire tests, avec des tests spécifiques pour les bugs déjà signalés, de cette façon ils garantissent que les bugs corrigés n'apparaîtront plus de nulle part, les bugs déjà corrigés apparaissent de nulle part encore. Cela s'appelle jeter de l'argent par les fenêtres. Au fil du temps, vous perdez du temps, de l'argent, de l'efficacité et des parts de marché au profit d'un concurrent qui fait mieux que vous avec moins de ressources.

Tous ceux qui se sentent incapables de faire quelque chose essaient de diffamer cette chose, et les tests unitaires ne sont pas différents. Créer de meilleurs tests unitaires qui couvrent chaque cas d'utilisation prend du temps, comme tout dans la vie, votre backend, je doute que vous ayez lu un seul tutoriel et que vous ayez créé des API parfaites, la même chose pour votre front-end, je doute que vous ayez regardé un cours et que vous soyez venu en rendant les interfaces parfaites. Alors ne pensez pas qu'avec les tests unitaires, ce sera différent !

Méthodes d'assertion

+-----------------------+-------------------------------------------------------+
| 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. |
+-----------------------+-------------------------------------------------------+

Installation

Pour l'installer c'est très simple, il suffit d'ouvrir un terminal de votre choix, avec pip installé et de taper pip install Sheepy

Exemple d'utilisation

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 classe SheepyTestCase fournit plusieurs fonctionnalités pour créer et exécuter des tests unitaires, notamment des méthodes d'assertivité et des mécanismes pour configurer des comportements spéciaux, tels que sauter des tests ou gérer les échecs attendus.

Au sein de la classe SampleTest, cinq méthodes de test sont définies :

test_success : Ce test vérifie si l'expression passée à la méthode assertTrue est vraie. Puisque la valeur True est explicitement transmise, ce test réussira.

test_failure : Ce test vérifie l'égalité entre deux valeurs à l'aide de la méthode assertEqual. Cependant, les valeurs comparées 1 et 2 sont différentes, ce qui entraîne un échec du test. Cela démontre un cas d'échec attendu, où le test doit détecter l'incohérence.

test_error : Cette méthode lève une exception intentionnelle avec le message "Erreur forcée". L'objectif est de tester le comportement du système face aux erreurs survenues lors de l'exécution du test. Comme la méthode lève une exception sans la gérer, le résultat sera une erreur dans le test.

test_skipped : Ce test a été agrémenté de la méthode skip de la classe SheepyTestCase, ce qui signifie qu'il sera ignoré lors de l'exécution des tests. La raison pour laquelle le test a été ignoré a été fournie comme « Raison d'ignorer », et cette justification peut être affichée dans le rapport de test final.

test_expected_failure : Cette méthode utilise le décorateur ExpectFailure, indiquant qu'un échec est attendu. A l'intérieur de la méthode, il y a un contrôle d'égalité entre 1 et 2, qui entraînerait normalement un échec, mais comme le décorateur a été appliqué, le framework considère cet échec comme faisant partie du comportement attendu et ne sera pas traité comme une erreur, mais comme un "échec attendu".

Sortie

Résultats des tests :
ExempleTest.test_error : FAIL - Erreur forcée
ExempleTest.test_expected_failure : ÉCHEC PRÉVU
ExempleTest.test_failure : FAIL - 1 != 2
ExempleTest.test_skipped : SAUTÉ -
ExempleTest.test_success : OK

Cas de test API

Les tests d'API dans Sheepy Test Framework sont conçus pour être simples mais puissants, permettant aux testeurs d'interagir avec les API à l'aide de méthodes HTTP courantes telles que GET, POST, PUT et DELETE. Le framework fournit une classe dédiée, ApiRequests, pour simplifier l'envoi de requêtes et la gestion des réponses, avec une gestion intégrée des erreurs via la classe d'exception HttpError.

Lors du test d'une API, la classe de test hérite de SheepyTestCase, qui est équipée de diverses méthodes d'assertion pour vérifier le comportement de l'API. Ceux-ci incluent assertStatusCode pour valider les codes d'état HTTP, assertJsonResponse pour garantir que la réponse est au format JSON et assertResponseContains pour vérifier si des clés spécifiques existent dans le corps de la réponse.

For instance, the framework allows you to send a POST request to an API, verify that the status code matches the expected value, and assert that the JSON response contains the correct data. The API requests are handled through the ApiRequests class, which takes care of constructing and sending the requests, while error handling is streamlined by raising HTTP-specific errors when the server returns unexpected status codes.

By providing built-in assertions and error handling, the framework automates much of the repetitive tasks in API testing, ensuring both correctness and simplicity in writing tests. This system allows developers to focus on verifying API behavior and logic, making it an efficient tool for ensuring the reliability of API interactions.

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)  

Output example

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

Summary:

The new sheepy library is an incredible unit testing library, which has several test accession methods, including a module just for API testing, in my opinion, it is not a library for beginners, it requires basic knowledge of object-oriented programming such as methods, classes and inheritance.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!