Por que os testes a seco são melhores do que usar o…

Os testes com mocks permitem isolar o componente testado, sem depender da disponibilidade ou funcionamento de serviços externos. Isto garante estabilidade e repetibilidade nos testes, acelera a execução dos cenários de teste e simplifica a identificação de erros relacionados diretamente com a lógica testada.

Postman, mesmo usando mocks, testa a interação com dependências externas ao nível de pedidos/respostas, e não integra mocks diretamente no código de teste ou no próprio componente. Isto é menos granular e mais difícil de automatizar em pipelines de CI/CD.

Vantagens dos testes com mocks em relação ao Postman para testes automatizados:

Isolamento: Apenas o código é testado, não a integração com sistemas externos.
Estabilidade: Os testes não falham devido a problemas com serviços externos.
Velocidade: Execução rápida dos testes sem esperar por respostas de serviços reais.
Granularidade: Possibilidade de mockear métodos ou funções específicas dentro do código.
Automatização: Fácil de integrar em testes unitários e de integração que são executados automaticamente.
Teste de casos extremos: Facilidade de simular diferentes cenários de respostas de dependências (erros, atrasos, dados não padrão).

Exemplo de uso de mock em Java (Mockito):

// Criar um mock para a dependência
ExternalService mockService = mock(ExternalService.class);

// Configurar o comportamento do mock ao chamar um método específico
when(mockService.getData(anyString())).thenReturn("dados simulados");

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

// Verificar o resultado
assertEquals("processado dados simulados", result);

// Verificar se o método do mock foi chamado
verify(mockService).getData("entrada");

Exemplo de uso de mock em Python (unittest.mock):

# mock_example.py

def get_data_from_external_service(id):
  # Simulação de chamada a serviço externo
  pass

def process_data(id):
  data = get_data_from_external_service(id)
  return f"processado {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 do mock
  mock_get_data.return_value = "dados simulados"

  # Chamar a função testada que usa o mock
  result = process_data("algum_id")

  # Verificar o resultado
  self.assertEqual(result, "processado dados simulados")

  # Verificar que o mock foi chamado com o argumento esperado
  mock_get_data.assert_called_once_with("algum_id")

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

Postman é mais adequado para testes manuais de API, testes exploratórios ou criação de requisições de demonstração. Para testes automatizados no âmbito de CI/CD, os testes com mocks a nível de código são preferíveis.

Por que os testes a seco são melhores do que usar o Postman?