Fake it (til you make it)

A técnica Fake it consiste em:

Escreva um teste que falhe. Para fazê-lo passar, utilize constantes. Vá escrevendo novos testes e gradualmente substituindo as constantes por variáveis.

Um exemplo simples: gostaria que um método me informasse se um número é par ou ímpar. Neste caso, eu posso começar com o seguinte teste:

public void testNumeroPar()
{
    assertTrue(verificador.ehPar(4));
}

Eu poderia tentar escrever a lógica deste teste, mas vou fazê-lo passar inicialmente com uma constante:

public boolean ehPar(int valor)
{
    return true;
}

O teste passa, mas é fácil ver que o método não faz tudo que queremos, o que me obriga a escrever um novo teste:

public void testNumeroImpar()
{
    assertFalse(verificador.ehPar(3));
}

Mais uma vez, posso usar uma implementação utilizando constantes. Então, modificamos o método ehPar:

public boolean ehPar(int valor)
{
    if(valor==3){
        return false;
    }
    return true;
}

Mais uma vez os testes passam, mas sinto que não cheguei onde eu queria. Vou escrever outro teste:

public void testNumeroImparSete()
{
    assertFalse(verificador.ehPar(7));
}

Agora meu teste falha, mas eu posso fazê-lo passar aproveitando para remover a duplicação da constante “3” (que está tanto no teste quanto no método ehPar):

public boolean ehPar(int valor)
{
    return (valor % 2 == 0) ? true : false;
}

Todos os testes passam e eu posso assumir que meu método está completo.

Esta técnica, embora seja simples, pode causar aversão à primeira vista. No exemplo acima é fácil imaginar a solução após escrever o primeiro testes, então o programador desavisado pode pensar: “por que diabos vou retornar uma constante?”. Simples: isto te obrigará a escrever novos testes e a pensar um pouco mais sobre o problema que está tentando se solucionar. Além disso, no final você terá vários testes para provar que a sua implementação funciona. Portanto, esta técnica trás dois benefícios:

• Aumenta a confiança: uma vez que você terá vários testes para provar que a implementação continua funcionando mesmo depois de um refactoring.
• Ajuda a controlar o escopo: já que você pode tratar um problema isolando um pedaço dele e gradativamente adicionando complexidade à solução.

Apesar de às vezes ir contra a natureza criativa dos programadores, esta técnica nos ajuda a trabalhar com um foco bem definido, o tempo todo.

Mais detalhes sobre esta técnicas podem ser encontrados no capítulo 28 (Testing Patterns) do livro Test-driven Development By Example, do Kent Beck.