Hallo zusammen, heute möchte ich euch eine neue Unit-Testing-Bibliothek namens Sheepy vorstellen, aber lasst uns zunächst über die Bedeutung von Unit-Tests sprechen. Diese Bibliothek ist nichts für Anfänger. Um Unit-Tests damit durchzuführen, müssen Sie etwas mehr Aufmerksamkeit auf sich ziehen. Es verfügt nur über Zusicherungen für API-Tests mit Endpunkt- und HTTP-Fehlerprüfungsmodulen.

Github-Link: Github
PyPi-Link: pypi

Alle ausgereifte Software mit Selbstachtung in der Produktion verfügt über Unit-Tests, sei es, um ein Gefühl dafür zu bekommen, ob das, was bereits im Code enthalten war, weiterhin funktioniert, um Fehler zu verhindern, die bereits zuvor gemeldet und behoben wurden, oder um neue Funktionen zu testen ist ein gutes Zeichen dafür, dass die Dinge vorankommen und keine technischen Schulden angehäuft sind. Nehmen wir als Beispiel den Firefox-Browser. Jedes Verzeichnis verfügt über ein Unterverzeichnis „Tests“ mit spezifischen Tests für bereits gemeldete Fehler. Auf diese Weise wird sichergestellt, dass behobene Fehler nicht aus dem Nichts erneut auftauchen, sondern bereits behobene Fehler auftauchen wieder aus dem Nirgendwo. Man nennt es Geld wegwerfen. Mit der Zeit verlieren Sie Zeit, Geld, Effizienz und Marktanteile an einen Konkurrenten, der mit weniger Ressourcen besser abschneidet als Sie.

Jeder, der sich unfähig fühlt, etwas zu tun, versucht, diese Sache zu diffamieren, und bei Unit-Tests ist das nicht anders. Bessere Unit-Tests zu erstellen, die jeden Anwendungsfall abdecken, braucht Zeit, wie alles im Leben. Ich bezweifle, dass Sie als Backend nur ein Tutorial gelesen und perfekte APIs erstellt haben. Dasselbe gilt für Ihr Frontend. Ich bezweifle, dass Sie sich einen Kurs angesehen haben und gekommen sind darauf, Schnittstellen perfekt zu machen. Denken Sie also nicht, dass es bei Unit-Tests anders sein wird!

Behauptungsmethoden

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

Die Installation ist sehr einfach. Öffnen Sie einfach ein Terminal Ihrer Wahl, auf dem pip installiert ist, und geben Sie pip install Sheepy ein.

Verwendungsbeispiel

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)

Die SheepyTestCase-Klasse bietet mehrere Funktionalitäten zum Erstellen und Ausführen von Komponententests, einschließlich Durchsetzungsmethoden und Mechanismen zum Konfigurieren spezieller Verhaltensweisen, wie zum Beispiel das Überspringen von Tests oder die Behandlung erwarteter Fehler.

Innerhalb der Klasse „ExampleTest“ sind fünf Testmethoden definiert:

test_success: Dieser Test prüft, ob der an die AssertTrue-Methode übergebene Ausdruck wahr ist. Da der True-Wert explizit übergeben wird, ist dieser Test erfolgreich.

test_failure: Dieser Test prüft die Gleichheit zwischen zwei Werten mithilfe der Methode „assertenEqual“. Allerdings sind die verglichenen Werte 1 und 2 unterschiedlich, was zu einem Testfehler führt. Dies zeigt einen Fall eines erwarteten Fehlers, bei dem der Test die Inkonsistenz erkennen muss.

test_error: Diese Methode löst eine gezielte Ausnahme mit der Meldung „Erzwungener Fehler“ aus. Ziel ist es, das Verhalten des Systems im Umgang mit Fehlern zu testen, die während der Testausführung auftreten. Da die Methode eine Ausnahme auslöst, ohne sie zu behandeln, ist das Ergebnis ein Fehler im Test.

test_skipped: Dieser Test wurde mit der Skip-Methode der SheepyTestCase-Klasse versehen, was bedeutet, dass er beim Ausführen der Tests übersprungen wird. Als Grund für das Überspringen des Tests wurde „Grund zum Ignorieren“ angegeben und diese Begründung kann im abschließenden Testbericht angezeigt werden.

test_expected_failure: Diese Methode verwendet den ExpectedFailure-Dekorator, der angibt, dass ein Fehler erwartet wird. Innerhalb der Methode gibt es eine Gleichheitsprüfung zwischen 1 und 2, die normalerweise zu einem Fehler führen würde, aber da der Dekorator angewendet wurde, betrachtet das Framework diesen Fehler als Teil des erwarteten Verhaltens und wird nicht als Fehler behandelt, sondern als „erwarteter Fehler“.

Ausgabe

Testergebnisse:
BeispielTest.test_error: FAIL – Erzwungener Fehler
BeispielTest.test_expected_failure: ERWARTETER FEHLER
BeispielTest.test_failure: FAIL - 1 != 2
BeispielTest.test_skipped: SKIPPED -
BeispielTest.test_success: OK

API-Testfall

API-Tests im Sheepy Test Framework sind unkompliziert und dennoch leistungsstark konzipiert und ermöglichen Testern die Interaktion mit APIs mithilfe gängiger HTTP-Methoden wie GET, POST, PUT und DELETE. Das Framework bietet eine dedizierte Klasse, ApiRequests, um das Senden von Anfragen und die Bearbeitung von Antworten zu vereinfachen, mit integrierter Fehlerverwaltung über die HttpError-Ausnahmeklasse.

Beim Testen einer API erbt die Testklasse von SheepyTestCase, das mit verschiedenen Assertionsmethoden ausgestattet ist, um das Verhalten der API zu überprüfen. Dazu gehören „asserStatusCode“, um HTTP-Statuscodes zu validieren, „assertJsonResponse“, um sicherzustellen, dass die Antwort im JSON-Format vorliegt, und „asserResponseContains“, um zu überprüfen, ob bestimmte Schlüssel im Antworttext vorhanden sind.

Mit dem Framework können Sie beispielsweise eine POST-Anfrage an eine API senden, überprüfen, ob der Statuscode mit dem erwarteten Wert übereinstimmt, und sicherstellen, dass die JSON-Antwort die richtigen Daten enthält. Die API-Anfragen werden über die ApiRequests-Klasse verarbeitet, die sich um die Erstellung und das Senden der Anfragen kümmert, während die Fehlerbehandlung optimiert wird, indem HTTP-spezifische Fehler ausgelöst werden, wenn der Server unerwartete Statuscodes zurückgibt.

Durch die Bereitstellung integrierter Behauptungen und Fehlerbehandlung automatisiert das Framework einen Großteil der sich wiederholenden Aufgaben beim API-Testen und gewährleistet so sowohl Korrektheit als auch Einfachheit beim Schreiben von Tests. Dieses System ermöglicht es Entwicklern, sich auf die Überprüfung des API-Verhaltens und der API-Logik zu konzentrieren, was es zu einem effizienten Werkzeug zur Gewährleistung der Zuverlässigkeit von API-Interaktionen macht.

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)  

Ausgabebeispiel

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

Zusammenfassung:

Die neue Sheepy-Bibliothek ist eine unglaubliche Unit-Testing-Bibliothek, die über mehrere Testzugriffsmethoden verfügt, darunter ein Modul nur für API-Tests. Meiner Meinung nach ist sie keine Bibliothek für Anfänger, sie erfordert Grundkenntnisse der objektorientierten Programmierung wie Methoden, Klassen und Vererbung.