Os testes de unidade devem sempre se sobrepor

5

Esta é uma questão de design de teste. Eu tenho um 'manipulador' de classe que aceita um 'validador' que verifica alguma lógica de negócios no que é passado para o manipulador.

Eu fiz os testes de unidade para o validador e agora estou escrevendo o teste para o manipulador. Obviamente, quero ter certeza de que o validador é chamado quando o manipulador faz sua coisa.

Devo testar os casos do validador mais uma vez ou isso é inútil?

EDIT 1:

Vou fornecer um pouco mais de insight sobre o que estou tentando fazer aqui, pois parece que as perguntas têm mais do que eu esperava.

O que estou fazendo é um serviço para registrar usuários em um site e preciso verificar se o usuário forneceu exatamente um método de contato com três opções possíveis (email, telefone e endereço postal). Essa validação precisa ser executada quando o usuário se registra no site e quando o usuário precisa redefinir sua senha, caso ele a tenha esquecido.

O método que lida com os usuários do registro é assim.

public Headers HandlePetition(Petition petition)
{
     if (petition == null)
     { throw new ArgumentNullException(); }

     contactPointValidator.ValidateContactPoint(new ContactData
     {
          Email = petition.email,
          PostalAddress = petition.postaladdress,
          Telephone = petition.telephone,
     });

     var response;

     // Do stuff

     return response;
}
    
por Zalomon 19.04.2016 / 16:39
fonte

3 respostas

0

Vou postar meu último comentário na resposta do fschmengler como resposta, já que acho que é a maneira mais adequada de resolver minha pergunta.

Eu acho que o meu problema é que eu estava enfrentando o problema da maneira errada: o manipulador não deveria validar nada disso, já que é uma lógica de negócios; nem mesmo indiretamente como está fazendo agora. Tanto o manipulador quanto o validador devem ser encapsulados por uma classe alta que usa ambos. Eu acho que isso está fazendo mais sentido para mim.

    
por 20.04.2016 / 11:58
fonte
5

Deve ser inútil. Mas você deve estar se certificando de que as chamadas do manipulador sejam chamadas pelo validador.

Para testes de unidade, você deve estar testando de forma isolada. Isso significa que você precisará de um validador stub (ou simulado) para entregar ao manipulador ao testar o manipulador. Você não verifica a lógica de negócios do validador ao testar o manipulador. Você testa esse manipulador chama o validador (neste caso, o ValidatorStub) quando e com o que deveria.

    
por 19.04.2016 / 16:55
fonte
3

Obviously I want to make sure that the validator is called when the handler does its thing

Em seguida, faça um mock do validador e teste que ele é chamado com os parâmetros corretos. Não há necessidade de testar o validador em si duas vezes.

Em uma nota relacionada, os testes de unidade têm seu verdadeiro valor no desenvolvimento orientado por testes. Parece que você está escrevendo os testes depois do código. Talvez os testes de integração sejam mais adequados para você aqui. Então você testaria o manipulador junto com validadores, ou até mesmo uma unidade maior em um teste que verifica se tudo funciona em conjunto conforme o esperado.

Os testes de integração são mais valiosos para o teste de regressão do que os testes de unidade, pois são mais propensos a encontrar bugs de efeitos colaterais inesperados.

    
por 19.04.2016 / 16:52
fonte