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 n'a d'affirmations que 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 matures et qui se respectent en production 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.

Quiconque se sent incapable de faire quelque chose essaie 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, y compris 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 transmise à 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é décoré avec 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".

Sortir

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.

Par exemple, le framework vous permet d'envoyer une requête POST à ​​une API, de vérifier que le code d'état correspond à la valeur attendue et d'affirmer que la réponse JSON contient les données correctes. Les requêtes API sont gérées via la classe ApiRequests, qui se charge de construire et d'envoyer les requêtes, tandis que la gestion des erreurs est rationalisée en générant des erreurs spécifiques à HTTP lorsque le serveur renvoie des codes d'état inattendus.

En fournissant des assertions intégrées et une gestion des erreurs, le framework automatise une grande partie des tâches répétitives dans les tests d'API, garantissant à la fois l'exactitude et la simplicité de l'écriture des tests. Ce système permet aux développeurs de se concentrer sur la vérification du comportement et de la logique de l'API, ce qui en fait un outil efficace pour garantir la fiabilité des interactions 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)  

Exemple de sortie

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

Résumé:

La nouvelle bibliothèque Sheepy est une incroyable bibliothèque de tests unitaires, qui dispose de plusieurs méthodes d'adhésion aux tests, y compris un module uniquement pour les tests d'API, à mon avis, ce n'est pas une bibliothèque pour les débutants, elle nécessite des connaissances de base en programmation orientée objet tels que les méthodes, les classes et l'héritage.