De ce testele uscate sunt mai bune decât utilizarea…

Testele cu mock-uri permit izolarea componentului testat, fără a depinde de disponibilitatea sau funcționarea serviciilor externe. Acest lucru asigură stabilitatea și reproductibilitatea testelor, accelerează executarea scenariilor de testare și simplifică identificarea erorilor direct legate de logica testată.

Postman, chiar și utilizând mock-uri, testează interacțiunea cu dependențele externe la nivel de solicitare/răspuns și nu integrează mock-urile direct în codul de test sau în componenta însăși. Acest lucru este mai puțin granular și mai dificil de automatizat în pipeline-urile CI/CD.

Avantajele testelor cu mock-uri față de Postman pentru testele automatizate:

Izolare: Se testează doar codul, nu integrarea cu sistemele externe.
Stabilitate: Testele nu eșuează din cauza problemelor cu serviciile externe.
Viteză: Executarea rapidă a testelor fără a aștepta răspunsuri de la servicii reale.
Granularitate: Posibilitatea de a mock-ui metode sau funcții specifice din cod.
Automatizare: Se integrează ușor în testele unitare și de integrare care rulează automat.
Testarea cazurilor extreme: Ușurință în simularea diferitelor scenarii de răspunsuri ale dependențelor (erori, întârzieri, date non-standard).

Exemplu de utilizare a mock-urilor în Java (Mockito):

// Creăm un mock pentru dependență
ExternalService mockService = mock(ExternalService.class);

// Configurăm comportamentul mock-ului la apelarea unei metode specifice
when(mockService.getData(anyString())).thenReturn("date mockate");

// Testăm componenta folosind mock-ul
Processor processor = new Processor(mockService);
String result = processor.process("intrare");

// Verificăm rezultatul
assertEquals("procesat date mockate", result);

// Verificăm dacă metoda mock-ului a fost apelată
verify(mockService).getData("intrare");

Exemplu de utilizare a mock-urilor în Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulare apel către serviciu extern
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"procesat {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):
  # Configurăm valoarea de return a mock-ului
  mock_get_data.return_value = "date mockate"

  # Apelăm funcția testată care folosește mock-ul
  result = process_data("some_id")

  # Verificăm rezultatul
  self.assertEqual(result, "procesat date mockate")

  # Verificăm dacă mock-ul a fost apelat cu argumentul așteptat
  mock_get_data.assert_called_once_with("some_id")

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

Postman este mai potrivit pentru testarea manuală a API-urilor, testare exploratorie sau crearea de solicitări demonstrative. Pentru testare automatizată în cadrul CI/CD, testele cu mock-uri la nivel de cod sunt preferate.

De ce testele uscate sunt mai bune decât utilizarea Postman?