A Magia dos Testes Automatizados.

A parte final dos três posts falando sobre testes. Vamos ver uma poderosa ferramenta de automação que é o Apache Ant.

O ANT trabalha através de tarefas, que são especificadas através de um arquivo XML chamado buildfile, onde ao editamos este arquivos definindo as tarefas que desejamos que ele faça, como por exemplo:

Criarmos pastas no sistema operacional, pastas que poderemos usar por exemplo para colocar os executáveis da aplicação que estamos desenvolvendo;

Compilarmos recursivamente todos os fontes na pasta dos arquivos fontes de nosso projeto, colocando na pasta dos executáveis;

Copiarmos arquivos, deletarmos arquivos, listarmos arquivos;

Fazer conexões com bancos de dados, utilizarmos comandos do sistema, fazer log de nossos projetos, dentre várias outras tarefas.

O que demonstrarei é como o Ant automatiza tarefas necessárias para que sua aplicação esteja pronta para a implantação, distribuição, etc. Nesse post, abordaremos as seguintes tarefas a serem executadas:

  • Deleção e criação de diretórios.

  • Definir as libs que serão incluídas no projeto.

  • Compilar suas classes.

  • Definir seus testes e executá-los.

  • E o objetivo final, que é gerar o arquivo .war.

Aproveitando a estrutura do projeto já desenvolvido nos outros posts, <link aqui referenciando os posts antigos>vamos criar o arquivo build.xml na raiz do projeto. A estrutura do arquivo xml segue uma estrutura uniforme, mais ou menos dessa forma:

<project name="nome_projeto" basedir="." default="alvo1">

        <target name="alvo1">

             <tarefa1 />

             <tarefa2 />

        </target>

        <target name="alvo2">

              <tarefa1 />

              <tarefa2 />

        </target>

        <target name="alvo3">

              <tarefa1 />

        </target>
</project>
A raiz do arquivo é o elemento project, que possui os atributos name(nome do projeto, ah vá..),basedir(O diretório base a partir do qual os demais caminhos para arquivos e diretórios serão calculados. O “.” se refere ao diretório atual), default(Se você executar o Ant via Terminal e não for especificado nenhum alvo, o alvo declarado aqui será executado).

Os elementos filhos, que são os target, e neles podem possuir uma ou mais tarefas(tasks) a serem executadas (novamente – criar, renomear ou excluir diretórios, compilar e empacotar arquivos, etc. ).

Pois bem, vamos ao “jeitão” do nosso XML. Vamos listar as tarefas que serão executadas e algumas particularidades:

1.Declaro meu classpath (as libs que serão utilizadas no meu projeto).
<path id="classpath">
        <pathelement location="${classes.dir}" />
        <fileset dir="${lib.root}">
              <include name="*.jar" />
        </fileset>
</path>
2.Target, ele exclui o diretório que é criado pelo ant (target). E serão recriados os diretorios onde serão armazenados as classes compiladas e os testes compilados, respectivamente.
<target name="clean">
      <delete dir="${target.dir}"/>
      <mkdir dir="${classes.dir}"/>
      <mkdir dir="${test.classes.dir}"/>
</target>
3. Target, as classes e os testes serão compilados e “jogados” para seus respectivos diretórios, que foram criados no target anterior.
<target name="compile" depends="clean">
        <javac srcdir="${basedir}" destdir="${classes.dir}" >
         <classpath>
            <path refid="classpath"/>
         </classpath>
        </javac>
     <!-- Compila Test classes -->
        <javac destdir="${test.classes.dir}" srcdir="${test.source.dir}">
      <classpath>
              <path refid="classpath"/>
      </classpath>
        </javac>
</target>
4.Próximo target, onde será executado os testes. O Ant gerará um relatório, no formato que você definir na tag “formatter”, armazenando em algum diretório de sua preferência. Adicionamos o classpath novamente e definimos o batchtest (no qual todas as classes com o padrão **/**Teste.java, serão reconhecidas como classe de teste e executadas como tal).
<target name="teste" depends="test-mysql">
        <mkdir dir="${test.report.dir}"/>
        <junit printsummary="on" fork="no" haltonfailure="true" haltonerror="true">
              <sysproperty key="basedir" value="." />
              <formatter type="xml" />
              <classpath refid="classpath"/>
              <batchtest todir="${test.report.dir}">
                    <!-- Unit Tests -->
                    <fileset dir="${test.source.dir}/unit">
                           <include name="${test.source.dir}/unit/${test.pattern}" />
                    </fileset>
                    <!-- Integration Tests -->
                    <fileset dir="${test.source.dir}/integration">
                           <include name="${test.source.dir}/integration/${test.pattern}" />
                    </fileset></p>

              </batchtest>
       </junit>
</target>
5.Por fim, se todas as etapas forem construídas sem erros e os testes passarem, então criaremos o arquivo .war para realizar o deploy no servidor.
<target name="buildwar" depends="teste">
         <javac srcdir="${basedir}" destdir="${classes.dir}">
               <classpath refid="classpath"/>
         </javac>

         <mkdir dir="${war.dir}" />
         <war destfile="${war.dir}/VRaptorTestesAutomatizados.war" webxml="${web.xml}">
              <classes dir="${classes.dir}" />
              <lib dir="${lib.root}"></lib>
              <fileset dir="WebRoot/">
                   <include name="META-INF/**"/>
                   <include name="*.jsp" />
                   <include name="*.html" />
              </fileset>
         </war>
</target>
*Todos os caminhos ${alguma-coisa} está definido no arquivo build.properties, definido na segunda linha.
Rodando o seu script Buildfile, vamos ao resultado no console:
E ao final, como prova que realmente você fez o que tinha que fazer :). Fiz o deploy no servidor e vamos ao resultado no browser.
Sinal que sua aplicação deu certo. Compilamos nossas classes, fazemos nossos testes e geramos nosso .war. Isso é só um pouco que essa poderosa ferramenta, que é o Ant pode fazer. Até os próximos posts.
Seguir

Obtenha todo post novo entregue na sua caixa de entrada.