Tag: eclipse

olá Pessoal,

Neste post vou falar de um plugin que temos para o Eclipse que permite saber quantos % de nossos testes de fato estão cobertos. É comum pensarmos que 100% dos nossos testes unitarios estao 100% cobertos apenas pq todos os testes passam. Quem aqui quando começou com test units não pensou nisso (eu confesso que achava isso). E neste post eu pretendo apresentar uma ferramenta que permite descobrir e dar um resultado no formato de relatório o quanto o seu code está coberto.

Lets go…

Iniciando

O plugin que vamos usar é chamado de Eclemma, ele pode ser baixado ou instalado via update no Eclipse. No site do fabricante há todas informações sobre o plugin, alguns tutoriais básicos e com imagens ilustrativas. Enfim, não tem erro para começar a usar.

Após, a instalação do plugin e o restart do Eclipse a única diferença que vc vai perceber na sua IDE é que teremos um novo botão para rodar os testes com Coverage, ou seja, “execute o testes com o plugin para eu ter relatorio da cobertura” seria algo mais ou menos assim que o botão abaixo faz.

 

Algumas Características:

• permite exportar em html os relatorios;
• suporte Junit 4
• suporte ao ant, ou seja, vc pode gerar os relatórios a partir do ant
• Baixa curva de aprendizado.

 

Antes de ir para o tópico a seguir certifique-se que já o plugin está instalado.

Praticando

Não irei abordar todos os recurso do plugin até pq nao tem tanta coisa assim, só ficar brincando um pouco com a ferramenta que alguns minutos dar para saber tudo que ela faz. Porém, para o post reservei um exemplo muito simples, onde o objetivo é mostrar como de fato a ferramenta trabalha e vai ti ajudar no aumento de cobertura dos seus testes unitarios. Criei um projeto que calcula a “Multa Mora” para alguma coisa.Isso pouco importa a questão é que essa classe recebe valores e através de um calculo financeiro terá que retorna um valor da multa a ser paga. O objetivo aqui não é ser um post para area de finanças, então deixaremos isso de lado, mas para vc saber criar bons testes precisa entender do negócio e calcular um juros simples é algo que bem do dia-dia. A seguir temos a nosso Java Project e o código da classe com seu devido calculo.

Classe MultaMora

publicclass MultaMora {

private BigDecimal taxaDia = new BigDecimal(0.33);

private BigDecimal taxaMaxima = new BigDecimal(20.00);

public MultaMora() {

// TODO Auto-generated constructor stub

}

public BigDecimal verificaAtraso(String dataVencimento, String dataPagamento,

BigDecimal valor) throws ParseException {

DateFormat df = new SimpleDateFormat(“dd/MM/yyy”);

Date dateVenc = df.parse(dataVencimento);

Date datePagto = df.parse(dataPagamento);

Calendar calendarVenci = Calendar.getInstance();

calendarVenci.setTime(dateVenc);

Calendar calendarPagto = Calendar.getInstance();

calendarPagto.setTime(datePagto);

long diferencaData = calendarPagto.getTimeInMillis()- calendarVenci.getTimeInMillis();

int umDia = 1000 * 60 * 60 * 24;

long diasDiferenca = diferencaData / umDia;

BigDecimal novoValor = calculaMulta(diasDiferenca,valor);

return novoValor;

// return diasDiferenca;

}

public BigDecimal calculaMulta(long diasAtrasado, BigDecimal valor) {

BigDecimal totalTaxa = taxaDia.multiply(new BigDecimal(diasAtrasado));

BigDecimal divisor = new BigDecimal(100);

double ttaxa = totalTaxa.doubleValue();

double ttaxamax = taxaMaxima.doubleValue();

if (ttaxa<=ttaxamax) {

return valor;

} else {

BigDecimal valorMulti= valor.multiply(taxaMaxima);

valorMulti = valorMulti.divide(divisor);

valor = valorMulti.add(valor);

return valor;

}}}

Vamos ao que interessa que é criar a classe que fará os testes e em seguida veremos quantos % de nossa classe é coberta, para isso criamos os seguites testes, o qual vai está passando.

publicclass MultaMoraTeste {

@Test

publicvoid testPeriodoValidoMes() throws ParseException {

assertEquals(new BigDecimal(120), new MultaMora().verificaAtraso(

“10/11/2010″, “20/01/2011″, new BigDecimal(100)));}

@Test

publicvoid testCalculaValor(){

//TODO

}}

Testes Passando

Vimos que os testes estão passando tranquilamente. Nada de errado, pois esperamos que eles uma hora ficasse verde. Não vamos discutir aqui o ciclo de TDD.

Agora veremos quantos % nossa aplicação está coberta pelos testes. Então precisamos rodar os testes agora usando o plugin Eclemma e para isso temos que rodar conforme a imagem a seguir:

Ao executar observe os tests units foram executados e logo em seguida temos o relatorio de cobertura.Veja que 98% não é 100% , isso é evidente, mas tem que ficar claro na sua mente que não temos 100% dos testes, e vamos navegar na arvore e ver quem não está coberto segundo a ferramenta. Mas, antes disso observe que temos quatro colunas, sendo de fácil interpretação. A primeira fala o % coberto, a segunda as instruções cobertas, a proxima instruções não cobertas e a ultima o total de instruções.Podemos ver que o método calculaMulta não está 100, mas onde não está 100%? o que está faltando? Para ver isso basta dar dois cliques em cima do método na aba Coverage, que veremos o resultado a seguir:

Observe que temos no nosso code, linhas verdes e uma vermelha, a verde significa que aquela linha está coberta pelo teste, a vermelha como sempre é um problema que precisamos resolver, ou seja, linha não está cobert. Em outras palavras não temos nenhum teste que valide aquele valor. Então vamos resolver o problema. Para isso, vamos adicionar o seguinte teste na classe de Test que criamos.

@Test

publicvoid testCalculaValor(){

BigDecimal testValor = new MultaMora().calculaMulta(1, new BigDecimal(3));

assertEquals(new BigDecimal(3),testValor);

}

Observe que agora estamos verificando aquela valor que é return ele de fato nao tinha sido testado, então criamos esse teste somente para verificar aquela parte e saber se ele vai retornar de fato o que esperamos. Rode os testes com cobertura novamente e veja agora o resultado.

Agora temos 100% de cobertura em nosso código, observe que coisa mais linda de ser vista. Porém, isso aqui foi com um exemplo muito simples com o objetivo de mostrar a vc leitor como saber quantos % de seu code está coberto. Para praticar vc pode pegar projetos antigos seus e tentar cobrir alguns cenários. Não posso deixar de falar que 100% de cobertura não significa que seu code é o melhor do mundo, o mais interessante são os testes que vc possui, sempre que for escrever seus unit tests pense, o quanto esses são eficientes. O percentual de cobertura vira consequência qto mais eficiente for seu teste.

Enfim, espero que tenham gostado do post!!
abracos,

see ya! Next post.