Diferença entre testes unitários e desenvolvimento orientado a testes

Teste de unidade refere-se a o que você está testando, TDD para quando você está testando.

Os dois são ortogonais.

Teste unitário significa, bem, testar unidades individuais de comportamento. Uma unidade individual de comportamento é a menor unidade possível de comportamento que pode ser individualmente testada isoladamente. (Eu sei que essas duas definições são circulares, mas elas parecem funcionar muito bem na prática.)

Você pode escrever testes de unidade antes de escrever seu código, depois de escrever seu código ou enquanto escreve seu código.

TDD significa (mais uma vez, obviamente) deixar seus testes impulsionarem seu desenvolvimento (e seu design). Você pode fazer isso com testes de unidade, testes funcionais e testes de aceitação. Normalmente, você usa todos os três.

A parte mais importante do TDD é o meio D . Você deixa os testes conduzirem você. Os testes lhe dizem o que fazer, o que fazer a seguir, quando terminar. Eles dizem o que a API vai ser, o que é o design. (Isso é importante: TDD não é sobre escrever testes primeiro. Existem muitos projetos que escrevem testes primeiro, mas não praticam TDD. Escrever testes primeiro é simplesmente um pré-requisito para permitir que os testes conduzam o desenvolvimento.)

O Teste de Unidade é um componente do Desenvolvimento Orientado a Testes

Você pode fazer testes unitários sem fazer um desenvolvimento orientado por testes. No entanto, você não pode fazer o desenvolvimento orientado a testes sem usar testes de unidade.

Quando você faz o teste de unidade tradicional, escreve o teste após escrever o seu código.

Desenvolvimento orientado a testes consiste em escrever o teste de unidade antes de escrever o código.

Vantagens mais interessantes do TDD (IMHO) em comparação com testes unitários simples:

• O código é totalmente testado antecipadamente. É um teste indolor.
• Obriga você a projetar suas aulas corretamente.
• Também obriga você a mantê-lo simples e estúpido .
• O ciclo do Red-Green-Refactor é o assassino absoluto da procrastinação!

TDD e Teste Unitário são dois termos muito específicos que muitas vezes são mal utilizados.

O TDD está gravando um teste que falhará, gravando a quantidade mínima de código necessária para executá-lo e refatorando o código para torná-lo limpo. Isso é feito em ciclos, falha - > passar - > refactor, adicionando um novo teste para cada requisito conhecido para o código. Mais recentemente, o TDD tornou-se ainda mais específico sobre a escrita de testes unitários nesse ciclo, para distingui-lo do ATDD (um subconjunto do BDD) que está escrevendo testes de aceitação em um ciclo similar.

Teste de unidade é sobre como testar um código em unidades pequenas e isoladas. A confusão comum aqui é pensar que, se você estiver usando uma ferramenta de teste de unidade, como xUnit ou Rspec, para executar testes em que você está escrevendo testes de unidade. Isto não é necessariamente verdade. Essas ferramentas podem ser usadas para executar testes usando a estrutura Selenium - nesse caso, você está escrevendo testes de aceitação usando um testador de unidade. Testes unitários são testes muito específicos que focam em um pequeno pedaço de lógica, isolado de qualquer outra coisa por causa da velocidade (para que você possa executá-los com frequência e obter feedback rápido sobre novos bugs).

TDD é a abordagem de escrever os casos de teste antes do desenvolvimento, como você disse, e o desenvolvedor escreve o código para passar os casos de teste. Teste de Unidade é um termo usado para descrever um tipo de teste de escopo limitado que não seja teste de sistema, teste de integração e teste de aceitação.

TDD é uma abordagem filosófica para escrever código: escreva os testes primeiro. Os testes que você escreve são testes de unidade.

A maneira que eu separo os dois é considerar que o TDD é menos sobre testes, e mais sobre como projetar o código. Os testes unitários são usados para definir as expectativas para o código final. Quando o código final é escrito e passa nos testes (especificações), você tem um código projetado usando testes.

Todas as respostas excelentes. Gostaria apenas de acrescentar que o teste unitário tende a considerar a 'unidade' como um componente pequeno, enquanto o TDD escala para incluir testes de integração e aceitação.

(Algumas variantes do TDD consideram a 'unidade' como o menor passo incremental em direção à funcionalidade desejada ...)