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.