Cobrindo seus testes com Cobertura, JUnit, HSQLDB, JPA

Olá tudo bem?

Vamos falar hoje sobre uma ferramenta muito importante chamada Cobertura. Esse framework tem a mesma função de cobertura de testes que o framework Emma, já mostrado aqui.

A diferença é que a tela inicial do framework Cobertura nos mostra os dados de um modo mais gráfico.

Caso você queira ver os outros posts sobre esse assunto,basta clicar nos links a seguir: Cobertura de testes com JUnit Ant e Emma, JUnit com HSQLDB, JPA e Hibernate, Primeiros passos.

Vou utilizar exatamente o código do post JUnit com HSQLDB, JPA e Hibernate. Caso você queira montar o ambiente corretamente, basta fazer o passo a passo que se encontra lá (no fim do post você irá encontrar o código fonte para download).
Eu não sou um usuário habilidoso do ant, você poderá ver algum código e pensar: “ele poderia ter usado o comando xyk”. Fique a vontade para sugerir. ;)

Vamos fazer o download da biblioteca do framework Cobertura – Download1.9.4.1Faça o download e coloque todos os arquivos jars (/cobertura.jar, /lib/* que tem os arquivos asm, jakarta, log4j) dentro na pasta lib do nosso projeto.

Na raiz do seu projeto crie um arquivo chamado “build.xml”com o seguinte código (tem que estar exatamente na raiz do projeto para funcionar):

<project name="Cobertura Coverage" basedir=".">

    <!--  Project Source  Code -->
    <property name="src.dir" value="src" />
    <property name="build.dir" value="bin" />
    <property name="teste.dir" value="src/test" />
    <property name="lib.dir" value="lib" />
    <property name="report.dir" value="cobertura" />

    <!-- Project classpath -->
    <path id="project.classpath">
        <pathelement location="${bin.dir}" />
        <fileset dir="${lib.dir}">
            <include name="*.jar" />
        </fileset>
    </path>

    <!-- Tested Class -->
    <property name="DogFacadeTest" value="test.com.facade.DogFacadeTest" />

</project>

No código acima, estamos apenas declarando os caminhos para o código fonte e as bibliotecas.

Agora vamos criar uma tarefa que irá apagar arquivos criados pelo framework Cobertura e pela compilação do nosso projeto.

<!-- Clears the paths -->
<target name="01-CleannUp" description="Remove all generated files.">
    <delete dir="${build.dir}" />
    <delete file="cobertura.ser" />
    <delete dir="${report.dir}" />

    <mkdir dir="${build.dir}" />
    <mkdir dir="${report.dir}" />
</target>

E para compilar seu código Java, adicione o código abaixo e depois execute para ter a certeza de que está compilando:

<!-- Compiles the Java code -->
<target name="02-Compile" depends="01-CleannUp" description="invoke compiler">
    <javac debug="true" debuglevel="vars,lines,source" srcdir="${src.dir}" destdir="${build.dir}">
        <classpath refid="project.classpath" />
    </javac>
    <copy file="${src.dir}/META-INF/persistence.xml" todir="${build.dir}/META-INF" />
</target>

Vamos configurar o framework Cobertura para que ele possa instrumentar as classes de testes e já preparar o ambiente:

<!-- Cobertura configs -->
<property name="cobertura.instrumented-classes.dir" value="${report.dir}/instrumented-classes" />
<property name="cobertura.data.file" value="cobertura.ser" />
<path id="cobertura.classpath">
    <fileset dir="${lib.dir}" includes="/*.jar" />
</path>

<!-- Points to the cobertura jar -->
<taskdef classpath="${lib.dir}/cobertura.jar" resource="tasks.properties" classpathref="cobertura.classpath" />

<!-- Instruments the classes -->
<target name="03-Instrument" depends="02-Compile">
    <delete quiet="false" failonerror="false">
        <fileset dir="${cobertura.instrumented-classes.dir}" />
    </delete>
    <delete file="${cobertura.data.file}" />
    <cobertura-instrument todir="${cobertura.instrumented-classes.dir}">
        <fileset dir="${build.dir}">
            <include name="**/*.class" />
            <exclude name="**/*Test.class" />
        </fileset>
    </cobertura-instrument>
    <copy todir="${cobertura.instrumented-classes.dir}">
        <fileset dir="${src.dir}" casesensitive="yes">
            <patternset id="resources.ps" />
        </fileset>
    </copy>
</target>

Adicione o código abaixo e vamos executar o JUnit pelo “ant.xml”:

<!-- Set up the instrumented classes path -->
<path id="cover-test.classpath">
    <fileset dir="${lib.dir}" includes="**/*.jar" />
    <pathelement location="${cobertura.instrumented-classes.dir}" />
    <pathelement location="${build.dir}" />
</path>

<!-- Run the JUnit test -->
<target name="04-RunTest" depends="03-Instrument" >
    <junit printsummary="yes" haltonerror="no" haltonfailure="no"  fork="yes">
        <batchtest>
            <fileset dir="${build.dir}" includes="**/*Test.class" />
        </batchtest>
        <classpath refid="cover-test.classpath" />
    </junit>
    <delete file="transaction.log" />
</target>

E por último, vamos executar gerar nosso relatório. Adicione o código abaixo ao “build.xml” e execute a task.

<!-- Creates the Cobertura report -->
<target name="00-CreateReport" depends="04-RunTest">
    <cobertura-report srcdir="${cobertura.data.file}" destdir="${report.dir}">
        <fileset dir="${src.dir}">
            <include name="**/*.java" />
        </fileset>
    </cobertura-report>
    <delete dir="${report.dir}/instrumented-classes" />
    <delete file="cobertura.ser"  />
</target>

Atualize seu projeto no Eclipse (F5 no projeto) e você verá que os arquivos do relatório foram criados com sucesso. Abra o arquivo “index.html” que estará dentro da pasta cobertura.

O framework Cobertura inclusive mostra quantas vezes você tem que testar um método. Como desafio, escreva o método equals da classe Dog,gere o relatório só para você conferir que não está sendo coberto. E crie seus testes e olhe depois a cobertura do seu método como ficou.

Você poderá fazer o download do código do post de hoje.

Qualquer dúvida/comentário basta postar.

Até a próxima! \o_