A cobertura de código é uma métrica de qualidade de software comumente utilizada durante o processo de desenvolvimento que permite determinar o grau de código que foi testado (ou executado). Para alcançar uma cobertura de código ideal, é essencial que a implementação de testes (ou suites de teste) teste a maioria percentual do código implementado.
Existem várias ferramentas de cobertura de código para linguagens como Java, C#, JavaScript, etc. Usar a ferramenta de cobertura de código mais adequada é importante para entender a porcentagem de código testado e tomar as ações apropriadas para garantir que você alcance a cobertura de código ideal.
Para testes de código otimizados, muitas empresas utilizam o plugin JaCoCo-Maven, que ajuda a gerar relatórios detalhados de cobertura de código. O plugin JaCoCo-Maven é uma biblioteca de cobertura de código gratuita para projetos Java. Baseia-se na análise de bibliotecas de integração existentes criadas pela equipe EclEmma. Em maior extensão, a cobertura de código fornece uma visão geral breve da qualidade do produto, pois quanto maior a cobertura, menor são as chances de código não testado entrar no ciclo de lançamento.
Neste artigo, aprenderemos mais sobre o plugin JaCoCo-Maven e como esse plugin é implementado usando Maven. Também integraremos um projeto Maven e geraremos um relatório detalhado de cobertura de código para os testes executando Selenium.
O que é Cobertura de Código?
No desenvolvimento de software, a cobertura de código é uma medida usada para descrever o grau em que o código-fonte de um aplicativo é executado quando uma suite de testes é executada. Um relatório é gerado para visualizar e analisar a cobertura de código de um aplicativo de software. Esse relatório de cobertura de código pode então ser usado para garantir a qualidade do código.
O plugin JaCoCo-Maven é utilizado para gerar relatórios de cobertura de código. O código-fonte com alta cobertura de código tem mais de seus códigos executados durante os testes. Por exemplo, se o software que você está testando contém 100 linhas de código e o número de linhas de código validadas no software é 90, então a porcentagem de cobertura de código desse aplicativo de software será de 90%.
Benefícios da Cobertura de Código
A cobertura de código é uma métrica muito útil para desenvolvedores, testadores e engenheiros de QA. Aqui estão alguns dos benefícios notáveis da cobertura de código:
- Os relatórios de cobertura de código fornecem insights úteis na detecção e eliminação de código morto. Isso pode ser evitado seguindo as melhores práticas de implementação, o que, por sua vez, resulta em maior manutenibilidade do código e melhor qualidade do produto.
- A garantia de qualidade pode ajudar a detectar código que não foi coberto usando a implementação de teste.
- Os desenvolvedores podem concluir o processo de desenvolvimento de software mais rapidamente, aumentando sua produtividade, escalabilidade e eficiência. Isso resulta em redução do Tempo para Mercado (TTM).
Como sabemos, a cobertura de código é muito importante para todos os produtos de software. Agora que fizemos um rápido resumo sobre os aspectos integrantes da cobertura de código, vamos mergulhar profundamente no tópico principal, ou seja, gerar relatórios de cobertura de código usando o plugin JaCoCo-Maven.
O que é o Plugin JaCoCo-Maven?
O plugin JaCoCo-Maven (abreviação para Java Code Coverage) é uma ferramenta de código aberto para cobertura de código em Java. Ele cria relatórios de cobertura de código e se integra bem com IDEs (ambientes de desenvolvimento integrado), como o Eclipse IDE.
Também se integra perfeitamente com ferramentas de CI/CD (por exemplo, Jenkins, Circle CI, etc.) e ferramentas de gerenciamento de projetos (por exemplo, SonarQube, etc.). Faz parte da Fundação Eclipse e substituiu a ferramenta de cobertura de código EclEmma no Eclipse.
Como Funciona o Plugin JaCoCo-Maven?
- O plugin JaCoCo-Maven executa a cobertura instrumentando o código Java por meio de um agente de runtime. Em termos simples, você anexa esse agente a uma JVM (Java Virtual Machine) quando ela inicia. Esse agente é chamado de agente JaCoCo. O primeiro start-agent de execução inicia esse agente de runtime JaCoCo.
- Sempre que uma classe é carregada, o JaCoCo pode instrumentar a classe para que possa ver quando a classe é chamada e quais linhas (de código) são chamadas durante o processo de teste. Mantendo esse rastreamento, ele constrói as estatísticas de cobertura de código, que são feitas em tempo real durante a segunda execução (ou seja, generate-report).
- Por padrão, o arquivo é criado assim que a JVM é encerrada, mas também é possível executar o agente no modo servidor. Isso aciona um dump dos resultados e o relatório é criado antes do encerramento. Abaixo estão os internos do plugin JaCoCo:
- Você pode definir metas e regras na configuração do plugin JaCoCo-Maven. Isso oferece a flexibilidade de definir limites e ajuda a verificar a quantidade de cobertura de código.
- O plugin Maven-surefire é o plugin padrão do Maven. Isso executa os testes na JVM e fornece relatórios de cobertura. Enquanto o plugin JaCoCo instrumenta o código já executado por um plugin (por exemplo, plugin Surefire). Portanto, é uma boa prática verificar a dependência do plugin maven-surefire.
Por que o Plugin JaCoCo-Maven é bom para cobertura de código?
O plugin JaCoCo-Maven é adequado para cobertura de código por causa dos seguintes motivos:
- Ao trabalhar em qualquer projeto, os desenvolvedores preferem principalmente IDEs porque simplificam a experiência de codificação e teste. O JaCoCo pode ser instalado no Eclipse IDE com o nome de EclEmma, baixando o EclEmma da sua marketplace.
- É fácil adicionar o plugin JaCoCo a todos os tipos de builds, incluindo ANT, Maven e Gradle. Também pode ser integrado com ferramentas de CI/CD como Jenkins, Circle CI, etc. Isso o torna versátil para muitos casos de uso.
- O relatório de cobertura de código gerado pelo JaCoCo é um arquivo HTML simples e informativo que pode ser visualizado em qualquer navegador ou IDE.
- O JaCoCo também oferece instrumentação offline (ou seja, todas as classes são instrumentadas antes de executar quaisquer testes).
- A análise de um relatório também é bastante fácil, pois é baseada em cores e fornece a porcentagem exata de cobertura de código.
Como configurar o Plugin JaCoCo com Maven
Para obter relatórios de cobertura de código em um projeto Maven, primeiro precisamos configurar o plugin JaCoCo Maven para esse projeto. Ao integrar o plugin JaCoCo, os resultados da análise de cobertura de código podem ser revisados como um relatório HTML. A versão atual do plugin JaCoCo-Maven pode ser baixada do repositório MVN.
Aqui estão os passos para integrar o plugin JaCoCo Maven com um projeto Maven:
1. Todo projeto Maven possui um arquivo pom.xml, utilizado para declarar todas as dependências e plugins. O plugin JaCoCo-Maven é declarado no mesmo arquivo POM.xml. O código XML para o mesmo é:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
</plugin>Este é o código XML básico adicionado sob a tag de build para especificar o plugin JaCoCo em um projeto baseado em Maven. Podemos aprimorar a funcionalidade (como mencionar quando um relatório deve ser gerado, etc.) especificando objetivos e regras na tag de execução.
2. Após a tag de versão, adicionamos a tag de execução. Esta tag prepara as propriedades ou execução para apontar para o agente JaCoCo e é passada como argumento VM (neste caso, JVM).
3. Para executar testes unitários simples, dois objetivos definidos nas tags de execução funcionarão bem. O mínimo necessário é configurar os objetivos prepare-agent e report.
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>- Objetivo prepare-agent: O objetivo prepare-agent prepara o agente de runtime JaCoCo para gravar os dados de execução. Ele registra o número de linhas executadas, rastreadas, etc. Por padrão, os dados de execução são escritos no arquivo
target/jacoco-ut.exec. - Objetivo report: O objetivo report cria relatórios de cobertura de código a partir dos dados de execução gravados pelo agente de runtime JaCoCo. Como especificamos a propriedade de fase, os relatórios serão criados após a compilação da fase de teste. Por padrão, os dados de execução são lidos do arquivo
target/jacoco-ut.exec, e o relatório de cobertura de código é escrito na pastatarget/site/jacoco/index.html.
4. Para executar testes unitários simples, a configuração acima funciona bem. No entanto, precisaríamos de colocar restrições nos relatórios de cobertura de código (por exemplo, especificar o diretório de destino, etc). Isso pode ser feito através de uma tag de configuração:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
<propertyName>surefireArgLine</propertyName>
</configuration>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
<configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>Configuração da Primeira Execução
De acordo com o código acima, você pode ver algumas tags, como destFile, etc., especificadas. Aqui está uma breve descrição das tags:
destFiletag: A tagdestFileé usada para definir o caminho até o arquivo contendo os dados de execução.propertyName-surefireArgLinetag: Esta tag define o nome da propriedade que contém as configurações para o agente de runtime JaCoCo. Isso também define a linha de argumento do VM quando os testes unitários são executados.
Configuração da Segunda Execução
De acordo com o código acima, você pode ver tags como dataFile, etc., especificadas. Aqui está uma breve descrição das tags:
dataFiletag: A tagdataFileé usada para definir o caminho até o arquivo contendo os dados de execução.outputDirectorytag: Esta tag define o diretório de saída para os relatórios de cobertura de código.
5. Também podemos adicionar regras à nossa tag de configuração para manter um controle sobre a porcentagem de cobertura de código. Isso pode ser feito como mostrado abaixo:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
<propertyName>surefireArgLine</propertyName>
</configuration>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
<configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
</configuration>
</execution>
<execution>
<id>jacoco-check</id>
<goals>
<goal>check</goal>
</goals>
<configuration>
<rules>
<rule>
<element>PACKAGE</element>
<limits>
<limit>
<counter>LINE</counter>
<value>COVEREDRATIO</value>
<minimum>0.50</minimum>
</limit>
</limits>
</rule>
</rules>
</configuration>
</execution>
</executions>
</plugin>Configuração da Terceira Execução
Aqui, um novo objetivo de verificação é definido. O objetivo jacoco:check está vinculado para verificar a regra especificada. A regra é fornecida no tag de regra. Você tem a flexibilidade de especificar mais de uma regra.
- Tag de Elemento: Este tag especifica o elemento no qual a regra deve ser aplicada.
- Tag de Limite: Tags como counter, value, minimum, etc., são usadas para limitar a porcentagem de cobertura de código. Um comando como mvn clean verify pode ser usado para garantir se a regra é seguida ou não.
6. Existem múltiplos objetivos e regras que podem ser definidos na configuração do plugin JaCoCo-Maven.
Relatórios de Cobertura de Código Usando Maven e o Plugin JaCoCo
Nesta seção, demonstraremos os passos para gerar o relatório de cobertura de código usando o plugin JaCoCo Maven. A demonstração é feita tomando um cenário de teste muito simples. Então, vamos começar.
Pré-requisitos
- Maven 3.0 ou superior: Maven é uma ferramenta de gerenciamento e compreensão do desenvolvimento de projetos. Você pode instalar a versão mais recente no site oficial do Apache Maven.
- Java 1.5 ou superior: Você precisa garantir que Java esteja instalado em sua máquina. Caso não tenha o Java instalado, por favor, baixe a versão mais recente do Java no site oficial do Java.
- IDE Eclipse para Desenvolvedores Java: Embora você possa usar a IDE de sua preferência, para esta demonstração utilizamos a IDE Eclipse.
Passos para Criar um Projeto Maven Simples
- No IDE Eclipse, vá para Arquivo > Novo > Projeto Maven.
2. Uma nova caixa de diálogo aparece. Certifique-se de que a caixa de seleção “Use default Workspace location” está marcada e clique em “Next.”
3. Para selecionar o arquétipo no projeto, digite org.apache.maven no campo de texto localizado ao lado do filtro. Selecione maven-archetype-quickstart e clique em “Next.”
4. Agora, especifique o “Group Id” como com.example e o “Artifact Id” como jacoco-example. O “Artifact Id” é o nome do nosso projeto. Por fim, clique no botão “Finish.”
5. Você pode ver a hierarquia de arquivos e pastas no “Project Explorer.”
Como Especificar o Plugin JaCoCo Maven no POM.xml
1. Abra POM.xml, role até a tag. Vamos especificar o plugin JaCoCo-Maven na seção que lista os plugins Maven. Basta copiar o código abaixo e colá-lo na tag acima:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<!--first execution : for preparing JaCoCo runtime agent-->
<execution>
<id>prepare-agent</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<!--second execution : for creating code coverage reports-->
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>2. Como estamos demonstrando a geração de relatórios para testes web automatizados com JUnit, também declararemos a dependência JUnit em POM.xml.
Aqui está todo o conteúdo de POM.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>jacoco-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>jacoco-example</name>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- JUnit dependencies added to run test cases -->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Maven plugin for Project Management -->
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals><goal>prepare-agent</goal></goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals><goal>report</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>3. A partir do diretório do projeto, navegue até o pacote com.example.jacoco_lambdatest existente em src/main/java. Crie uma nova classe Java chamada LambdaTest.java. Escreveremos uma função simples setUp() nela que fornece as capacidades desejadas do Selenium Grid.
package com.example.Jacoco_lambdatest;
import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
public class LambdaTest {
public static String username = "<LambdaTest_Username>";
public static String accessKey = "<LambdaTest_AccessKey>";
public static DesiredCapabilities setUp() throws Exception {
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("platform", "Windows 10");
capabilities.setCapability("browserName", "Chrome");
capabilities.setCapability("version", "87.0"); // If this cap isn't specified, it will just get the any available one
capabilities.setCapability("resolution","1024x768");
capabilities.setCapability("build", "First Test");
capabilities.setCapability("name", "Sample Test");
capabilities.setCapability("network", true); // To enable network logs
capabilities.setCapability("visual", true); // To enable step by step screenshot
capabilities.setCapability("video", true); // To enable video recording
capabilities.setCapability("console", true); // To capture console logs
return capabilities;
}
}Adicionando Casos de Teste JUnit no Projeto
1. Criaremos um caso de teste simples com JUnit em AppTest.java. Isso é fornecido por padrão, no diretório src/test/java sob o nome do pacote com.example.jacoco_lambdatest.
package com.example.Jacoco_lambdatest;
import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import com.example.Jacoco_lambdatest.*;
public class AppTest {
public static RemoteWebDriver driver;
@Test
public void testScript1() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username =LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click(); driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}Gerando Relatórios de Cobertura de Código
1. Clique no botão “Run As” e configure como Maven Test.
2. Em vez disso, você pode abrir o cmd (Command Line), navegar até a pasta do projeto e executar o comando maven, “mvn test”.
3. Ao executar os testes JUnit, o agente JaCoCo será acionado automaticamente. Ele criará um relatório em formato binário na pasta target, com o caminho target/jacoco.exec. A saída de jacoco.exec não pode ser interpretada individualmente, mas outras ferramentas como SonarQube e plugins podem interpretá-la. Como especificamos anteriormente, o objetivo jacoco:report gerará relatórios de cobertura de código legíveis em formatos populares como HTML, CSV e XML.
4. Como a compilação foi bem-sucedida, vá até a pasta target, depois para a pasta site > jacoco. O relatório de cobertura de código (ou seja, index.html) está localizado em target/site/jacoco/index.html. O relatório se parece com isto:
5. Você pode aprofundar em um nível micro clicando em com.example.jacoco_lambdatest>LambdaTest no relatório.
6. Ao clicar em funções específicas, você terá uma visão mais detalhada em LambdaTest.java.
7. Aqui, você verá muitos diamantes de cores diferentes, como verde, amarelo e vermelho. Estas são as especificações utilizadas no relatório para simbolizar qual linha de código foi executada e quando ela foi executada. Vamos aprender mais sobre isso na próxima seção da análise do relatório. Com isso, você gerou com sucesso um relatório de cobertura de código através do plugin Jacoco Maven.
Análise do Relatório de Cobertura de Código
Nosso relatório de cobertura de código mostra 94% de cobertura de instruções e 100% de cobertura de ramificações, o que é uma ótima pontuação de cobertura de código. Mais tarde, tentaremos alcançar uma pontuação de 100% de cobertura de código adicionando mais casos de teste.
As 38 instruções mostradas por JaCoCo no relatório referem-se às instruções de bytecode em vez de instruções de código Java. Os relatórios JaCoCo ajudam você a analisar visualmente a cobertura de código usando diamantes com cores para ramos e cores de destaque de fundo para linhas. Uma breve explicação dos diamantes vistos no relatório de cobertura de código é a seguinte:
- Diamante vermelho; indica que nenhuma ramificação foi exercitada durante a fase de teste.
- Diamante amarelo: indica que o código está parcialmente coberto (ou seja, algumas ramificações não são exercitadas).
- Diamante verde: indica que todas as ramificações são exercitadas durante o teste
O mesmo código de cores se aplica ao destaque de cor de fundo para a cobertura de linha.
O relatório fornece principalmente três métricas cruciais:
- Cobertura de linha: Isso reflete a quantidade de código exercitado com base no número de instruções de bytecode Java chamadas pelos testes.
- Cobertura de ramificações: Isso mostra a porcentagem de ramos exercidos no código-fonte. Estes são típicos de instruções if/else ou switch.
- Complexidade ciclomática: Isso reflete a complexidade do código através do número de caminhos necessários para cobrir todos os caminhos possíveis em um código. Também se refere ao número de casos de teste necessários para implementar para cobrir todo o código. Como não há switch ou instrução no código, a complexidade ciclomática será um; apenas um caminho de execução é suficiente para cobrir todo o código.
Introduzindo Mais Casos de Teste para Melhorar a Cobertura do Código
1. Para alcançar uma melhor cobertura de código, é necessário introduzir mais testes que testem o código que não foi coberto anteriormente através da implementação de testes.
2. Vá para AppTest.java em src/test/java para adicionar mais casos de teste.
3. Os novos casos de teste adicionados a AppTest.java serão semelhantes a:
@Test
public void testScript2() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li2")).click();
driver.findElement(By.name("li3")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it to list"); driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
@Test
public void testScript3() throws Exception {
try {
DesiredCapabilities capabilities = LambdaTest.setUp();
String username = LambdaTest.username;
String accessKey = LambdaTest.accessKey;
RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities); driver.get("https://lambdatest.github.io/sample-todo-app/"); driver.findElement(By.name("li4")).click();
driver.findElement(By.id("sampletodotext")).clear(); driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it!");
driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}4. Vamos executar o relatório de cobertura do Maven JaCoCo para publicar um novo relatório de cobertura.
5. JaCoCo oferece uma maneira simples e fácil de rastrear a pontuação de cobertura de código declarando requisitos mínimos. A compilação falha se esses requisitos não forem atendidos, caso contrário, a compilação é bem-sucedida.
6. Esses requisitos podem ser especificados como regras em POM.xml. Basta especificar a nova execução especificando o objetivo ‘check’ em POM.xml. Adicione o código abaixo após a segunda tag <execution> em POM.xml.
<!--Third execution : used to put a check on the entire package-->
<execution>
<id>jacoco-check</id>
<goals>
<goal>check</goal>
</goals>
<configuration>
<rules>
<rule>
<element>PACKAGE</element>
<limits>
<limit>
<counter>LINE</counter>
<value>COVEREDRATIO</value>
<minimum>0.50</minimum>
</limit>
</limits>
</rule>
</rules>
</configuration>
</execution>7. Com isso, estamos limitando nossa razão de cobertura a 50%. Isso significa que pelo menos 50% do código deve ser coberto durante a fase de teste.
8. Você pode executar o Maven clean verify para verificar se as regras definidas no objetivo jacoco:check são cumpridas ou não.
9. O log mostra “Todas as verificações de cobertura foram cumpridas”, pois nossa pontuação de cobertura de código é de 94%, o que é maior do que nosso mínimo de 50%.
Teste Automatizado na Grade Selenium do LambdaTest
Usando Projeto Maven com o Plugin JaCoCo
Testes Selenium na nuvem ajudam a alcançar melhor cobertura de navegador, aumento na cobertura de testes e tempo de entrada no mercado acelerado. Testes paralelos no Selenium ajudam a alcançar os requisitos mencionados acima.
A Grade Selenium Cloud do LambdaTest é uma plataforma de testes Selenium escalável baseada na nuvem que permite executar seus scripts de automação em mais de 2000 navegadores e sistemas operacionais diferentes.
Pré-requisitos
Para executar o script de teste usando JUnit com Selenium, precisamos configurar um ambiente. Primeiro, você precisará criar uma conta no LambdaTest. Lembre-se de anotar o nome de usuário e a chave de acesso que estão disponíveis na seção de perfil do LambdaTest.
Usaremos este projeto de exemplo para testes Selenium em Java.
Importando o Projeto para o IDE Eclipse
Após baixar o arquivo zip do projeto: junit-selenium-sample do GitHub, importaremos para o IDE Eclipse seguindo os passos mencionados abaixo:
1. Acesse o seu IDE Eclipse, clique no menu “File” e selecione “Import”. Uma nova caixa de diálogo aparece.
2. Digite Maven na caixa de texto abaixo e selecione “Existing Maven Projects”, e então clique em “Next”.
3. Na próxima caixa de diálogo, clique em “Browse” e navegue até a pasta do projeto. Marque a caixa de seleção que fornece o caminho para o arquivo POM.xml, e clique em “Finish”.
4. Seu projeto será carregado com sucesso no IDE Eclipse.
Adicionando Dependências no Arquivo POM.xml
1. Abra o POM.xml, agora adicione as dependências do JUnit, Selenium e JaCoCo Maven Plugin. Após adicionar as dependências, o código do POM.xml deve ficar assim:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lambdatest</groupId>
<artifactId>lambdatest-junit-sample</artifactId>
<version>1.0-SNAPSHOT</version>
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<surefire.version>2.19.1</surefire.version>
<config.file>default</config.file>
</properties>
<dependencies>
<!--JUnit dependency-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>1.3.2</version>
<scope>test</scope>
</dependency>
<!--Selenium dependency-->
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.52.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.googlecode.json-simple</groupId>
<artifactId>json-simple</artifactId>
<version>1.1.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--Apache Maven Plugins-->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
</plugin>
<!--JaCoCo Maven Plugin-->
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.6</version>
<executions>
<execution>
<id>prepare-agent</id>
<goals><goal>prepare-agent</goal></goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals><goal>report</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project><em><a href="https://github.com/rachnaagrawal/junit-selenium-sample/blob/master/pom.xml" target="_blank" rel="nofollow">Github</a></em>Configurando as Capacidades Desejadas para Testes Automatizados com JUnit
1. Para se conectar ao Grid de Automatização Selenium da LambdaTest, a primeira coisa a ser feita é invocar um webdriver remoto. Esse driver remoto requer algumas capacidades como navegador, versões do navegador, sistema operacional, etc., para montar um ambiente. O código para isso é o seguinte:
WebDriver driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub"),
DesiredCapabilities.firefox()); //A class named DesiredCapabilities is used to create an environment as a Firefox browser.2. No código de testes automatizados com JUnit, as capacidades como navegador, versões do navegador, informações do sistema operacional, etc., podem ser personalizadas e são passadas através do objeto capabilities.
3. A LambdaTest facilitou esse processo ao fornecer um gerador de capacidades embutido. O gerador de capacidades irá automaticamente gerar o código para as capacidades desejadas com base em sua entrada. Por exemplo, nossas configurações são:
|
Campos |
Valores Selecionados |
|
Sistemas Operacionais |
Windows 10 |
|
Navegador |
Chrome |
|
Versão do Navegador |
62.0 |
|
Resolução |
1024×768 |
|
Versão do Selenium |
3.13.0 |
4. Selecione a configuração especificada acima no gerador de capacidades e cole-a em LambdaTestBaseTest.java.
Especificando o Nome de Usuário e Chave de Acesso da LambdaTest na Classe Java Necessária
1. No Project Explorer, você verá três classes Java:
LambdaTestBaseTest.java (contém a configuração necessária para testes Java Selenium).Parallelized.java(contém testes Junit para testes paralelos na grade Selenium da LambdaTest).SimpleTest.java(contém testes simples).
2. LambdaTestBaseTest.java busca os dados necessários, como capacidades desejadas, nome de usuário e chave de acesso, a partir de um arquivo de configuração. Isso é fornecido em src/test/resources como config.json.
3. Especifique as capacidades desejadas, nome de usuário e chave de acesso em config.json. Este arquivo JSON é usado pois você pode fornecer múltiplas configurações nele para realizar testes paralelos com Selenium, especificando múltiplas configurações em config.json e depois buscá-las posteriormente.
[ { "tunnelName":"LambdaTest tunnel",
"buildName":"running Java Selenium Tests",
"testName":"Jacoco JUnit Test",
"username": "user-name",
"access_key":"access-key",
"operatingSystem" : "win10",
"browserName" : "chrome",
"browserVersion" : "62.0",
"resolution" : "1024x768" }]Teste Unitário Usando JUnit com Selenium:
1. SimpleTest.java é a classe Java para especificar um único caso de teste unitário para testar e realizar a cobertura de código usando o plugin JaCoCo Maven.
package com.lambdatest;
import com.lambdatest.LambdaTestBaseTest;
import org.junit.Test;
import org.openqa.selenium.By;
import static org.junit.Assert.assertEquals;
public class SimpleTest extends LambdaTestBaseTest {
/**
* Simple Test case annotation for JUnit Test
* @throws Exception
*/
@Test
public void validateUser() throws Exception {
driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click();
driver.findElement(By.id("sampletodotext")).clear();
driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
}
}2. Este é um teste simples do Selenium WebDriver que abrirá uma aplicação de exemplo de lista de tarefas a fazer com as seguintes tarefas:
- Marca os dois primeiros itens como “Concluído.”
- Adiciona um novo item à lista.
- Retorna o item adicionado.
3. Dispare o comando mvn test no terminal para construir e executar o caso de teste.
4. Agora, faça login em sua conta do LambdaTest e vá para “Automação.” Você encontrará os testes que executou sob o nome de build “Testes JUnit JaCoCo.”
5. Clique em “Testes JUnit JaCoCo” e revise-os em detalhes. O LambdaTest gravou o vídeo. Assim, você também pode ver as visualizações.
Gerando Relatório de Cobertura de Código via Plugin JaCoCo Maven:
- Agora, como executamos os casos de teste JUnit no Grid Selenium do LambdaTest, o relatório de cobertura de código deve ser gerado via plugin JaCoCo Maven.
- Basta ir para a pasta target, e você encontrará o formato binário do relatório como
jacoco.exec. - Você pode visualizar o formato HTML, CSV e XML do relatório de cobertura de código na pasta
target/site/jacococomoindex.html, jacoco.csvejacoco.xml, respectivamente. - Agora você também pode tentar melhorar a pontuação de cobertura de código e analisar o relatório de cobertura de código gerado.
Conclusão
Neste artigo, vimos como usar o plugin JaCoCo-Maven para gerar relatórios de cobertura de código para projetos Java. Também aproveitamos a agilidade e escalabilidade do LambdaTest Selenium Grid cloud para automatizar os processos de teste. Lembre-se, no entanto, que 100% de cobertura de código não reflete necessariamente testes eficazes, pois apenas mostra a quantidade de código executado durante os testes.
No entanto, isso ajuda a reduzir o número de bugs e melhora a qualidade do software lançado. Além disso, adiciona um overhead mínimo ao processo de build e permite manter um certo limite à medida que a equipe de desenvolvimento adiciona casos limite ou implementa programação defensiva.
Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven