JUnit XML ਸਟੈਕ ਟਰੇਸ ਵਿੱਚ ਸਰੋਤ ਕੋਡ ਲਿੰਕਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ

JUnit XML ਰਿਪੋਰਟਾਂ ਵਿੱਚ ਸਰੋਤ ਕੋਡ ਲਿੰਕ ਸ਼ਾਮਲ ਕਰਨਾ

ਇੱਕ Maven ਪ੍ਰੋਜੈਕਟ ਅਤੇ ਇੱਕ ਕਸਟਮ JUnit ਲਿਸਨਰ ਪਹੁੰਚ ਨਾਲ ਜਾਵਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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;

ਵਿਆਖਿਆ: ਜਾਵਾ ਦੇ ਨਾਲ JUnit XML ਵਿੱਚ ਕਸਟਮ ਲਿੰਕਾਂ ਨੂੰ ਜੋੜਨਾ

ਇਹ ਉਦਾਹਰਨ JUnit ਲਿਸਨਰ ਐਕਸਟੈਂਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, GitHub ਸਰੋਤ ਕੋਡ ਦੇ ਲਿੰਕਾਂ ਦੇ ਨਾਲ JUnit XML ਆਉਟਪੁੱਟ ਨੂੰ ਸੋਧਦਾ ਹੈ।

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();
        }
    }
}

ਵਿਕਲਪਕ ਹੱਲ: JUnit XML ਨੂੰ ਪਾਰਸ ਅਤੇ ਸੋਧਣ ਲਈ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਇਸ ਪਹੁੰਚ ਵਿੱਚ JUnit XML ਫਾਈਲਾਂ ਨੂੰ ਪੋਸਟ-ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਸ਼ਾਮਲ ਹੈ, ਸਟੈਕ ਟਰੇਸ ਲਈ GitHub ਲਿੰਕ ਸ਼ਾਮਲ ਕਰਨਾ।

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")

ਸਟੈਕ ਟਰੇਸ ਨੂੰ ਸਰੋਤ ਕੋਡ ਨਾਲ ਲਿੰਕ ਕਰਨ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. JUnit ਰਿਪੋਰਟਾਂ ਵਿੱਚ ਸਰੋਤ ਕੋਡ ਦੇ ਲਿੰਕ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ?
2. ਤੁਸੀਂ ਜਾਵਾ ਵਿੱਚ ਇੱਕ ਕਸਟਮ JUnit ਲਿਸਨਰ ਦੀ ਵਰਤੋਂ ਸਟੈਕ ਟਰੇਸ ਲਈ ਕਲਿਕ ਕਰਨ ਯੋਗ ਲਿੰਕ ਜੋੜਨ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ Python's ਵਰਗੀ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JUnit XML ਫਾਈਲਾਂ ਨੂੰ ਪੋਸਟ-ਪ੍ਰੋਸੈਸ ਕਰ ਸਕਦੇ ਹੋ। ElementTree.
3. ਕੀ ਇਹ ਵਿਧੀ ਕਿਸੇ ਵੀ ਰਿਪੋਜ਼ਟਰੀ, ਜਿਵੇਂ ਕਿ GitHub ਜਾਂ GitLab ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ?
4. ਹਾਂ, ਤੁਸੀਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਅਧਾਰ URL ਨੂੰ ਤੁਹਾਡੇ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਖਾਸ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਬਦਲੋ https://github.com/your-repo-name/ ਤੁਹਾਡੇ ਰਿਪੋਜ਼ਟਰੀ ਦੇ URL ਨਾਲ।
5. ਤੁਸੀਂ ਮਲਟੀ-ਰੇਪੋ ਜਾਂ ਮੋਨੋਰੇਪੋ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ?
6. ਸਟੈਕ ਟਰੇਸ ਵਿੱਚ ਫਾਈਲ ਮਾਰਗ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਢੁਕਵੇਂ ਰਿਪੋਜ਼ਟਰੀ ਅਧਾਰ URL ਵਿੱਚ ਜੋੜੋ। ਇਹ ਵਿਧੀ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਮਾਪਯੋਗਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ।
7. ਕੀ JUnit ਲਈ ਮੌਜੂਦਾ ਪਲੱਗਇਨ ਹਨ ਜੋ ਇਹ ਕਾਰਜਸ਼ੀਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ?
8. ਜਦੋਂ ਕਿ SpecFlow ਵਰਗੇ ਕੁਝ ਟੂਲ ਸਮਾਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ, JUnit ਲਈ, ਕਸਟਮ ਸਕ੍ਰਿਪਟਿੰਗ ਜਾਂ ਤੀਜੀ-ਧਿਰ ਦੇ ਹੱਲ ਖਾਸ ਤੌਰ 'ਤੇ ਇਸ ਵਿਸ਼ੇਸ਼ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਹਨ।
9. ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ ਕੀ ਹਨ?
10. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇਨਪੁਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦੀਆਂ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਫਾਈਲ ਪਾਥ) ਅਤੇ ਮਜ਼ਬੂਤ ​​ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਸ਼ਾਮਲ ਕਰੋ। ਮੁੜ ਵਰਤੋਂਯੋਗਤਾ ਲਈ ਆਪਣੇ ਕੋਡ ਨੂੰ ਮਾਡਿਊਲਰਾਈਜ਼ ਕਰੋ।

ਕੋਡ ਲਿੰਕਸ ਨਾਲ ਤਰੁੱਟੀ ਹੱਲ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਣਾ

ਸਟੈਕ ਟਰੇਸ ਨੂੰ ਸਰੋਤ ਕੋਡ ਨਾਲ ਜੋੜਨਾ ਡੀਬੱਗਿੰਗ ਵਰਕਫਲੋ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦਾ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਆਪਣੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਮੱਸਿਆ ਵਾਲੀਆਂ ਲਾਈਨਾਂ ਤੱਕ ਤੁਰੰਤ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ। ਇਹ ਪਹੁੰਚ ਇਕਸਾਰਤਾ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦੀ ਹੈ ਅਤੇ ਗਲਤੀ ਦੇ ਹੱਲ ਨੂੰ ਤੇਜ਼ ਕਰਦੀ ਹੈ। 🔗

ਭਾਵੇਂ ਕਸਟਮ ਸਕ੍ਰਿਪਟਾਂ ਜਾਂ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੋਵੇ, ਹੱਲ ਸਕੇਲੇਬਲ ਅਤੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਜੈਕਟ ਕਿਸਮਾਂ ਲਈ ਅਨੁਕੂਲ ਹੈ। CI/CD ਪਾਈਪਲਾਈਨਾਂ ਨਾਲ ਭਰਪੂਰ ਟੈਸਟ ਰਿਪੋਰਟਾਂ ਨੂੰ ਜੋੜਨਾ ਵੱਧ ਤੋਂ ਵੱਧ ਉਤਪਾਦਕਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਡਾਊਨਟਾਈਮ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਆਧੁਨਿਕ ਸੌਫਟਵੇਅਰ ਟੀਮਾਂ ਲਈ ਗੇਮ-ਚੇਂਜਰ ਬਣਾਉਂਦਾ ਹੈ। 🚀