Guia: Enviar dados de relatório de extensão por e-mail no Jenkins

Visão geral da integração do Extension Reporting

A integração do Extent Reporting com Jenkins para projetos Java automatizados aumenta a visibilidade dos resultados dos testes, o que é crucial para ambientes de integração contínua. Essa configuração normalmente inclui TestNG, Maven e Extent Reporter, gerenciados por meio do SureFire, permitindo compilações noturnas e relatórios detalhados.

No entanto, um desafio comum é extrair dados específicos, como contagens de testes e taxas de aprovação/reprovação, do painel HTML do Extent Reporter para inclusão nas notificações por e-mail do Jenkins. Isso requer um script ou método para analisar esses detalhes de forma eficaz a partir do conteúdo HTML para disseminação automatizada.

Comando	Descrição
groovy.json.JsonSlurper	Usado no Groovy para analisar dados formatados em JSON, facilitando a manipulação de dados de arquivos ou respostas JSON.
new URL().text	Cria um novo objeto URL e busca o conteúdo como texto, comumente usado para ler dados diretamente de recursos da web.
jenkins.model.Jenkins.instance	Padrão Singleton para acessar a instância atual do Jenkins em execução, permitindo a manipulação de configurações e definições de trabalho.
Thread.currentThread().executable	Usado no pipeline com script do Jenkins para obter uma referência ao build ou trabalho em execução no momento, geralmente para manipulação dinâmica.
hudson.util.RemotingDiagnostics	Permite a execução de scripts Groovy em nós remotos do Jenkins, usados ​​principalmente para fins de diagnóstico em scripts.
Transport.send(message)	Parte da API JavaMail utilizada para enviar uma mensagem de email preparada no script, essencial para sistemas de notificação.

Explicação da implementação do script

Os scripts fornecidos são projetados para automatizar a extração de dados de teste de Extent Reports no Jenkins e enviar esses dados por e-mail como parte de um ciclo de feedback de integração contínua. O primeiro comando importante é , que é essencial para analisar dados JSON no ambiente Jenkins. Isso permite que o script lide com respostas ou arquivos JSON de forma eficiente, crucial para extrair os resultados do teste formatados em JSON dos relatórios de extensão. Outro comando chave usado é , que acessa o relatório HTML dos Extent Reports hospedados no Jenkins. Este comando busca o conteúdo HTML como texto simples, permitindo que o script extraia os dados necessários, como testes totais, testes aprovados e reprovados.

A extração de dados é gerenciada ainda mais usando expressões regulares para encontrar padrões específicos no texto HTML, identificando os números associados ao total, aos testes aprovados e reprovados. O O comando é então usado para fazer referência à instância atual do Jenkins, que é necessária para buscar vários detalhes do trabalho e definir as configurações programaticamente. Após a extração de dados, o script usa da API JavaMail para enviar o email construído. Este comando é crucial para enviar notificações por e-mail com os resultados dos testes extraídos, garantindo que as partes interessadas sejam atualizadas com os resultados dos testes mais recentes diretamente por e-mail, melhorando assim a comunicação e os tempos de resposta nos ciclos de desenvolvimento.

import hudson.model.*
import hudson.util.RemotingDiagnostics
import groovy.json.JsonSlurper
def extractData() {
    def build = Thread.currentThread().executable
    def reportUrl = "${build.getProject().url}${build.number}/HTML_20Report/index.html"
    def jenkinsConsole = new URL(reportUrl).text
    def matcher = jenkinsConsole =~ "<span class=\\"param_name\\">\\s*Total Tests:\\s*</span>(\\d+)</br>"
    def totalTests = matcher ? Integer.parseInt(matcher[0][1]) : 0
    matcher = jenkinsConsole =~ "<span class=\\"param_name\\">\\s*Passed Tests:\\s*</span>(\\d+)</br>"
    def passedTests = matcher ? Integer.parseInt(matcher[0][1]) : 0
    matcher = jenkinsConsole =~ "<span class=\\"param_name\\">\\s*Failed Tests:\\s*</span>(\\d+)</br>"
    def failedTests = matcher ? Integer.parseInt(matcher[0][1]) : 0
    return [totalTests, passedTests, failedTests]
}
def sendEmail(testResults) {
    def emailExt = Jenkins.instance.getExtensionList('hudson.tasks.MailSender')[0]
    def emailBody = "Total Tests: ${testResults[0]}, Passed: ${testResults[1]}, Failed: ${testResults[2]}"
    emailExt.sendMail(emailBody, "jenkins@example.com", "Test Report Summary")
}
def results = extractData()
sendEmail(results)

import groovy.json.JsonSlurper
import jenkins.model.Jenkins
import javax.mail.Message
import javax.mail.Transport
import javax.mail.internet.InternetAddress
import javax.mail.internet.MimeMessage
def fetchReportData() {
    def job = Jenkins.instance.getItemByFullName("YourJobName")
    def lastBuild = job.lastBuild
    def reportUrl = "${lastBuild.url}HTML_20Report/index.html"
    new URL(reportUrl).withReader { reader ->
        def data = reader.text
        def jsonSlurper = new JsonSlurper()
        def object = jsonSlurper.parseText(data)
        return object
    }
}
def sendNotification(buildData) {
    def session = Jenkins.instance.getMailSession()
    def message = new MimeMessage(session)
    message.setFrom(new InternetAddress("jenkins@example.com"))
    message.setRecipients(Message.RecipientType.TO, "developer@example.com")
    message.setSubject("Automated Test Results")
    message.setText("Test Results: ${buildData.totalTests} Total, ${buildData.passed} Passed, ${buildData.failed} Failed.")
    Transport.send(message)
}
def reportData = fetchReportData()
sendNotification(reportData)

Aprimoramentos em relatórios automatizados por meio do Jenkins

A implementação de extração automatizada de dados e notificações por e-mail no Jenkins usando Extent Reports otimiza significativamente o processo de integração contínua (CI). Essa metodologia não apenas garante atualizações oportunas, mas também facilita a resolução proativa de problemas, fornecendo às partes interessadas resultados de testes imediatos. O processo aproveita os recursos do Jenkins para agendar e executar testes automatizados durante a noite, que são então analisados ​​para extrair métricas importantes, como o número total de testes, aprovações e falhas diretamente dos relatórios HTML gerados pelo Extent Reporter.

Essa extração e relatórios automatizados simplificam o mecanismo de feedback essencial para ambientes de desenvolvimento ágeis. Ao integrar o Extent Reports ao Jenkins, as equipes podem gerenciar melhor os resultados dos testes e manter altos padrões de qualidade de código por meio de monitoramento e avaliação contínuos. Essas operações são essenciais para manter um pipeline de desenvolvimento eficiente e garantir que todos os membros da equipe estejam alinhados com os resultados de testes e status do projeto mais recentes.

1. Como configuro o Jenkins para enviar um email após uma compilação?
2. Você pode configurar isso nas ações pós-construção da configuração do seu trabalho, usando a opção Notificação por e-mail.
3. O que são relatórios de extensão no contexto do Jenkins?
4. Extent Reports é uma ferramenta de relatório de código aberto que fornece relatórios interativos e detalhados sobre testes automatizados, facilmente integrados aos pipelines Jenkins.
5. O Jenkins pode ser integrado a outras ferramentas de relatórios além dos Extent Reports?
6. Sim, Jenkins oferece suporte à integração com várias outras ferramentas de relatórios como JUnit, TestNG e muito mais, usando os respectivos plug-ins.
7. Como extraio dados de teste de um relatório HTML no Jenkins?
8. Normalmente, você usa scripts Groovy ou Python no Jenkins para analisar o conteúdo HTML e extrair os dados necessários.
9. Quais são os benefícios das notificações automatizadas por e-mail no Jenkins?
10. E-mails automatizados fornecem feedback imediato sobre status de construção e teste, ajudando as equipes a resolver problemas com mais rapidez e a manter fluxos de trabalho de implantação contínuos.

Automatizar a extração de métricas de teste de Extent Reports e integrá-las às notificações por e-mail do Jenkins aprimora significativamente os recursos de monitoramento em um pipeline de CI. Essa abordagem permite que as equipes recebam atualizações oportunas sobre os resultados dos testes, promovendo ações rápidas para corrigir falhas e melhorar o código. O processo simplificado não só economiza tempo, mas também otimiza a alocação de recursos, garantindo que todas as partes interessadas sejam prontamente informadas sobre o status das construções noturnas, mantendo assim um ciclo contínuo de feedback e desenvolvimento.