Integrando links de código-fonte em rastreamentos de pilha XML JUnit

Adicionando links de código-fonte em relatórios JUnit XML

Usando Java com um projeto Maven e uma abordagem de ouvinte JUnit customizada

import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestExecutionExceptionHandler;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

Explicação: Integrando links personalizados em JUnit XML com Java

Este exemplo modifica a saída XML do JUnit com links para o código-fonte do GitHub, usando uma extensão de ouvinte JUnit.

public class CustomJUnitListener implements TestExecutionExceptionHandler {
    private static final String BASE_URL = "https://github.com/your-repo-name/";
    private static final String SOURCE_FOLDER = "src/main/java/";

    @Override
    public void handleTestExecutionException(ExtensionContext context, Throwable throwable) {
        try {
            String className = context.getTestClass().orElseThrow().getName();
            int lineNumber = extractLineNumber(throwable);
            String url = BASE_URL + SOURCE_FOLDER + className.replace(".", "/") + ".java#L" + lineNumber;
            addLinkToXml(context.getDisplayName(), throwable.getMessage(), url);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private int extractLineNumber(Throwable throwable) {
        return throwable.getStackTrace()[0].getLineNumber();
    }

    private void addLinkToXml(String testName, String message, String url) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.newDocument();

            Element root = document.createElement("testcase");
            root.setAttribute("name", testName);
            root.setAttribute("message", message);
            root.setAttribute("link", url);
            document.appendChild(root);

            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(document);
            StreamResult result = new StreamResult("junit-report.xml");
            transformer.transform(source, result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Solução alternativa: usando Python para analisar e modificar XML JUnit

Essa abordagem envolve um script Python para pós-processar arquivos XML JUnit, adicionando links do GitHub para rastreamentos de pilha.

import xml.etree.ElementTree as ET

BASE_URL = "https://github.com/your-repo-name/"
SOURCE_FOLDER = "src/main/java/"

def add_links_to_xml(file_path):
    tree = ET.parse(file_path)
    root = tree.getroot()

    for testcase in root.findall(".//testcase"):  # Loop through test cases
        error = testcase.find("failure")
        if error is not None:
            message = error.text
            class_name = testcase.get("classname").replace(".", "/")
            line_number = extract_line_number(message)
            link = f"{BASE_URL}{SOURCE_FOLDER}{class_name}.java#L{line_number}"
            error.set("link", link)

    tree.write(file_path)

def extract_line_number(stack_trace):
    try:
        return int(stack_trace.split(":")[-1])
    except ValueError:
        return 0

add_links_to_xml("junit-report.xml")

Perguntas comuns sobre como vincular rastreamentos de pilha ao código-fonte

1. Qual é a melhor maneira de gerar links para código-fonte em relatórios JUnit?
2. Você pode usar um ouvinte JUnit personalizado em Java para adicionar links clicáveis ​​a rastreamentos de pilha ou pós-processar arquivos XML JUnit usando um script como o do Python ElementTree.
3. Este método pode funcionar com qualquer repositório, como GitHub ou GitLab?
4. Sim, você pode adaptar a URL base nos scripts para corresponder ao repositório específico que você usa. Por exemplo, substitua https://github.com/your-repo-name/ com o URL do seu repositório.
5. Como você lida com projetos multi-repo ou monorepo?
6. Use o caminho do arquivo no rastreamento de pilha e anexe-o à URL base do repositório apropriada. Este método garante escalabilidade para grandes projetos.
7. Existem plugins para JUnit que fornecem essa funcionalidade?
8. Embora algumas ferramentas como SpecFlow ofereçam recursos semelhantes, para JUnit, normalmente são necessários scripts personalizados ou soluções de terceiros para obter essa funcionalidade específica.
9. Quais são as melhores práticas para otimizar esse processo?
10. Certifique-se de que seus scripts validem a entrada (por exemplo, caminhos de arquivo) e incluam tratamento de erros para um desempenho robusto. Modularize seu código para reutilização.

Simplificando a resolução de erros com links de código

Vincular rastreamentos de pilha ao código-fonte é uma maneira poderosa de otimizar fluxos de trabalho de depuração. Ao automatizar esse processo, os desenvolvedores obtêm acesso instantâneo a linhas problemáticas em seu repositório. Essa abordagem promove consistência e acelera a resolução de erros. 🔗

Seja utilizando scripts ou ferramentas customizadas, a solução é escalável e adaptável a diversos tipos de projetos. A combinação de relatórios de teste enriquecidos com pipelines de CI/CD garante produtividade máxima e minimiza o tempo de inatividade, tornando-se uma virada de jogo para equipes de software modernas. 🚀