Bild vom Autor | DALLE-3 & Canva
Das Testen von Software program ist entscheidend, um Zuverlässigkeit und Funktionalität in verschiedenen Szenarien sicherzustellen. Wenn die Codeimplementierung jedoch von externen Diensten abhängt, wird dies zu einer echten Herausforderung. Hier kommt Mocking ins Spiel. Die Mock-Bibliothek von Python bietet Instruments zum Erstellen von Mock-Objekten, die echte Objekte ersetzen, wodurch Ihre Exams einfacher zu warten sind. Mocking ermöglicht gezieltes Testen von Komponenten und schnellere Testzyklen.
Was ist Mocking?
Mocking ist eine Technik, die beim Softwaretesten verwendet wird, um reale Objekte zu simulieren. Reale Objekte werden durch Mock-Objekte ersetzt, um ihre Funktionalität zu simulieren. So können Sie Code in verschiedenen Szenarien und isoliert testen. Mocking ist besonders nützlich, um bestimmte Teile der Codebasis zu testen, ohne auf die Interaktion mit externen Systemen, Datenbanken oder anderen komplexen Diensten angewiesen zu sein.
Lassen Sie mich dieses Konzept anhand eines Beispiels erklären. Stellen Sie sich vor, Sie haben eine Webanwendung, die eine externe API zum Abrufen von Daten verwendet. Um zu testen, ohne von der echten API abhängig zu sein, können Sie ein Mock-Objekt erstellen, das die Antworten der API nachahmt. Auf diese Weise können Sie die Funktionalität Ihrer Anwendung testen, ohne von der echten API abhängig zu sein, die möglicherweise langsam, unzuverlässig oder während der Entwicklung nicht einmal verfügbar ist.
Klingt interessant, oder? Lassen Sie uns nun eine ausführliche Anleitung zur tatsächlichen Verwendung dieser Bibliothek durchgehen.
Schritt-für-Schritt-Anleitung zur Verwendung von Mock
Schritt 1: Importieren der Mock-Bibliothek
Der unittest.mock ist die Standardbibliothek in Python (3.3 und in allen neueren Versionen), die Mock-Objekte bereitstellt, um das Verhalten realer Objekte zu steuern. Zuerst müssen Sie die unittest.mock Bibliothek.
from unittest.mock import Mock, patchSchritt 2: Erstellen eines Mock-Objekts
Das Erstellen eines Mock-Objekts ist unkompliziert. Nach dem Import können Sie ein Mock-Objekt wie folgt instanziieren:
Jetzt, my_mock ist ein Mock-Objekt, das Sie so konfigurieren können, dass es das Verhalten eines realen Objekts simuliert.
Schritt 3: Rückgabewerte festlegen
Die Mock-Bibliothek bietet verschiedene Möglichkeiten, Mock-Objekte zu konfigurieren und ihr Verhalten zu steuern. Sie können beispielsweise angeben, was eine Methode beim Aufruf zurückgeben soll:
my_mock.some_method.return_value="Hi there, World!"
print(my_mock.some_method())
Ausgabe:
Schritt 4: Nebeneffekte festlegen
Nebeneffekte sind zusätzliche Aktionen oder Verhaltensweisen, die ausgelöst werden, wenn eine Methode eines Mock-Objekts aufgerufen wird, z. B. das Auslösen von Ausnahmen oder das Ausführen von Funktionen. Neben Rückgabewerten können Sie auch Attribute definieren oder Nebeneffekte wie folgt angeben:
def raise_exception():
elevate ValueError("An error occurred")
my_mock.some_method.side_effect = raise_exception
# This can elevate a ValueError
strive:
my_mock.some_method()
besides ValueError as e:
print(e) Ausgabe:
In diesem Beispiel ValueError erhöht, wann immer some_method() wird genannt.
Schritt 5: Aufrufe bestätigen
Die Überprüfung der Methodenaufrufe ist für gründliche Exams von entscheidender Bedeutung. Mithilfe von Assertionen können Sie angeben, ob eine Methode aufgerufen wurde, wann und mit welchen Argumenten.
my_mock.calculate_length('foo', 'bar')
my_mock.calculate_length.assert_called()
my_mock.calculate_length.assert_called_once()
my_mock.calculate_length.assert_called_with('foo', 'bar')
my_mock.calculate_length.assert_called_once_with('foo', 'bar')assert_called(): Gibt True zurück, wenn calculate_length mindestens einmal aufgerufen wurdeassert_called_once(): Gibt True zurück, wenn calculate_length genau einmal aufgerufen wurdeassert_called_with('foo', 'bar'): Gibt True zurück, wenn calculate_length mit den gleichen Argumenten aufgerufen wurdeassert_called_once_with('foo', 'bar'): Gibt True zurück, wenn calculate_length genau einmal mit den gleichen Argumenten aufgerufen wurde
Wenn eine dieser Behauptungen beim Mock-Objekt fehlschlägt, AssertionError wird ausgelöst, um anzuzeigen, dass das erwartete Verhalten nicht mit dem tatsächlichen Verhalten des Mocks übereinstimmt.
Schritt 6: Patch verwenden
Der patch Mit dieser Funktion können Sie während Exams echte Objekte durch simulierte Objekte ersetzen. Wie bereits erwähnt, ist dies besonders nützlich, um Bibliotheken oder APIs von Drittanbietern zu simulieren und sicherzustellen, dass Ihre Exams von tatsächlichen Implementierungen isoliert bleiben. Um das Patchen zu demonstrieren, betrachten Sie die folgende Beispielfunktion, die Daten von der URL abruft.
# my_module.py
import requests
def fetch_data(url):
response = requests.get(url)
return response.json()Sie können vermeiden, echte HTTP Anfragen, indem Sie „requests.get“ wie folgt patchen:
# test_my_module.py
import unittest
from unittest.mock import patch
import my_module
class TestFetchData(unittest.TestCase):
@patch('my_module.requests.get')
def test_fetch_data(self, mock_get):
# Arrange the mock to return a selected response
mock_get.return_value.json.return_value = {'key': 'worth'}
# Name the operate to check
outcome = my_module.fetch_data('http://instance.com')
# Examine the outcome
self.assertEqual(outcome, {'key': 'worth'})
# Confirm that requests.get was known as accurately
mock_get.assert_called_once_with('http://instance.com')
if __name__ == '__main__':
unittest.major()Der Patch-Dekorator wird direkt über dem test_fetch_data operate als Ersatz für die requests.get Funktion mit einem Mock.
Schritt 7: Mocking-Klassen
Sie können ganze Klassen und ihre Methoden simulieren, um Interaktionen zwischen Objekten zu simulieren. Sie können beispielsweise eine Datenbankklasse simulieren, um die Interaktion Ihrer Anwendung mit der Datenbank zu testen, ohne eine echte Datenbankverbindung wie folgt einrichten zu müssen:
# database.py
class Database:
def join(self):
go
def save_user(self, person):
go
def get_user(self, user_id):
go
# test_database.py
from unittest.mock import Mock
# Making a mock database object
mock_db = Mock(spec=Database)
# Simulating technique calls
mock_db.join()
mock_db.save_user({"id": 1, "title": "Alice"})
mock_db.get_user(1)
# Verifying that the strategies had been known as
mock_db.join.assert_called_once()
mock_db.save_user.assert_called_once_with({"id": 1, "title": "Alice"})
mock_db.get_user.assert_called_once_with(1)Einpacken
Das conflict’s für den heutigen Artikel über unittest.mockeine leistungsstarke Bibliothek zum Testen in Python. Sie ermöglicht Entwicklern das Testen von Code und stellt reibungslose Interaktionen zwischen Objekten sicher. Mit erweiterten Funktionen wie dem Festlegen von Nebeneffekten, dem Bestätigen von Aufrufen, dem Mocking von Klassen und der Verwendung von Kontextmanagern wird das Testen verschiedener Szenarien einfacher. Beginnen Sie noch heute mit der Verwendung von Mocks in Ihren Exams, um Code von höherer Qualität und reibungslosere Bereitstellungen sicherzustellen.
Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.