Isso é algo que me preocupa há um tempo. Realmente vale a pena testar uma unidade de um cliente de API?
Digamos que você esteja criando uma classe pequena para abstrair as chamadas para uma API REST da loja de animais de estimação. A loja de animais de estimação é uma API muito simples e possui um conjunto básico de métodos:
listProducts()
getProductDetails(ProductID)
addProduct(...)
removeProduct(ProductID)
Ao testar isso, teríamos que criar um serviço simulado ou simular as respostas. Mas isso parece exagero; Entendo que queremos garantir que nossos métodos não parem de funcionar com erros de digitação / sintaxe, mas como estamos escrevendo funções que chamam métodos remotos e depois criando respostas falsas a partir desses métodos remotos, parece que um desperdício de esforço e que estamos testando algo que realmente não pode falhar. Pior, se o método remoto mudar, nossos testes de unidade serão aprovados enquanto o uso da produção falhar.
Tenho certeza de que estou perdendo alguma coisa, ou estou com o lado errado do bastão, ou não estou vendo a madeira para as árvores. Alguém pode me colocar no caminho certo?
fonte
Respostas:
O trabalho de um cliente remoto da API é emitir determinadas chamadas - nem mais nem menos. Portanto, seu teste deve verificar se emite essas chamadas - nem mais nem menos.
Claro, se o provedor da API alterar a semântica de suas respostas, seu sistema falhará na produção. Mas isso não é culpa da sua classe de cliente; é algo que só pode ser capturado em testes de integração. Ao confiar no código que não está sob seu controle, você renunciou à capacidade de verificar a correção por meio de testes internos - foi uma troca e esse é o preço.
Dito isso, testar uma classe que consiste apenas de delegações para outra classe pode ser de baixa prioridade, porque há comparativamente pouco risco de erros complexos. Mas isso vale para qualquer classe que consiste apenas de uma linha uniforme, não tem nada a ver com chamar o código de outro fornecedor.
fonte
foo()
é chamado antesbar()
, mas isso não significa que ligarfoo()
antesbar()
é a coisa certa a fazer; um teste de unidade como esse passaria mesmo se o código estivesse errado. E se isso é tudo o que o cliente está fazendo, configurar as simulações que verificam sefoo()
são chamadas antesbar()
é relativamente problemático para algo que pode ser verificado com uma rápida olhada no código do cliente.add()
método adiciona dois números corretamente, mas isso não significa que a adição é a coisa certa a ser feita neste momento no algoritmo - oadd()
teste de unidade seria bem-sucedido, mesmo que seu programa estivesse errado. Se for a coisa errada, seulevenshteinDistance()
método é o culpado, não oadd()
método. Isto é exatamente o mesmo. O ponto de separar o código em métodos é sempre que cada método precisa se preocupar apenas em corrigir uma coisa.Resposta curta:
Todos os métodos devem ser testados em unidade.
Resposta longa:
Sim. Vale a pena.
Estas são algumas coisas que os testes de unidade desses métodos de chamada de API devem testar:
Essas são as coisas que o método chamado faz que podem ser isoladas quando estou zombando do serviço da API e, testando-as bem, asseguro que os erros não sejam originados por um erro no código do cliente que chama a API.
fonte
Estes não seriam testes de unidade, porque você está testando a entrada e a saída do seu sistema, mais como testes de integração limitados.
Seja muito cauteloso ao dizer "parece um desperdício de esforço e que estamos testando algo que realmente não pode falhar" - pode falhar, falhará, provavelmente falhará de maneiras que você não pode antecipar, o as falhas serão piores se você não tiver testes.
O erro que você está cometendo aqui está relacionado à invenção das rodas: fazer chamadas para serviços remotos e APIs é um cenário muito comum, portanto existem algumas ferramentas muito boas para ajudá-lo a testar isso. A última vez que trabalhei em um aplicativo conectado a serviços remotos, usei o SoapUIque pode examinar um serviço e fazer chamadas simuladas para esse serviço ou se comportar como uma cópia local do servidor, na qual você pode fazer chamadas de teste e acompanhar as solicitações e respostas. Demorou alguns minutos para configurar e também era muito rápido para atualizar se a interface remota fosse alterada. Eu não o usei em um cenário REST, mas mesmo que não funcione bem para isso (ou talvez alguém esteja lendo esta resposta no futuro quando existirem ferramentas melhores), você poderá encontrar uma ferramenta que possa simular um serviço para você e quando chegar a hora de implantar seu código, você ficará satisfeito por ter feito isso.
fonte