Unit-Tests in Python mit Sheepy

Hallo zusammen, heute bin ich gekommen, um euch eine neue Unit-Testing-Bibliothek namens Sheepy vorzustellen, 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, noch funktioniert, um Fehler zu verhindern, die bereits 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, dieses Etwas 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 ganz einfach: Öffnen Sie einfach ein Terminal Ihrer Wahl, auf dem pip installiert ist, und geben Sie pip install Sheepy ein

Anwendungsbeispiel

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“ zum Überprüfen von HTTP-Statuscodes, „assertJsonResponse“ zum Sicherstellen, dass die Antwort im JSON-Format vorliegt, und „asserResponseContains“ zum Überprüfen, ob bestimmte Schlüssel im Antworttext vorhanden sind.

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.

Das obige ist der detaillierte Inhalt vonUnit-Tests in Python mit Sheepy. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!