Dlaczego testy na sucho są lepsze niż korzystanie z…

Testy z użyciem mocków pozwalają na izolację testowanego komponentu, nie zależąc od dostępności lub działania zewnętrznych usług. Zapewnia to stabilność i powtarzalność testów, przyspiesza wykonywanie scenariuszy testowych i upraszcza wykrywanie błędów bezpośrednio związanych z testowaną logiką.

Postman, nawet używając mocków, testuje interakcję z zależnościami zewnętrznymi na poziomie żądań/odpowiedzi, a nie integruje mocków bezpośrednio w kodzie testowym lub samym komponencie. Jest to mniej granularne i trudniejsze do automatyzacji w pipeline'ach CI/CD.

Zalety testów z mockami w porównaniu do Postmana dla testów automatycznych:

Izolacja: Testowany jest tylko kod, a nie integracja z systemami zewnętrznymi.
Stabilność: Testy nie zawalają się z powodu problemów z usługami zewnętrznymi.
Szybkość: Szybkie wykonanie testów bez oczekiwania na odpowiedzi od rzeczywistych usług.
Granularność: Możliwość mockowania poszczególnych metod lub funkcji w kodzie.
Automatyzacja: Łatwo integruje się z testami jednostkowymi i integracyjnymi uruchamianymi automatycznie.
Testowanie skrajnych przypadków: Łatwość symulacji różnych scenariuszy odpowiedzi zależności (błędy, opóźnienia, nietypowe dane).

Przykład użycia mock w Java (Mockito):

// Tworzymy mock dla zależności
ExternalService mockService = mock(ExternalService.class);

// Konfigurujemy zachowanie mocka przy wywołaniu określonej metody
when(mockService.getData(anyString())).thenReturn("mockowane dane");

// Testujemy komponent, używając mocka
Processor processor = new Processor(mockService);
String result = processor.process("input");

// Sprawdzamy wynik
assertEquals("przetworzono mockowane dane", result);

// Sprawdzamy, czy metoda mocka została wywołana
verify(mockService).getData("input");

Przykład użycia mock w Pythonie (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Symulacja wywołania zewnętrznego serwisu
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"przetworzono {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):
  # Konfigurujemy wartość zwracaną mocka
  mock_get_data.return_value = "mockowane dane"

  # Wywołujemy testowaną funkcję, która używa mocka
  result = process_data("some_id")

  # Sprawdzamy wynik
  self.assertEqual(result, "przetworzono mockowane dane")

  # Sprawdzamy, czy mock został wywołany z oczekiwanym argumentem
  mock_get_data.assert_called_once_with("some_id")

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

Postman jest bardziej odpowiedni do ręcznego testowania API, testów eksploracyjnych lub tworzenia zapytań demonstracyjnych. Do automatycznych testów w ramach CI/CD preferowane są testy z mockami na poziomie kodu.

Dlaczego testy na sucho są lepsze niż korzystanie z Postmana?