Warum sind Trocken-Tests besser als die Verwendung…

Mock-Tests ermöglichen es, die getestete Komponente zu isolieren, ohne von der Verfügbarkeit oder Funktionalität externer Dienste abhängig zu sein. Dies gewährleistet Stabilität und Reproduzierbarkeit der Tests, beschleunigt die Ausführung der Testszenarien und vereinfacht die Fehlererkennung, die direkt mit der getesteten Logik zusammenhängt.

Postman testet, auch wenn Mocks verwendet werden, die Interaktion mit externen Abhängigkeiten auf Anfrage/Antwort-Ebene und integriert Mocks nicht direkt in den Testcode oder die Komponente selbst. Dies ist weniger granular und schwieriger in CI/CD-Pipelines zu automatisieren.

Vorteile von Mock-Tests gegenüber Postman bei automatisierten Tests:

Isolation: Es wird nur der Code getestet, nicht die Integration mit externen Systemen.
Stabilität: Tests schlagen nicht wegen Problemen mit externen Diensten fehl.
Geschwindigkeit: Schnelle Ausführung der Tests ohne Warten auf Antworten von echten Diensten.
Granularität: Möglichkeit, einzelne Methoden oder Funktionen im Code zu mocken.
Automatisierung: Leicht in Unit- und Integrationstests integrierbar, die automatisch ausgeführt werden.
Testen von Extremfällen: Einfachheit, verschiedene Szenarien von Abhängigkeitsantworten zu simulieren (Fehler, Verzögerungen, nicht-standardisierte Daten).

Beispiel für die Verwendung von Mocks in Java (Mockito):

// Erstellen eines Mocks für die Abhängigkeit
ExternalService mockService = mock(ExternalService.class);

// Verhalten des Mocks bei Aufruf einer bestimmten Methode konfigurieren
when(mockService.getData(anyString())).thenReturn("mocked data");

// Komponente testen, die den Mock verwendet
Processor processor = new Processor(mockService);
String result = processor.process("input");

// Ergebnis überprüfen
assertEquals("processed mocked data", result);

// Überprüfen, ob die Mock-Methode aufgerufen wurde
verify(mockService).getData("input");

Beispiel für die Verwendung von Mocks in Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulation eines externen Dienstaufrufs
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"processed {data}"

# test_mock_example.py
import unittest
from unittest.mock import patch
from . mock_example import process_data

class TestProcessData(unittest.TestCase):
  @patch('mock_example.get_data_from_external_service')
  def test_process_data_with_mock(self, mock_get_data):
  # Mock-Rückgabewert konfigurieren
  mock_get_data.return_value = "mocked data"

  # Aufruf der zu testenden Funktion, die den Mock verwendet
  result = process_data("some_id")

  # Ergebnis überprüfen
  self.assertEqual(result, "processed mocked data")

  # Überprüfen, ob der Mock mit dem erwarteten Argument aufgerufen wurde
  mock_get_data.assert_called_once_with("some_id")

if __name__ == '__main__':
  unittest.main()

Postman eignet sich eher für manuelle API-Tests, explorative Tests oder die Erstellung von Demonstrationsanfragen. Für automatisierte Tests im Rahmen von CI/CD sind Code-Mocks in der Regel vorzuziehen.

Warum sind Trocken-Tests besser als die Verwendung von Postman?