Eu escrevi cerca de 20 métodos em Java e todos eles chamam alguns serviços web. Nenhum desses serviços da web ainda está disponível. Para continuar com a codificação do lado do servidor, codifiquei os resultados que o serviço da Web deve fornecer.
Podemos testar esses métodos de unidade? Tanto quanto eu sei, o teste de unidade está zombando dos valores de entrada e veja como o programa responde. A zombaria dos valores de entrada e saída é significativa?
Editar:
As respostas aqui sugerem que eu deveria escrever casos de teste de unidade.
Agora, como posso escrever sem modificar o código existente?
Considere o seguinte código de exemplo (código hipotético):
public int getAge()
{
Service s = locate("ageservice"); // line 1
int age = s.execute(empId); // line 2
return age; // line 3
}
Agora, como zombamos da saída?
No momento, estou comentando a 'linha 1' e substituindo a linha 2 por int age= 50
. Isto está certo ? Alguém pode me indicar o caminho certo para fazê-lo?
fonte
Sim, você deve estar zombando de seu serviço. Zombar é a prática de usar objetos simulados para substituir os objetos reais que você usaria normalmente em tempo de execução. Na maioria das vezes, você deseja usar uma estrutura de simulação para criar objetos simulados de maneira fácil e dinâmica.
Se você usar objetos simulados, provavelmente escreveria um código mais parecido com isto:
onde
service
é o serviço real que você usará em tempo de execução, mas durante um teste de unidade, é um objeto simulado com comportamento simulado. Observe que o parâmetro paragetAge
não é mais uma classe concreta, mas uma interface. Isso permite que você use qualquer objeto como parâmetro, desde que implemente a interface, em vez de apenas uma classe específica. Seu teste de unidade seguiria as seguintes etapas:execute
for chamadogetAge
com o objeto simulado como parâmetrogetAge
retorna a idade correta.Para uma boa lista de estruturas de simulação de Java, consulte esta pergunta sobre o stackoverflow .
EDITAR
Não comente seu código e substitua-o por uma constante apenas para seus testes de unidade. O problema é que você precisará garantir que a coisa certa seja comentada ao executar testes de unidade e a coisa certa ao ser liberada para o cliente. Isso se tornaria um pesadelo para fins de manutenção a longo prazo, especialmente se você pretender escrever mais de dois testes de unidade que exijam zombarias. Além disso, seus testes devem ser executados no produto acabado ; caso contrário, isso significa que você não está testando o código real que está sendo lançado, o que nega a finalidade de realizar testes.
fonte
Sim, ele é. Seu trabalho é demonstrar que seu código faz a coisa certa, considerando o ambiente. Os serviços da web externos fazem parte do ambiente; não é seu trabalho testar o funcionamento adequado, é o trabalho das pessoas que escrevem os serviços. O mapeamento de entrada / saída que os testes devem verificar é a entrada / saída do seu código; se o código produzir informações para outro colaborador fazer seu trabalho, isso é estritamente acidental.
De fato, mesmo depois que os serviços da web estão disponíveis, é provavelmente uma boa idéia manter seus testes de unidade usando um ambiente simulado e não o real. Isso torna os testes mais simples, menos frágeis em relação ao contexto esperado do sistema e provavelmente mais rápido também.
fonte
Para adicionar à excelente resposta da emddudley, o maior ganho que você pode obter ao zombar do serviço é poder testar o que deve acontecer, o serviço não funciona corretamente. O pseudocódigo de teste pode ser algo como isto:
E agora sua implementação foi editada com este novo requisito
Em outros cenários, é mais provável que você precise responder a respostas mais complicadas. Se o serviço forneceu o processamento do cartão de crédito, você precisaria responder a Sucesso, Serviço indisponível, Cartão de crédito expirado, Número inválido, etc. Ao zombar do serviço, você pode garantir que responde a esses cenários da maneira adequada à sua situação. Nesse caso, você deve simular a entrada / saída do serviço e o feedback obtido ao saber que o código consumidor funcionará para todas as saídas conhecidas é realmente significativo e valioso.
EDIT: Acabei de notar que você deseja poder zombar sem modificar o método existente. Para fazer isso, o
locate("ageservice");
método precisaria ser alterado para suportar objetos simulados nos testes e localizar o serviço real quando estiver pronto. Essa é uma variação do padrão do localizador de serviço que abstrai a lógica para recuperar a implementação do serviço que você está usando. Uma versão rápida disso pode ser assim:Minha recomendação, no entanto, seria mover as dependências de serviço para os Construtores:
Agora, o método getAge não tem mais a responsabilidade de procurar o serviço, pois foi extraído da classe deixando completamente uma implementação semelhante a esta:
fonte
Não, mas você não está zombando do valor de entrada. Seu teste está sendo executado e o serviço simulado verifica se a parte certa do contrato foi acessada. O fato de você retornar um valor específico é irrelevante.
Por outro lado, se o seu método faz alguma lógica, o valor de retorno é importante. Aqui você está zombando das entradas da lógica (o resultado do serviço da web) e testando a saída.
fonte
você não pode. Mas você pode criar uma interface "IMyService" com a qual possa programar que contenha todas as assinaturas e métodos de serviço da web.
No modo Produção
getService();
, retornará uma referência a um serviço da web funcional completo e, no modo de teste, uma implementação alternativa (ou simulação) que retorna seus dados falsos.fonte
Zombar não é sobre entradas ou saídas, é sobre substituir dependências externas. Portanto, sim, é apropriado escrever testes de unidade e zombar dos serviços da web externos.
Agora as más notícias: dependendo do idioma e das ferramentas disponíveis, talvez você não consiga zombar das dependências externas, a menos que o código tenha sido projetado para permitir isso. Se esse for o caso, você encontrará seus testes realmente transformados em pequenos testes de integração, em vez de testes unti puros.
No lado positivo, parece que você está autorizado a modificar o código (caso contrário, como está comentando), passe uma interface para o seu serviço para permitir que seja zombado (ou use alguma outra forma de injeção de dependência )
Por fim, o que você deseja testar parece ser um invólucro puro em torno do serviço externo; não há quase nada para testar a unidade aqui, exceto o que você chama de serviço. Como essa é basicamente uma interface, a maioria dos testes terá que ser realizada posteriormente em um nível superior (teste de integração)
fonte