Gradle DSL: Configurando JaCoco
Tags: java, gradle, beginners, kotlin
Published: 2024-05-17 10:47:47

# Contexto

Como desenvolvedores, muitas vezes nos encontramos em situações em que precisamos ler grandes documentações. Mas o que fazer quando se trata apenas de uma coisa simples e, na documentação, ela é descrita de tal forma que não vai direto ao ponto, já que a mesma precisa ser assim, pois a documentação precisa tratar todos os casos de uso de suas features.
Recentemente, eu precisava adicionar o JaCoCo ao meu projeto Micronaut/Kotlin que usa build.gradle, mas, ao ler a documentação, me senti perdido, já que o passo a passo ficava em vários pontos da documentação e eu precisaria realizar um trabalho de pesquisa oneroso.
Neste post, irei ensinar como podemos configurar o JaCoCo em nossa app de forma simples e direta.
Bora começar?

### Sobre Gradle
> Gradle consiste de um sistema de build open source no qual sua configuração é através de arquivos de build por meio de DSL (Domain Specific Language) baseada em Groovy em vez do XML usado pelo Apache Maven para declarar a configuração do projeto.
Além da DSL, a ideia do Gradle é permitir configurações baseadas em tasks, ou seja, quando queremos criar algum novo comportamento durante o build, criamos uma task!

## 🚀 Começando

Para adicionar o **[JaCoCo](https://www.eclemma.org/jacoco/)** ao seu projeto Micronaut com Kotlin usando o **[Gradle Kotlin DSL](https://docs.gradle.org/current/userguide/userguide.html)** (build.gradle.kts), siga estes passos:

1. **Adicionar o plugin JaCoCo:**
Você precisa adicionar o plugin JaCoCo ao seu arquivo **`build.gradle.kts`**.
    1. Exemplo:
        
        ```kotlin
        plugins {
            kotlin("jvm") version "1.8.21" // Certifique-se de usar a versão do Kotlin adequada para o seu projeto
            id("jacoco") // Adicione a versão mais recente do JaCoCo
            id("io.micronaut.application") version "3.4.0" // Adicione a versão do Micronaut que está usando
        }
        ```
        
2. **Configurar o JaCoCo:**
Configure as tarefas e os relatórios do JaCoCo de acordo com as suas necessidades.
    1. Exemplo::
        
        ```kotlin
        tasks {
            test {
                useJUnitPlatform()
                finalizedBy(tasks.jacocoTestReport) // Gera o relatório JaCoCo após a execução dos testes
            }
        
            jacocoTestReport {
                dependsOn(tasks.test) // Executa os testes antes de gerar o relatório
                reports {
                    xml.required.set(true)
                    html.required.set(true)
                }
            }
        }
        
        jacoco {
            toolVersion = "0.8.8" // Certifique-se de usar a versão mais recente do JaCoCo
        }
        ```
        

Aqui está um exemplo de como você pode configurar isso:

```kotlin
plugins {
    kotlin("jvm") version "1.8.21" // Certifique-se de usar a versão do Kotlin adequada para o seu projeto
    id("org.jacoco") version "0.8.8" // Adicione a versão mais recente do JaCoCo
    id("io.micronaut.application") version "3.4.0" // Adicione a versão do Micronaut que está usando
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("io.micronaut:micronaut-runtime")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
    testImplementation("io.micronaut.test:micronaut-test-junit5")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
}

application {
    mainClass.set("com.example.ApplicationKt")
}

tasks {
    test {
        useJUnitPlatform()
        finalizedBy(tasks.jacocoTestReport) // Gera o relatório JaCoCo após a execução dos testes
    }

    jacocoTestReport {
        dependsOn(tasks.test) // Executa os testes antes de gerar o relatório
        reports {
            xml.required.set(true)
            html.required.set(true)
        }
    }
}

jacoco {
    toolVersion = "0.8.8" // Certifique-se de usar a versão mais recente do JaCoCo
}
```

### **Explicação dos blocos:**

- **plugins:**
Adiciona os plugins necessários para Kotlin, JaCoCo e Micronaut.
- **repositories:**
Define onde procurar as dependências do projeto.
- **dependencies:**
Adiciona as dependências necessárias para o projeto Micronaut e para os testes.
- **application:**
Define a classe principal do aplicativo.
- **tasks:**
    - **`test`**: Configura o uso do JUnit Platform para os testes e define que o relatório JaCoCo deve ser gerado após os testes.
    - **`jacocoTestReport`**: Configura o relatório JaCoCo, definindo que os testes devem ser executados antes de gerar o relatório e especifica os formatos dos relatórios (XML e HTML).
- **jacoco:**
Configura a versão da ferramenta JaCoCo a ser usada.

### **Passos adicionais:**

- Certifique-se de ter o **`kotlin("jvm")`** e outros plugins com as versões corretas que correspondem ao seu ambiente de desenvolvimento.
- Altere **`mainClass.set("com.example.ApplicationKt")`** para apontar para a sua classe principal real.
- Ajuste outras dependências e configurações conforme necessário para o seu projeto específico.

Depois de configurar o **`build.gradle.kts`**, você pode executar a tarefa de teste e gerar o relatório JaCoCo com o seguinte comando:

```bash
./gradlew test jacocoTestReport
```

Isso executará os testes e gerará os relatórios de cobertura de código no diretório **`build/reports/jacoco/test/html`**.

## Mostrar relatório jaCoco

1. **Localizar o Arquivo HTML:**
Após a execução do comando acima, o relatório HTML será gerado no diretório **`build/reports/jacoco/test/html`**.
2. **Abrir o Relatório no Navegador:**
Navegue até o diretório **`build/reports/jacoco/test/html`** no seu sistema de arquivos e procure por um arquivo chamado **`index.html`**. Este é o arquivo principal do relatório JaCoCo.
3. **Abrir o Arquivo no Navegador:**
Você pode abrir o arquivo **`index.html`** no seu navegador de duas maneiras:
    - **Método 1: Usando o Explorador de Arquivos:**
        - Navegue até o diretório **`build/reports/jacoco/test/html`** usando o explorador de arquivos do seu sistema operacional.
        - Encontre o arquivo **`index.html`**.
        - Dê um duplo clique no arquivo **`index.html`** ou clique com o botão direito do mouse e selecione "Abrir com" e escolha o seu navegador preferido.
    - **Método 2: Usando o Navegador:**
        - Abra o seu navegador preferido.
        - Na barra de endereços, digite o caminho completo para o arquivo **`index.html`**. por exemplo:
            
            ```ruby
            file:///caminho/para/seu/projeto/build/reports/jacoco/test/html/index.html
            ```
            
        - Certifique-se de substituir **`caminho/para/seu/projeto`** pelo caminho real do seu projeto.

**Exemplos de Caminhos:**

- No windows:
    
    ```ruby
    file:///C:/Users/SeuUsuario/SeuProjeto/build/reports/jacoco/test/html/index.html
    ```
    
- No macOS/Linux:
    
    ```ruby
    file:///Users/SeuUsuario/SeuProjeto/build/reports/jacoco/test/html/index.html
    ```
    

### **Dica:**

- Se você estiver usando um IDE como IntelliJ IDEA, você pode navegar até o diretório **`build/reports/jacoco/test/html`** diretamente pelo painel do projeto, clicar com o botão direito no arquivo **`index.html`** e selecionar "Open in Browser".

Seguindo esses passos, você deverá conseguir acessar o relatório de cobertura de código gerado pelo JaCoCo no seu navegador.

Espero que aproveitem esse guia, e aqui o Dev Lisan Al Gaib se despede!

<div align="center">

![Lisan Al Gaib](
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i2z8ja7kvna490u8mnqe.png)

)

</div>