Determinando o que é um teste de unidade útil

Eu estive pesquisando os documentos do phpunit e encontrei a seguinte citação:

Você sempre pode escrever mais testes. No entanto, você descobrirá rapidamente que apenas uma fração dos testes que você pode imaginar são realmente úteis. O que você deseja é escrever testes que falhem, mesmo que você ache que eles devam funcionar, ou testes que tenham sucesso, mesmo que você ache que eles devam falhar. Outra maneira de pensar é em termos de custo / benefício. Você deseja escrever testes que pagarão com informações. --Erich Gamma

Isso me fez pensar. Como você determina o que torna um teste de unidade mais útil que outro, além do que é mencionado nessa citação sobre custo / benefício. Como você decide para qual parte do seu código você cria testes de unidade? Estou perguntando isso, porque outra daquelas citações também dizia:

Então, se não se trata de testes, o que é isso? Trata-se de descobrir o que você está tentando fazer antes de fugir para tentar fazê-lo. Você escreve uma especificação que identifica um pequeno aspecto do comportamento de forma concisa, inequívoca e executável. É simples assim. Isso significa que você escreve testes? Não. Isso significa que você escreve especificações do que seu código terá que fazer. Isso significa que você especifica o comportamento do seu código com antecedência. Mas não muito à frente do tempo. De fato, pouco antes de você escrever o código, é melhor porque é quando você tem o máximo de informações disponíveis até o momento. Como o TDD bem feito, você trabalha em pequenos incrementos ... especificando um pequeno aspecto do comportamento de cada vez e implementando-o. Quando você percebe que se trata de especificar comportamento e não de escrever testes, seu ponto de vista muda. De repente, a idéia de ter uma classe de teste para cada uma de suas classes de produção é ridiculamente limitante. E o pensamento de testar cada um dos seus métodos com seu próprio método de teste (em um relacionamento de 1 a 1) será risível. --Dave Astels

A seção importante disso é

* E o pensamento de testar cada um de seus métodos com seu próprio método de teste (em um relacionamento de 1 a 1) será risível. *

Portanto, se a criação de um teste para cada método é 'risível', como / quando você escolhe para que escreve os testes?

Quantos testes por método?

Bem, o máximo teórico e altamente impraticável é a complexidade do N-Path (suponha que todos os testes abranjam maneiras diferentes através do código;)). O mínimo é UM !. Por método público , isto é, ele não testa detalhes da implementação, apenas comportamentos externos de uma classe (retornam valores e chamam outros objetos).

Você cita:

* E o pensamento de testar cada um de seus métodos com seu próprio método de teste (em um relacionamento de 1 a 1) será risível. *

e depois pergunte:

Portanto, se a criação de um teste para cada método é 'risível', como / quando você escolhe para que escreve os testes?

Mas acho que você não entendeu o autor aqui:

A idéia de ter one test methodpor one method in the class to testé o que o autor chama de "risível".

(Pelo menos para mim) Não se trata de 'menos', é de 'mais'

Então deixe-me reformular como eu o entendi:

E o pensamento de testar cada um de seus métodos com SOMENTE UM MÉTODO (seu próprio método de teste em um relacionamento de 1 a 1) será risível.

Para citar sua cotação novamente:

Quando você percebe que se trata de especificar comportamento e não de escrever testes, seu ponto de vista muda.

Quando você pratica TDD , não pensa :

Eu tenho um método calculateX($a, $b);e ele precisa de um teste testCalculcateXque teste TUDO sobre o método.

O que o TDD diz é para pensar sobre como o seu código DEVE FAZER :

Preciso calcular o maior dos dois valores ( primeiro caso de teste! ), Mas se $ a for menor que zero, ele deverá gerar um erro ( segundo caso de teste! ) E se $ b for menor que zero, deverá ... ( terceiro caso de teste! ) e assim por diante.

Você deseja testar comportamentos, não apenas métodos únicos sem contexto.

Dessa forma, você obtém um conjunto de testes que é documentação para o seu código e REALMENTE explica o que é esperado que ele faça, talvez até o porquê :)

Como você decide para qual parte do seu código você cria testes de unidade?

Bem, tudo o que acaba no repositório ou em qualquer lugar perto da produção precisa de um teste. Eu não acho que o autor de suas citações discordaria disso, como tentei declarar acima.

Se você não tiver um teste, fica muito mais difícil (mais caro) alterar o código, especialmente se você não estiver fazendo a alteração.

O TDD é uma maneira de garantir que você tenha testes para TUDO, mas contanto que você os escreva, tudo bem. Normalmente, escrevê-las no mesmo dia ajuda, já que você não fará isso mais tarde, vai? :)

Resposta aos comentários:

uma quantidade decente de métodos não pode ser testada em um contexto específico porque eles dependem ou dependem de outros métodos

Bem, existem três coisas que esses métodos podem chamar:

Métodos públicos de outras classes

Podemos zombar de outras classes e definir o estado lá. Estamos no controle do contexto, então isso não é um problema.

* Métodos protegidos ou privados no mesmo *

Qualquer coisa que não faça parte da API pública de uma classe não é testada diretamente, geralmente.

Você deseja testar o comportamento e não a implementação e, se uma classe faz tudo, funciona em um grande método público ou em muitos métodos protegidos menores chamados de implementação . Você deseja alterar esses métodos protegidos sem tocar nos seus testes. Porque seus testes serão interrompidos se o seu código mudar de comportamento! É para isso que servem seus testes, para dizer quando você quebra alguma coisa :)

Métodos públicos na mesma classe

Isso não acontece com muita frequência, acontece? E se gostar do exemplo a seguir, existem algumas maneiras de lidar com isso:

$stuff = new Stuff();
$stuff->setBla(12);
$stuff->setFoo(14);
$stuff->execute(); 

Que os setters existem e não fazem parte da assinatura do método execute é outro tópico;)

O que podemos testar aqui é se as execuções explodem quando definimos os valores errados. Isso setBlagera uma exceção quando você passa uma string e pode ser testado separadamente, mas se quisermos testar se esses dois valores permitidos (12 e 14) não funcionam JUNTOS (por qualquer motivo) do que esse é um caso de teste.

Se você deseja uma suíte de testes "boa", pode, em php, talvez (!) Adicionar uma @covers Stuff::executeanotação para garantir que você gere apenas cobertura de código para esse método e que outras coisas que estão apenas configuradas precisam ser testadas separadamente (novamente, se você quer isto).

Portanto, o ponto é: talvez você precise criar parte do mundo circundante primeiro, mas deve ser capaz de escrever casos de teste significativos que geralmente abrangem apenas uma ou talvez duas funções reais (setters não contam aqui). O restante pode ser zombado do éter ou ser testado primeiro e depois confiar (ver @depends)

* Nota: A questão foi migrada do SO e, inicialmente, era sobre PHP / PHPUnit, é por isso que o código de exemplo e as referências são do mundo php, acho que isso também é aplicável a outras linguagens, pois o phpunit não difere muito dos outros xUnit estruturas de teste.

Testes e testes unitários não são a mesma coisa. O Teste de Unidade é um subconjunto muito importante e interessante de Testes em geral. Eu diria que o foco do teste de unidade nos faz pensar sobre esse tipo de teste de maneiras que contradizem as citações acima.

Primeiro, se seguirmos o TDD ou mesmo o DTH (ou seja, desenvolver e testar em estreita harmonia), estaremos usando os testes que escrevemos como foco para obter o design correto. Pensando nos casos de canto e escrevendo testes de acordo, evitamos que os bugs entrem em primeiro lugar, então, na verdade, escrevemos o teste que esperamos passar (OK, no início do TDD, eles falham, mas isso é apenas um artefato de pedido, quando o código está pronto, esperamos que eles sejam aprovados, e a maioria aceita, porque você pensou no código.

Segundo, os testes unitários realmente surgem quando refatamos. Alteramos nossa implementação, mas esperamos que as respostas permaneçam as mesmas - o Teste de Unidade é nossa proteção contra a quebra de nosso contrato de interface. Então, mais uma vez, esperamos que os testes passem.

Isso implica que, para nossa interface pública, que provavelmente é estável, precisamos de uma rastreabilidade clara, para que possamos ver que todos os métodos públicos são testados.

Para responder sua pergunta explícita: Teste de unidade para interface pública tem valor.

editado no comentário da resposta:

Testando métodos particulares? Sim, deveríamos, mas se tivermos que não testar algo, é aí que eu comprometeria. Afinal, se os métodos públicos estão funcionando, esses bugs podem ser tão importantes? Pragmaticamente, a rotatividade tende a acontecer nas coisas particulares, você trabalha duro para manter sua interface pública, mas se as coisas de que depende mudar as coisas particulares podem mudar. Em algum momento, podemos achar que manter os testes internos é muito trabalhoso. Esse esforço é bem gasto?

Os testes de unidade devem fazer parte de uma estratégia de teste maior. Sigo esses princípios ao escolher quais tipos de testes escrever e quando:

• Concentre-se em escrever testes de ponta a ponta. Você cobre mais código por teste do que com testes de unidade e, portanto, obtém mais testes pelo preço. Faça disso a validação automatizada do seu sistema como um todo.

• Comece a escrever testes de unidade em torno de pepitas de lógica complicada. Os testes de unidade valem o seu peso em situações em que os testes de ponta a ponta seriam difíceis de depurar ou difíceis de escrever para obter uma cobertura de código adequada.

• Aguarde até que a API em que você está testando esteja estável para gravar qualquer tipo de teste. Você deseja evitar ter que refatorar sua implementação e seus testes.

Rob Ashton tem um bom artigo sobre esse tópico, do qual me baseei bastante para articular os princípios acima.

Eu costumo seguir uma abordagem diferente ao teste de unidade que parece funcionar bem. Em vez de pensar em um teste de unidade como "Testando algum comportamento", penso nele mais como "uma especificação que meu código deve seguir". Dessa forma, você pode basicamente declarar que um objeto deve se comportar de uma certa maneira e, desde que você assuma que em outras partes do seu programa, você pode ter certeza de que é relativamente livre de erros.

Se você está escrevendo uma API pública, isso é extremamente valioso. No entanto, você sempre precisará de uma boa dose de testes de integração de ponta a ponta, porque geralmente não vale a pena se aproximar de uma cobertura de 100% dos testes de unidade e perderá coisas que a maioria consideraria "não testável" pelos métodos de teste de unidade (zombaria, etc)