Waarom zijn droge tests beter dan het gebruik van…

Mocks-testen maken het mogelijk om de geteste component te isoleren, zonder afhankelijk te zijn van de beschikbaarheid of werking van externe diensten. Dit zorgt voor stabiliteit en reproduceerbaarheid van tests, versnelt de uitvoering van testscenario's en vereenvoudigt het identificeren van fouten die direct verband houden met de geteste logica.

Postman, zelfs met mocks, test de interactie met externe afhankelijkheden op request/response-niveau en integreert mocks niet direct in de testcode of de component zelf. Dit is minder granular en moeilijker te automatiseren in CI/CD-pijplijnen.

Voordelen van mock-tests ten opzichte van Postman voor geautomatiseerde tests:

Isolatie: Alleen de code wordt getest, niet de integratie met externe systemen.
Stabiliteit: Tests falen niet door problemen met externe services.
Snelheid: Snelle uitvoering van tests zonder te wachten op antwoorden van echte services.
Granulariteit: Mogelijkheid om afzonderlijke methoden of functies binnen de code te mocken.
Automatisering: Eenvoudig te integreren in unit- en integratietests die automatisch worden uitgevoerd.
Testen van randgevallen: Gemakkelijk verschillende scenario's van afhankelijkheidsantwoorden te simuleren (fouten, vertragingen, niet-standaardgegevens).

Voorbeeld van mock-gebruik in Java (Mockito):

// Maak een mock voor de afhankelijkheid
ExternalService mockService = mock(ExternalService.class);

// Configureer het gedrag van de mock bij het aanroepen van een specifieke methode
when(mockService.getData(anyString())).thenReturn("gemockte data");

// Test de component met de mock
Processor processor = new Processor(mockService);
String result = processor.process("input");

// Controleer het resultaat
assertEquals("verwerkt gemockte data", result);

// Controleer of de mock-methode is aangeroepen
verify(mockService).getData("input");

Voorbeeld van mock-gebruik in Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulatie van een externe service-aanroep
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"verwerkt {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):
  # Configureer de return-waarde van de mock
  mock_get_data.return_value = "gemockte data"

  # Roep de geteste functie aan die de mock gebruikt
  result = process_data("some_id")

  # Controleer het resultaat
  self.assertEqual(result, "verwerkt gemockte data")

  # Controleer of de mock met het verwachte argument is aangeroepen
  mock_get_data.assert_called_once_with("some_id")

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

Postman is meer geschikt voor handmatig testen van API's, exploratief testen of het maken van demonstratietests. Voor geautomatiseerde tests binnen CI/CD zijn code-gebaseerde mock-tests de voorkeur.

Waarom zijn droge tests beter dan het gebruik van Postman?