¿Por qué las pruebas en mojado son mejores que usar…

Las pruebas con mocks permiten aislar el componente probado, sin depender de la disponibilidad o funcionamiento de servicios externos. Esto garantiza estabilidad y repetibilidad en las pruebas, acelera la ejecución de los escenarios de prueba y simplifica la identificación de errores relacionados directamente con la lógica probada.

Postman, incluso usando mocks, prueba la interacción con dependencias externas a nivel de solicitudes/respuestas, y no integra mocks directamente en el código de prueba o en el componente mismo. Esto es menos granular y más difícil de automatizar en pipelines de CI/CD.

Ventajas de las pruebas con mocks frente a Postman para pruebas automatizadas:

Aislamiento: Solo se prueba el código, no la integración con sistemas externos.
Estabilidad: Las pruebas no fallan por problemas en servicios externos.
Velocidad: Ejecución rápida de las pruebas sin esperar respuestas de servicios reales.
Granularidad: Posibilidad de mockear métodos o funciones específicas dentro del código.
Automatización: Fácil integración en pruebas unitarias y de integración que se ejecutan automáticamente.
Prueba de casos extremos: Facilidad para simular diferentes escenarios de respuestas de dependencias (errores, retrasos, datos no estándar).

Ejemplo de uso de mock en Java (Mockito):

// Crear un mock para la dependencia
ExternalService mockService = mock(ExternalService.class);

// Configurar el comportamiento del mock al llamar a un método específico
when(mockService.getData(anyString())).thenReturn("datos simulados");

// Probar el componente usando el mock
Processor processor = new Processor(mockService);
String result = processor.process("entrada");

// Verificar el resultado
assertEquals("procesado datos simulados", result);

// Verificar que se llamó al método del mock
verify(mockService).getData("entrada");

Ejemplo de uso de mock en Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulación de llamada a servicio externo
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"procesado {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):
  # Configurar valor de retorno del mock
  mock_get_data.return_value = "datos simulados"

  # Llamar a la función que se prueba, que usa el mock
  result = process_data("algun_id")

  # Verificar el resultado
  self.assertEqual(result, "procesado datos simulados")

  # Verificar que el mock fue llamado con el argumento esperado
  mock_get_data.assert_called_once_with("algun_id")

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

Postman es más adecuado para pruebas manuales de API, pruebas exploratorias o creación de solicitudes de demostración. Para pruebas automatizadas en CI/CD, las pruebas con mocks a nivel de código son preferibles.

¿Por qué las pruebas en mojado son mejores que usar Postman?