Java: Testes de Unidade

E aí galera, tudo tranquilo?

Passei um tempo fora daqui, porque estou em processo de treinamento com o Jonas Abreu, na Lambda3. Minha semana, ausente do blog, começou muito diferente. Meu primeiro estágio na área foi em uma empresa convencional, então estava acostumado com aquele lance de calça jeans, tênis e Gerentes com caras de bravos.
Então conheci a Lambda3, através de um amigo, e fiquei super interessado na filosofia e nos valores, que são bem próximos aos meus. Os apaixonados por desenvolvimento, que não curtem gerentes e nem trabalhar vestido como se fosse a um casamento. No primeiro dia, foi um choque, realmente não é normal ver um dos Fundadores (Giovanni Bassi) de Chinelo! Mas venho concluindo que isso só nos deixa mais confortáveis para maiores desafios!

Continuarei me dedicando a vocês e já conversei com o Jonas, vou escrever toda segunda-feira a minha experiência da semana.

Para começar de um jeito novo, minha primeira lição foi TDD!
Imagine o quão confortável é refatorar todo seu código e ter certeza de que se rolar alguma merda, você vai saber antes da Produção. :)

E o assunto será exatamente esse: TDD! (Test Driven Development)

O que é TDD?
Desenvolvimento Orientado a Testes. Você simplesmente escreve seus testes antes de codar seu software. Existe algo mais profundo aqui: http://pt.wikipedia.org/wiki/Test_Driven_Development

O que é um Teste?
Imagine a seguinte situação: Você precisa verificar se dois números foram somados corretamente (Exemplo extremamente didático). Assim você escreve seu teste e vai codar de forma que aquele teste seja satisfeito. Vamos fazer um exemplo prático (Java):

Crie um novo projeto TestandoTDD no Eclipse;

No diretório raiz de TestandoTDD crie um source folder test;

Feito isso, crie dentro do folder test um novo arquivo JUnit Test Case, caso role de você não encontrar o JUnit no seu Eclipse: http://www.vogella.com/tutorials/JUnit/article.html

Por convenção, não sei de quem, nós damos o nome do teste assim: SuaClasseTest
Ou seja, SomaTest.

Bom, agora o lindo e maravilhoso código:

// Não se esqueça dos imports
public class SomaTest{
  @Test
  public void DeveSomarDoisNumeros(){
    // Setup
    Soma soma = new Soma(1, 2);

    // Execução e Verifição
    Assert.assertEquals(4, soma.ExecutaSoma());
  }
}

Bom, mas e aí o que tudo isso significa?
O nome do método de teste tem que ser bem objetivo, muito mesmo. Assim caso der erro, fica "simples" de identificar o ocorrido.

Assim que você escrever a annotation @Test, você declara que aquele é um metodo para testar um caso. (Mais Detalhes: http://junit.sourceforge.net/javadoc/org/junit/Test.html)

O teste é convencional é composto de 3 etapas: Setup, Execução e Verificação.

No Setup, nós definimos o que será testado, no nosso caso o Objeto Soma(que ainda não existe).

Nossa execução acontece no método soma.ExecutaSoma(), que deve retornar o resultado da soma.

E o mais legal aí é a Verificação, que no momento acontece com a Classe Assert (http://junit.sourceforge.net/javadoc/org/junit/Assert.html). Essa classe é composta de diversos métodos que avaliam diversas situações, nós usaremos o assertEquals(int Esperado, int Resultado) que compara dois números.

Caso nosso retorno seja o resultado esperado (3), veremos a aba do JUnit (geralmente a esquerda) com uma barra verde. Caso contrário a cor vermelha predomina.

Bom, nosso teste está escrito, como provavelmente você sabe, ele não funcionará, pois não temos a classe Soma e nem mesmo o seu respectivo método.

Vamos na pasta /src e e criarmos a classe Soma.java. Nosso objetivo atual é satisfazer o teste, ou seja, implementar a classe soma, de forma que nosso teste dê certo.

File -> New -> Class

Soma.java:

//imports
public class Soma {
  private int x;
  private int y;

  public Soma(int x, int y){
    this.x = x;
    this.y = y;
  }

  public int ExecutaSoma(){
    return x + y;
  }
}

E pronto, temos uma situação que satisfaz nosso teste!

Teste seu SomaTest clicando com o direito em cima do arquivo e Run as -> JUnit Test.

Isso foi um simples Teste de Unidade, onde testamos a função ExecutaSoma() da classe Soma.

Na Aba JUnit, logo abaixo você verá algo como Failure Trace, onde caso ocorra algum erro no teste, serão impressos os resultados. Como você deve ter visto, nosso teste retornou um erro, procure no Failure Trace qual foi o erro. E esse é o exercício de hoje, e a dica é você pode encontrar algo no expected:<valor> but was:<valor>. Ou seja valor experado e valor atual.

Caso você tenha ficado com preguiça de digitar todo esse código, que não é muito. Ele está lá no meu Github, é só baixar, importar no Eclipse e testar!

Qualquer dúvida, observação ou mesmo dica email-me: abner.terribili@lambda3.com.br ou comente abaixo!