TDD Cobertura de testes com JUnit Ant e Emma

Olá pessoal, bom dia.

Quando escrevemos testes temos sempre a preocupação de saber se estamos testando toda nossa classe. Imagine só, testar 4 métodos e esquecer de simular um caso de teste que caia em uma Exception do Try/Catch?

Para solucionar esse problema existem ferramentas para cobrir seu teste, que irão informar por onde seu teste passou ou deixou de passar.

Vou falar sobre duas ferramentas para cobertura do seu teste Emma (no post de hoje) e Cobertura (no próximo post sobre TDD).

Vou usar exatamente o código deste post (TDD com HSQLDB, JPA e Hibernate). Se você quiser montar um ambiente, siga o que for descrito no post anterior e tudo irá funcionar 100%. Outro post sobre o assunto é: TDD – Primeiros passos.

Hoje iremos utilizar o framework Emma com Ant. Não sou um bom conhecedor ainda do Ant, então os códigos que “garimpei” pela internet talvez tenha alguma redundância ou coisa assim. Um dia irei melhorá-lo.

Vamos começar com os downloads:

O JUnit é utilizado apenas pelo o framework do Emma possa executar os testes.

Copie as bibliotecas do Emma e do JUnit para a pasta lib; não será necessário adicioná-los ao “Build Path” do projeto.

Crie um arquivo chamado “build.xml” na raiz do seu projeto (
o arquivo tem que ficar exatamente na raiz do projeto, ou então o script irá falhar)
.

Altera altere o arquivo para ficar com o seguinte código:

<project name="Emma Reports" basedir=".">

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

    <!-- Emma source code -->
    <property name="emma.bin.dir" value="emma/bin" />
    <property name="emma.metadate.dir" value="emma/metadate" />
    <property name="emma.report.dir" value="emma/report" />

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

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

    <!-- Emma task definitions that you will find inside the jar -->
    <taskdef resource="emma_ant.properties">
        <classpath refid="project.classpath" />
    </taskdef>

    <!-- JUnit task definition -->
    <taskdef name="junit" classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask" />

</project>

No arquivo build.xml estamos definindo as variáveis do script, os caminhos dos arquivos e o JUnit a ser executado.

Agora vá ao menu Window > Show View > Other. Digite Ante aperte Ok:


Arraste o arquivo para o dentro do da view do Ant. Duplo click no arquivo para executá-lo. A seguinte mensagem irá aparecer:

Caso a mensagem “Could not load definitions from resource emma_ant.properties. It could not be found.” É por que o caminho da sua lib está errado. Verifique novamente se o seu arquivo“build.xml” está na raiz do projeto. Não prossiga sem resolver esse problema de path.

Vamos alterar nosso “build.xml” e fazer com que ele a partir de agora compile nosso código java. Ele tem dois passos (ações chamadas de “target”).

    <!-- Clean UP Your Code -->
    <target name="01-CleanUp">
        <delete dir="${bin.dir}" />
        <mkdir dir="${bin.dir}" />
    </target>

    <!-- Compile Your Code -->
    <target name="02-CompileSourceCode" depends="01-CleanUp">
        <javac debug="on" srcdir="${src.dir}" destdir="${bin.dir}">
            <classpath refid="project.classpath" />
        </javac>
        <copy file="${src.dir}/META-INF/persistence.xml" todir="${bin.dir}/META-INF" />
    </target>

Perceba que temos as ações “01-CleanUp” e “02-CompileSourceCode”onde a ação de compilar “depends” da ação de limpar o código, com isso, toda vez que você quiser compilar o projeto o Ant irá executar a ação de limpar automaticamente.

Vamos gerar agora a task com uma palavra que você irá ouvir muito, Instrumentação. Falando vagamente, o Emma ele é bytecode instrumentado,ou seja, ele não necessita de adaptações ou alterações na JVM para mensurar o seu código. Ele analisa o seu bytecode e pronto.

Vamos alterar o build.xml e adicionar a task:

    <!-- Generate the Emma  -->
    <target name="03-Instrumentation" depends="02-CompileSourceCode">
        <emma>
            <instr instrpath="${bin.dir}" destdir="${emma.bin.dir}" metadatafile="${emma.metadate.dir}/metadate.emma" merge="false" mode="fullcopy" />
        </emma>
    </target>

Vamos criar agora, a chave que irá compilar e executar o teste JUnit:

    <!-- Runs JUnit Tests -->
    <target name="04-RunTests" depends="03-Instrumentation">
        <junit haltonfailure="false" haltonerror="false" fork="true">
            <classpath>
                <pathelement location="${emma.bin.dir}/classes" />
                <pathelement location="${emma.bin.dir}/lib" />
                <path refid="project.classpath" />
            </classpath>
            <formatter type="plain" usefile="false" />
            <test name="${DogFacadeTest}" />
            <jvmarg value="-Demma.coverage.out.file=${emma.metadado.dir}/cobertura.emma" />
            <jvmarg value="-Demma.coverage.out.merge=false" />
        </junit>
    </target>

Execute o teste e veja que o nosso teste não retornou erro:

Vamos criar agora o nosso gerador de relatório:

    <!-- Creates the report -->
    <target name="00-GenerateReport" depends="04-RunTests">
        <delete dir="${emma.report.dir}" />
        <emma enabled="true">
            <report sourcepath="${src.dir}" sort="+block,+name,+method,+class" metrics="method:70,block:80,line:80,class:100">
                <fileset dir="${emma.metadate.dir}">
                    <include name="*.emma" />
                </fileset>
                <html outfile="${emma.report.dir}/report.html" depth="method" columns="name,class,method,block,line" />
            </report>
        </emma>
    </target>

Execute a tarefa de Gerar relatório e abra o arquivo que irá aparecer em “
/emma/report/report.html
”.


E por ultimo vamos apagar os arquivos que foram gerados para que o relatório fosse extraído.

Altere a task para gerar relatório e vamos criar uma task que irá ser chamada automaticamente pelo Ant após gerar um relatório:

    <!-- Creates the report -->
    <target name="00-GenerateReport" depends="04-RunTests">
        <delete dir="${emma.report.dir}" />
        <emma enabled="true">
            <report sourcepath="${src.dir}" sort="+block,+name,+method,+class" metrics="method:70,block:80,line:80,class:100">
                <fileset dir="${emma.metadate.dir}">
                    <include name="*.emma" />
                </fileset>
                <html outfile="${emma.report.dir}/report.html" depth="method" columns="name,class,method,block,line" />
            </report>
        </emma>

        <antcall target="05-DeleteOldReportData" />
    </target>

    <!-- Delete Old Report Data -->
    <target name="05-DeleteOldReportData">
        <delete dir="${emma.bin.dir}" />
        <delete dir="${emma.metadate.dir}" />
    </target>

Click aqui para fazer o download do tutorial de hoje.
Espero que esse post possa te ajudar.

Qualquer dúvida ou comentário, basta colocar.

Inté+! o_

OBS.: Fonte de pesquisa:

Leave a Comment