Perché i test a secco sono migliori dell'uso di…

I test con mock consentono di isolare il componente testato, senza dipendere dalla disponibilità o dal funzionamento di servizi esterni. Ciò garantisce stabilità e ripetibilità dei test, accelera l'esecuzione degli scenari di test e semplifica l'identificazione degli errori direttamente legati alla logica testata.

Postman, anche utilizzando i mock, verifica l'interazione con le dipendenze esterne a livello di richieste/risposte, e non integra i mock direttamente nel codice di test o nel componente stesso. Questo è meno granulare e più difficile da automatizzare nelle pipeline CI/CD.

Vantaggi dei test con mock rispetto a Postman per i test automatizzati:

Isolamento: Viene testato solo il codice, non l'integrazione con sistemi esterni.
Stabilità: I test non falliscono a causa di problemi con i servizi esterni.
Velocità: Esecuzione rapida dei test senza attendere risposte da servizi reali.
Granularità: Possibilità di mockare metodi o funzioni specifiche all'interno del codice.
Automazione: Facile da integrare in test unitari e di integrazione eseguiti automaticamente.
Test di casi estremi: Facilità nel simulare diversi scenari di risposte delle dipendenze (errori, ritardi, dati non standard).

Esempio di utilizzo di mock in Java (Mockito):

// Creiamo un mock per la dipendenza
ExternalService mockService = mock(ExternalService.class);

// Configuriamo il comportamento del mock quando viene chiamato un metodo specifico
when(mockService.getData(anyString())).thenReturn("dati mockati");

// Testiamo il componente usando il mock
Processor processor = new Processor(mockService);
String result = processor.process("input");

// Verifichiamo il risultato
assertEquals("processed dati mockati", result);

// Verifichiamo che il metodo del mock sia stato chiamato
verify(mockService).getData("input");

Esempio di utilizzo di mock in Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulazione di chiamata a servizio esterno
  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):
  # Configuriamo il valore di ritorno del mock
  mock_get_data.return_value = "dati mockati"

  # Chiamiamo la funzione che utilizza il mock
  result = process_data("some_id")

  # Verifichiamo il risultato
  self.assertEqual(result, "processed dati mockati")

  # Verifichiamo che il mock sia stato chiamato con l'argomento atteso
  mock_get_data.assert_called_once_with("some_id")

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

Postman è più adatto per test manuali di API, test esplorativi o creazione di richieste di demo. Per i test automatizzati in CI/CD, i test con mock a livello di codice sono preferibili.

Perché i test a secco sono migliori dell'uso di Postman?