Blog da KondutoDevelopers

Cobertura de código em projetos Java multi-módulo

Por 18 de abril de 2019 Maio 20th, 2019 Nenhum comentário

Olá! Damos as boas-vindas ao primeiro artigo do nosso time de developers da Konduto!

Temos uma equipe apaixonada por tecnologia e apaixonada por aprender, ensinar, compartilhar conhecimento – você já deve ter lido um pouquinho sobre alguns de nós na série Quem faz a Konduto.

Pois bem… mas como compartilhar o conhecimento que nasce nas nossas reuniões de dev e nas nossas reuniões de daily? Bom, o Blog da Konduto é o canal de comunicação mais importante da nossa empresa, e por isso pedimos uma licencinha para o pessoal do marketing para, periodicamente, escrevermos alguns artigos para a nossa comunidade de programadores, desenvolvedores e maníacos por tecnologia.

O pessoal topou, e agora temos a nossa seção aqui no blog! Espero que gostem!

Introdução

Todos sabem que não tem como ter um código de qualidade sem testes automatizados. E, para garantir o bom funcionamento da aplicação, mais importante do que ter testes é ter testes de qualidade. Como saber que os testes que escrevi para a minha aplicação são suficientes? Esta é uma longa discussão, já que podemos olhar para a qualidade de código a partir de vários ângulos diferentes, desde os requisitos de negócio, passando por aspectos técnicos e comportamento do usuário.

Um destes ângulos é a cobertura de código. Ou seja, o quanto do seu código está coberto por testes. Mais especificamente: quantas e quais instruções da aplicação são visitadas durante os testes. Apenas garantir que o código está coberto por testes não vai te salvar de todos problemas, mas já é um primeiro passo em direção a menos bugs.

Para Java existem uma porção de libs que calculam a cobertura automaticamente para você. O que vamos mostrar aqui é como configurar cobertura de testes em um projeto Java, especialmente para o caso em que a aplicação é composta de múltiplos módulos.

Aqui vamos assumir que você está utilizando o Maven como gerenciador de projeto. Um projeto Java multi-módulo gerenciado pelo Maven possui uma estrutura de diretórios similar a abaixo:

sample-project/
 ├── module1/
 │ ├── src/
 │ │ ├── main/
 │ │ └── test/
 │ └── pom.xml
 ├── module2/
 │ ├── src/
 │ │ ├── main/
 │ │ └── test/
 │ └── pom.xml
 └── pom.xml

Temos a pasta raiz sample-project, ela tem um arquivo Maven pom.xml que descreve o projeto geral. E vemos dois módulos module1 e module2. Cada um com seu respectivo pom.xml, e onde src/ é guarda o código da aplicação e test/ o código de teste. A cobertura de testes é quanto os testes em test/ cobrem o código contido em src/.

Vale lembrar que nesta estrutura toda dependência e tarefa Maven definida no pom.xml raiz é replicada em todos os módulos por padrão (a não ser que explicitado o contrário).

Se você quiser saber mais sobre projetos multi-módulo em Maven, este artigo cobre mais detalhes sobre o assunto.

– Para os apressados, colocamos o projeto acima já configurado com cobertura neste repositório.

Calculando a cobertura de código com o JaCoCo

O JaCoCo é um dentre vários sistemas que sabe calcular a cobertura de código de uma suíte de testes Java. Além de te dar a porcentagem do código coberto por testes, ele fornece uma porção de outros indicadores interessantes, como porcentagem das ramificações do código (if/else, for etc) visitadas, classes, métodos, etc.

O primeiro passo é adicionar o plugin do JaCoCo no pom.xml do diretório raiz. É importante que a dependência seja adicionada com escopo test para garantir que ela só seja incluída durante a execução dos testes:

xml
<properties>
 <jacoco.version>0.8.3</jacoco.version>
</properties>

<dependencies>
 ... demais dependências ...
 <dependency>
 <groupId>org.jacoco</groupId>
 <artifactId>jacoco-maven-plugin</artifactId>
 <version>${jacoco.version}</version>
 <type>maven-plugin</type>
 <scope>test</scope>
 </dependency>
</dependencies>

Em seguida, configuramos para o JaCoCo ser iniciado e executado durante a etapa de build usando a configuração mais básica possível:

xml
<build>
 <plugins>
 <plugin>
 <groupId>org.jacoco</groupId>
 <artifactId>jacoco-maven-plugin</artifactId>
 <version>${jacoco.version}</version>
 <executions>
 <execution>
 <id>default-prepare-agent</id>
 <goals>
 <goal>prepare-agent</goal>
 </goals>
 </execution>
 <execution>
 <id>default-report</id>
 <goals>
 <goal>report</goal>
 </goals>
 </execution>
 </executions>
 </plugin>
 </plugins>
</build>

O passo default-prepare-agent inicia o sistema do JaCoCo. O passo default-report executa o JaCoCo para gerar o relatório de cobertura padrão. O JaCoCo possui várias de opções e tipos de relatórios dependendo da sua necessidade. Neste link você encontra a explicação do que é cada uma das configurações possíveis do plugin Maven do JaCoCo.

O relatório básico gerado pelo JaCoCo vem em um formato pouco amigável para leitura humana, otimizado para parseamento programático. Para a nossa sorte, o JaCoCo vem com uma função que consegue transformar este relatório em uma página HTML de fácil visualização, contendo todos os indicadores calculados, como porcentagem de instruções/classes/métodos/ramificações cobertas.

Para gerar o relatório em HTML, inclua na etapa reporting do pom.xml o plugin do JaCoCo com a seguinte configuração:

xml
<reporting>
 <plugins>
 <plugin>
 <groupId>org.jacoco</groupId>
 <artifactId>jacoco-maven-plugin</artifactId>
 <version>${jacoco.version}</version>
 <reportSets>
 <reportSet>
 <reports>
 <report>report</report>
 </reports>
 </reportSet>
 </reportSets>
 </plugin>
 </plugins>
</reporting>

Pronto! Quando você buildar o projeto via mvn install serão gerados os reports de cada módulo nos diretórios seus respectivos diretório target/site/. Acesse os links abaixo para visualizar os relatórios em HTML:

sample-project/module1/target/site/jacoco/index.html

sample-project/module2/target/site/jacoco/index.html

Agregando a cobertura do projeto em relatório único

Você deve ter percebido que, seguindo os passos acima, geramos um relatório para cada módulo. Isso já ajuda, mas não é tão prático para visualizar o projeto todo. Existe um jeito de agregar os relatórios gerados em um único HTML. A partir da versão 0.7.7, o JaCoCo vem com um método que sabe fazer essa agregação: jacoco:report-aggregate.

Quando chamado, este método busca dentro do diretório de todas as dependências do módulo buildado por relatórios de cobertura e os agrega em um relatório único. Perceba que ele só sabe agregar relatórios de módulos listados entre as <dependencies> do projeto.

Portanto, a estratégia que vamos usar aqui é criar um módulo especial que tem como dependências todos os demais módulos do projeto. Vamos chamar este módulo de coverage. Para criar este módulo, digite o comando abaixo a partir do diretório raiz do projeto:

mvn archetype:generate \
 -DarchetypeGroupId=org.apache.maven.archetypes \
 -DarchetypeArtifactId=maven-archetype-quickstart \
 -DarchetypeVersion=RELEASE

Ele vai te pedir alguns inputs, como groupId, artifactId e a versão do módulo. No nosso exemplo demos o nome de coverage ao artifactId.

Agora a estrutura de diretórios do seu projeto deve se parecer com a seguinte:

sample-project/
 ├── module1/
 │ ├── src/
 │ └── pom.xml
 ├── module2/
 │ ├── src/
 │ └── pom.xml
 ├── coverage/
 │ ├── src/
 │ └── pom.xml
 └── pom.xml

Adicione os demais módulos do projeto como dependências do coverage no coverage/pom.xml:

xml
 <dependencies>
 <dependency>
 <groupId>com.konduto</groupId>
 <artifactId>module1</artifactId>
 <version>1.0-SNAPSHOT</version>
 <scope>provided</scope>
 </dependency>
 <dependency>
 <groupId>com.konduto</groupId>
 <artifactId>module2</artifactId>
 <version>1.0-SNAPSHOT</version>
 <scope>provided</scope>
 </dependency>
 </dependencies>

Configure a tarefa jacoco:report-aggregate para rodar durante a etapa build no coverage/pom.xml:

xml
 <build>
 <plugins>
 <plugin>
 <groupId>org.jacoco</groupId>
 <artifactId>jacoco-maven-plugin</artifactId>
 <version>${jacoco.version}</version>
 <executions>
 <execution>
 <id>report-aggregate</id>
 <phase>prepare-package</phase>
 <goals>
 <goal>report-aggregate</goal>
 </goals>
 <configuration>
 <title>JaCoCo</title>
 <footer>Code Coverage Report for JaCoCo ${project.version}</footer>
 </configuration>
 </execution>
 </executions>
 </plugin>
 </plugins>
 </build>

Pronto. Da próxima vez que você rodar um mvn install no diretório raiz você deve ver o relatório completo de cobertura do projeto no endereço abaixo:

sample-project/coverage/target/site/jacoco-aggreagate/index.html

Sempre que novos módulos forem criados dentro do projeto lembre-se de adicioná-los como dependência do projeto coverage. Além disso, você deve garantir que o módulo coverage seja sempre o último a ser buildado. Ou seja, que na entrada <modules> no pom.xml raiz, o projeto coverage sempre seja último:

xml
 <modules>
 <module>module1</module>
 <module>module2</module>
 <module>coverage</module> <!-- Deve ser sempre o último -->
 </modules>

Veja o projeto completo na minha página do Gitlab!

Como foi sua experiência configurando cobertura de código no seu projeto? Você teve algum problema inesperado, ou descobriu algo que pode ter ficado de fora? Este passo a passo só funciona no Maven, sabe como funcionaria no Gradle? Conta para a gente nos comentários como foi, ou entre em contato diretamente com a gente no oi@konduto.com.

Newsletter da Konduto

Adriano Oliveira

Autor Adriano Oliveira

Adriano integra o time de desenvolvimento da Konduto desde o primeiro dia da empresa. Líder de tecnologia, ele gosta de máquinas, mas gosta mais de pessoas.

Mais posts de Adriano Oliveira