Einführung in das Mocking in Python

Mocking ist eine Bibliothek zum Testen in Python. Es ermöglicht Ihnen, Teile Ihres zu testenden Systems durch Scheinobjekte zu ersetzen und Aussagen über deren Verwendung zu treffen. In diesem Lernprogramm wird detailliert beschrieben, was als Mocking gilt und wie es in Python-Anwendungen verwendet wird.

Was ist ein Spott?

Mocking ist eine Bibliothek zum Testen in Python, mit der Sie Teile des getesteten Systems durch Mock-Objekte ersetzen und Assertions über deren Verwendung machen können.

In Python wird das Spottmachen durch Ersetzen von Teilen Ihres Systems durch Pseudoobjekte mithilfe des Moduls unittest.mock ausgeführt. Dieses Modul enthält eine Reihe nützlicher Klassen und Funktionen, nämlich die Patch-Funktion (als Dekorator und Kontextmanager) und die MagicMock-Klasse. Diese beiden Komponenten sind sehr wichtig, um in Python Spaß zu haben.

Ein Mock-Funktionsaufruf gibt normalerweise sofort einen vordefinierten Wert zurück. Die Attribute und Methoden eines Scheinobjekts werden auch im Test definiert, ohne dass das reale Objekt erstellt wird.

Beim Mocking können Sie beim Schreiben von Tests auch vordefinierte Werte für jeden Funktionsaufruf zurückgeben. Dadurch haben Sie beim Testen mehr Kontrolle.

Voraussetzungen

Mock ist in Python 3 verfügbar, wenn Sie jedoch eine Python-Version verwenden
3.3 können Sie noch verwenden unittest.mock indem Sie es als separate Bibliothek importieren.

$ pip installieren Mock

Vorteile des Spottens

Zu den Vorteilen von Spott gehören:

Zu viele Abhängigkeiten vermeiden. Spott reduziert die Abhängigkeit von Funktionen. Wenn Sie beispielsweise über eine Funktion-A-Klasse verfügen, die von einer Funktion B abhängt, müssen Sie einige Unit-Tests schreiben, die die von Funktion B bereitgestellten Funktionen abdecken. Nehmen wir an, der Code wächst in der Zukunft und Sie haben mehr Funktionen, dh A hängt davon ab B, B hängt von C ab und C von D. Wenn in Z ein Fehler auftritt, schlagen alle Gerätetests fehl.
Reduzierte Überlastung. Dies gilt für ressourcenintensive Funktionen. Ein Mock dieser Funktion würde den unnötigen Ressourcenverbrauch während des Testens reduzieren und somit die Testlaufzeit reduzieren.
Zeiteinschränkungen in Funktionen umgehen. Dies gilt für geplante Aktivitäten. Stellen Sie sich einen Prozess vor, der stündlich ausgeführt werden soll. Wenn Sie die Zeitquelle verspotten, können Sie diese Logik tatsächlich testen, damit der Test nicht stundenlang ablaufen muss und warten muss, bis die Zeit abgelaufen ist.

Verwendungszweck

Benutzung von spotten ist einfach als:

>>> aus dem Mock-Import Mock >>> Mock = Mock (return_values = 10) >>> Mock (1,4, foo = 'bar')  >>> mock.return_values 10

Hier importieren wir das Mock-Modul, erstellen ein Mock-Objekt und geben Rückgabewerte an. Wenn das Scheinobjekt aufgerufen wird, möchten wir, dass es einige Werte zurückgeben kann. In unserem Fall soll das Scheinobjekt einen Wert von 10 zurückgeben. Wenn wir das Scheinobjekt mit den Argumenten aufrufen (1, 4, foo = "bar"), Das Ergebnis ist der Wert 10, der als Rückgabewert definiert wurde.

Sie können Ausnahmen auch wie folgt in Mocks auslösen:

>>> mock = Mock (side_effect = KeyError ('foobar')) >>> mock () Traceback (letzter Aufruf zuletzt):… KeyError: 'foobar'

Das Nebenwirkungen Mit dem Argument können Sie bestimmte Dinge ausführen, z. B. eine Ausnahme auslösen, wenn ein Mock aufgerufen wird.

Beispiel

Betrachten Sie diese einfache Funktion:

Importanforderungen def api (): antwort = request.get ("https://www.google.com/"), Antwort zurückgeben

Diese Funktion führt eine API-Anforderung an die Google-Website aus und gibt eine Antwort zurück.

Der entsprechende einfache Testfall lautet wie folgt:

Importiere unittest aus der Hauptimport-API-Klasse TetsApi (unittest.TestCase): def test_api (self): assert api () == 200

Das Ausführen des obigen Tests sollte eine Ausgabe wie folgt ergeben:

---------------------------------------------------------------------- Lief 1 Test in 3.997s OK

Im Folgenden wird das Mocking an diesem Beispiel vorgestellt. Der resultierende Test mit dem Mock-Modul wird wie folgt gezeigt:

unittest aus mock import import import import import import import import import import import unittest class TetsApi (unittest.TestCase): def test_api (self): mit patch.object (request, 'get') als get_mock: get_mock.return_value = mock_response = Mock ( ) mock_response.status_code = 200 assert api () == 200

Das Ausführen des obigen Tests sollte eine Ausgabe wie folgt ergeben:

---------------------------------------------------------------------- Lief 1 Test in 0,001s OK

Wie oben zu sehen, benötigt das Mocking-Modul weniger Zeit, um denselben API-Aufruf wie der normale Testfall durchzuführen.

Größeres Beispiel

Nehmen wir an, Sie haben ein Skript, das mit einer externen API interagiert und diese API aufruft, wenn eine bestimmte Funktion aufgerufen wird. In diesem Beispiel verwenden wir die Twitter-API, um ein Python-Skript zu implementieren, das auf der Twitter-Profilseite veröffentlicht wird.

Wir möchten nicht jedes Mal, wenn wir das Skript testen, Nachrichten auf Twitter veröffentlichen, und da kommt Mocking ins Spiel.

Lass uns anfangen. Wir werden die Python-Twitter-Bibliothek verwenden, und als erstes erstellen wir einen Ordner python_mock und innerhalb des Ordners zwei Dateien erstellen, nämlich tweet.py und mock_test.py.

Schreiben Sie den folgenden Code in die Datei tweet.py.

# Pip installieren Python-Mail import Mail # Authentifizierungs-Credentials consumer_key = 'iYD2sKY4NC8teRb9BUM8UguRa' consumer_secret = 'uW3tHdH6UAqlxA7yxmcr8FSMSzQIBIpcC4NNS7jrvkxREdJ15m' access_token_key = '314.746.354-Ucq36TRDnfGAxpOVtnK1qZxMfRKzFHFhyRqzNpTx7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' access_token_secret = '7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' def post_tweet (api, tweet) definieren: # Beitrag tweet status = api.PostUpdate (tweet) return status def main (): api = twitter.Api (consumer_key = consumer_key, consumer_secret = consumer_secret, access_token_key = access_token_key, access_token_secret = access_token_secret) message = raw_input ("Geben Sie Ihren Tweet ein:") __name__ == '__main__': main ()

Im obigen Code importieren wir zunächst die Twitter-Bibliothek und definieren dann die Anmeldeinformationen, die Sie leicht von der Twitter-Apps-Seite abrufen können.

Die Twitter-API wird über die twitter.Api Klasse, also erstellen wir die Klasse, indem wir unsere Token und geheimen Schlüssel übergeben.

Das post_tweet function nimmt ein Authentifizierungsobjekt und die Nachricht auf und sendet den Tweet im Twitter-Profil.

Anschließend machen wir den API-Aufruf an Twitter nach, damit die API nicht bei jedem Aufruf gepostet wird. Mach weiter und öffne die mock_test.py Datei und fügen Sie den folgenden Code hinzu.

# mock_test.py #! / usr / bin / env python importieren unittest von mock import Mock-Import-Tweet-Klasse TweetTest (unittest.TestCase): def test_example (self): mock_twitter = Mock () tweet.post_tweet ("tock_twitter", "Aufgabe erstellen" Manager-App mit Ionic: Teil 1 ") mock_twitter.PostUpdate.assert_called_with (" Erstellen einer Task-Manager-App mit Ionic: Teil 1 "), wenn __name__ == '__main__': unittest.main ()

Das Ausführen des obigen Tests sollte eine Ausgabe wie folgt ergeben:

---------------------------------------------------------------------- Lief 1 Test in 0,001s OK

Fazit

In diesem Lernprogramm wurden die meisten Grundlagen des Mockings und die Verwendung des Mockings zum Ausführen externer API-Aufrufe behandelt. Weitere Informationen finden Sie in der offiziellen Python-Dokumentation. In diesem Lernprogramm finden Sie auch weitere Ressourcen zur Authentifizierung mit der Twitter-API.

Zögern Sie nicht, zu sehen, was wir zum Verkauf anbieten und um auf dem Envato-Markt zu studieren. Bitte stellen Sie Ihre Fragen und stellen Sie Ihr wertvolles Feedback mithilfe des folgenden Feeds.

Code