Em testes de software, mock vs stub são dois tipos populares de testes duplos usados ​​para simular dependências. Eles ajudam a isolar o comportamento de um componente, substituindo dependências reais por substitutos controlados durante o teste. Embora os mocks e os stubs tenham finalidades semelhantes, eles são usados ​​de forma diferente com base no tipo de cenário de teste.
Este artigo se aprofunda nas principais diferenças entre mocks e stubs, seus casos de uso e quando usar cada um em sua estratégia de teste.

O que é um teste duplo?
Um teste duplo é um termo genérico para qualquer objeto ou componente usado para substituir uma dependência real durante o teste. O objetivo é isolar o componente em teste e remover fatores externos que possam afetar o resultado do teste. Mocks e stubs são dois tipos de testes duplos, frequentemente usados ​​em testes unitários e de integração.

O que é um esboço?
Um stub é um teste duplo que retorna dados predefinidos quando chamado pelo componente em teste. Normalmente é usado quando o componente que está sendo testado requer entrada de uma dependência, mas o comportamento real da dependência é irrelevante para o resultado do teste. Stubs fornecem respostas controladas, permitindo que você se concentre apenas na lógica dentro do componente.

Exemplo de esboço:
Digamos que você esteja testando uma função de processamento de pagamentos. Em vez de chamar um gateway de pagamento real, você usa um stub que sempre retorna uma resposta "pagamento bem-sucedido", garantindo que a lógica da função possa ser testada de forma independente.

const paymentGatewayStub = {
  processPayment: () => "payment successful"
};

function processOrder(paymentService) {
  const result = paymentService.processPayment();
  return result === "payment successful" ? "Order Complete" : "Order Failed";
}

// Test
console.log(processOrder(paymentGatewayStub));  // Output: "Order Complete"

Nesse caso, o stub garante que o serviço externo sempre retorne a saída esperada, facilitando o teste da lógica interna.

O que é uma simulação?
Uma simulação é um teste duplo que não apenas fornece dados falsos, mas também verifica as interações entre os componentes. As simulações ajudam a garantir que os métodos corretos sejam chamados com os parâmetros corretos e que a sequência desejada de eventos ocorra durante a execução. Eles normalmente são usados ​​quando o comportamento ou interação do componente é importante para o teste.
Exemplo de simulação:
Usando o mesmo exemplo de pagamento, digamos que você deseja verificar se o método processPayment() é chamado exatamente uma vez durante o processamento do pedido.

const paymentGatewayMock = {
  processPayment: jest.fn().mockReturnValue("payment successful")
};

function processOrder(paymentService) {
  paymentService.processPayment();  
}

// Test
processOrder(paymentGatewayMock);
expect(paymentGatewayMock.processPayment).toHaveBeenCalledTimes(1);

Nesse caso, o mock verifica a interação verificando se o método foi chamado, garantindo que o componente se comporte corretamente durante a execução.
Principais diferenças entre simulação e esboço
Esboço simulado de aspecto
Finalidade Verifica interações entre componentes Fornece respostas predefinidas
Comportamento Valida chamadas de métodos e parâmetros Retorna apenas dados estáticos
Cenário de uso Usado quando a interação é importante Usado quando a saída de dados é suficiente
Complexidade Mais complexo de implementar Mais simples de criar
Exemplo de teste Verificando chamadas de método Testando lógica com respostas fixas

Quando usar um esboço
• Testando Lógica Simples: Use um stub quando precisar apenas controlar a saída de uma dependência.
• Testes orientados a dados: se o foco for testar como seu componente se comporta com dados específicos, os stubs são mais adequados.
• Exemplo de caso de uso: se você estiver testando um recurso de login que precisa de dados de usuário de um banco de dados, use um stub para retornar um usuário fictício sem chamar o banco de dados real.
Quando usar uma simulação
• Teste Baseado em Interação: Se o foco for garantir que os métodos corretos sejam chamados com os parâmetros corretos, use uma simulação.
• Teste de interações complexas: simulações são ideais para componentes que interagem com vários serviços ou APIs.
• Exemplo de caso de uso: se você estiver testando um serviço de envio de e-mail, use uma simulação para verificar se a função sendEmail() foi chamada com o destinatário e a mensagem esperados.
Simulações e stubs podem ser usados ​​juntos?
Sim, em alguns casos, simulações e stubs são usados ​​juntos no mesmo teste para obter validação de interação e respostas controladas. Por exemplo, você pode usar um stub para retornar dados específicos e uma simulação para verificar se um serviço específico foi chamado.
Prós e contras de simulações e stubs
Prós dos stubs:
• Simples e fácil de implementar
• Útil para testar a lógica de componentes isoladamente
Contras dos stubs:
• Não é possível validar chamadas de método ou parâmetros
• Limitado a respostas estáticas
Prós das simulações:
• Verifica comportamento, interações e sequências
• Útil para cenários complexos com múltiplas dependências
Contras das simulações:
• Requer mais configuração e pode dificultar a leitura dos testes
• Pode levar a testes frágeis se não forem usados ​​com cuidado
Mock vs Stub: qual você deve usar?
• Se o seu teste depende da saída de uma dependência e você deseja controlar essa saída, use um stub.
• Se você precisar verificar se um método foi chamado ou validar interações entre componentes, use um mock.
• Para testes unitários, os stubs são mais comumente usados, pois o foco está no teste da lógica interna.
• Para testes de integração, os mocks são mais úteis para verificar como diferentes partes do sistema interagem.

Conclusão
Tanto os mocks quanto os stubs desempenham papéis essenciais nas estratégias de teste, mas cada um serve a um propósito diferente. Embora os stubs controlem os dados retornados por uma dependência, os mocks garantem que as interações corretas aconteçam entre os componentes. Compreender quando e como usar cada um pode melhorar a qualidade dos seus testes, resultando em software mais confiável. Ao aplicar mocks e stubs corretamente, as equipes podem reduzir bugs, acelerar o desenvolvimento e criar melhores estratégias de teste para testes unitários e de integração.