@allurereport/reader 3.0.0-beta.10

package/README.md

@@ -0,0 +1,25 @@
+# Reader
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+Set of Allure Reader implementations which allow to read different files formats as Allure Results files.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/reader
+yarn add @allurereport/reader
+pnpm add @allurereport/reader
+```

package/dist/allure1/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const allure1: ResultsReader;

package/dist/allure1/index.js

@@ -0,0 +1,289 @@
+import { XMLParser } from "fast-xml-parser";
+import * as console from "node:console";
+import { ensureInt, ensureString } from "../utils.js";
+import { cleanBadXmlCharacters, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
+const DEFAULT_TEST_NAME = "The test's name is not defined";
+const DEFAULT_STEP_NAME = "The step's name is not defined";
+const SUITE_LABEL_NAME = "suite";
+const TEST_CLASS_LABEL_NAME = "testClass";
+const TEST_METHOD_LABEL_NAME = "testMethod";
+const TEST_ID_LABEL_NAME = "testCaseId";
+const HISTORY_ID_LABEL_NAME = "historyId";
+const STATUS_DETAILS_LABEL_NAME = "status_details";
+const ISSUE_LABEL_NAME = "issue";
+const TMS_LABEL_NAME = "testId";
+const ISSUE_LINK_TYPE = "issue";
+const TMS_LINK_TYPE = "tms";
+const RESERVER_LABEL_NAMES = new Set([
+    TEST_CLASS_LABEL_NAME,
+    TEST_METHOD_LABEL_NAME,
+    TEST_ID_LABEL_NAME,
+    HISTORY_ID_LABEL_NAME,
+    ISSUE_LABEL_NAME,
+    TMS_LABEL_NAME,
+    STATUS_DETAILS_LABEL_NAME,
+]);
+const arrayTags = new Set(["attachment", "label", "parameter", "step", "test-case"]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: arrayTags.has.bind(arrayTags),
+});
+const readerId = "allure1";
+export const allure1 = {
+    read: async (visitor, data) => {
+        if (data.getOriginalFileName().endsWith("-testsuite.xml")) {
+            try {
+                const asBuffer = await data.asBuffer();
+                if (!asBuffer) {
+                    return false;
+                }
+                const content = cleanBadXmlCharacters(asBuffer).toString("utf-8");
+                const parsed = xmlParser.parse(content);
+                if (!isStringAnyRecord(parsed)) {
+                    return false;
+                }
+                return await parseRootElement(visitor, parsed);
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const parseRootElement = async (visitor, xml) => {
+    const { "test-suite": testSuite } = xml;
+    if (!isStringAnyRecord(testSuite)) {
+        return false;
+    }
+    return await parseTestSuite(visitor, testSuite);
+};
+const parseTestSuite = async (visitor, testSuite) => {
+    const { "name": testSuiteName, "title": testSuiteTitle, "description": descriptionElement, "test-cases": testCases, "labels": labelsElement, } = testSuite;
+    if (!isStringAnyRecord(testCases)) {
+        return false;
+    }
+    const { "test-case": testCase } = testCases;
+    if (!isStringAnyRecordArray(testCase)) {
+        return false;
+    }
+    const labels = parseLabels(labelsElement);
+    for (const tc of testCase) {
+        await parseTestCase(visitor, {
+            name: ensureString(testSuiteName),
+            title: ensureString(testSuiteTitle),
+            ...parseDescription(descriptionElement),
+            labels,
+        }, tc);
+    }
+    return true;
+};
+const parseTestCase = async (visitor, testSuite, testCase) => {
+    const { name: suiteName, title: suiteTitle, description: suiteDescription, descriptionHtml: suiteDescriptionHtml, labels: suiteLabels, } = testSuite;
+    const { name: nameElement, title: titleElement, description: descriptionElement, status: statusElement, failure: failureElement, parameters: parametersElement, steps: stepsElement, start: startElement, stop: stopElement, attachments: attachmentsElement, labels: labelsElement, } = testCase;
+    const testCaseName = ensureString(nameElement);
+    const testCaseTitle = ensureString(titleElement);
+    const name = testCaseTitle ?? testCaseName ?? DEFAULT_TEST_NAME;
+    const status = convertStatus(ensureString(statusElement));
+    const { description: testCaseDescription, descriptionHtml: testCaseDescriptionHtml } = parseDescription(descriptionElement);
+    const description = combineDescriptions(suiteDescription, testCaseDescription, "\n\n");
+    const descriptionHtml = combineDescriptions(suiteDescriptionHtml, testCaseDescriptionHtml, "<br>");
+    const { start, stop, duration } = parseTime(startElement, stopElement);
+    const testCaseLabels = parseLabels(labelsElement);
+    const allLabels = [...suiteLabels, ...testCaseLabels];
+    const testId = maybeFindLabelValue(allLabels, TEST_ID_LABEL_NAME);
+    const historyId = maybeFindLabelValue(allLabels, HISTORY_ID_LABEL_NAME);
+    const testClass = resolveTestClass(testCaseLabels, suiteLabels, suiteName, suiteTitle);
+    const testMethod = resolveTestMethod(testCaseLabels, testCaseName, testCaseTitle);
+    const fullName = getFullName(testClass, testMethod);
+    const statusDetailLabels = findAllLabels(allLabels, STATUS_DETAILS_LABEL_NAME);
+    const flaky = labelValueExistsIgnoreCase(statusDetailLabels, "flaky");
+    const muted = labelValueExistsIgnoreCase(statusDetailLabels, "muted");
+    const known = labelValueExistsIgnoreCase(statusDetailLabels, "known");
+    const links = [
+        ...createLinks(allLabels, ISSUE_LABEL_NAME, ISSUE_LINK_TYPE),
+        ...createLinks(allLabels, TMS_LABEL_NAME, TMS_LINK_TYPE),
+    ];
+    const labels = composeTestResultLabels(allLabels, testClass, testMethod, suiteTitle ?? suiteName);
+    const { message, trace } = parseFailure(failureElement);
+    const parameters = parseParameters(parametersElement);
+    const steps = [...(parseSteps(stepsElement) ?? []), ...(parseAttachments(attachmentsElement) ?? [])];
+    await visitor.visitTestResult({
+        name,
+        fullName,
+        description,
+        descriptionHtml,
+        testId,
+        historyId,
+        status,
+        start,
+        stop,
+        duration,
+        message,
+        trace,
+        flaky,
+        muted,
+        known,
+        labels,
+        links,
+        parameters,
+        steps,
+    }, { readerId });
+};
+const getFullName = (suiteComponent, testCaseComponent) => suiteComponent && testCaseComponent ? `${suiteComponent}.${testCaseComponent}` : undefined;
+const parseDescription = (element) => {
+    if (typeof element === "string") {
+        return { description: element };
+    }
+    if (!isStringAnyRecord(element)) {
+        return {};
+    }
+    const { "#text": value, type } = element;
+    const safeValue = ensureString(value);
+    return ensureString(type)?.toLowerCase() === "html" ? { descriptionHtml: safeValue } : { description: safeValue };
+};
+const combineDescriptions = (suiteDescription, testDescription, sep) => {
+    return [suiteDescription, testDescription].filter(Boolean).join(sep) || undefined;
+};
+const parseFailure = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return {};
+    }
+    const { message, "stack-trace": trace } = element;
+    return { message: ensureString(message), trace: ensureString(trace) };
+};
+const parseTime = (startElement, stopElement) => {
+    const start = ensureInt(startElement);
+    const stop = ensureInt(stopElement);
+    const duration = stop !== undefined && start !== undefined ? Math.max(0, stop - start) : undefined;
+    return { start, stop, duration };
+};
+const parseLabels = (labelsElement) => {
+    if (!isStringAnyRecord(labelsElement)) {
+        return [];
+    }
+    const { label: labelElements } = labelsElement;
+    if (!Array.isArray(labelElements)) {
+        return [];
+    }
+    return labelElements.filter(isStringAnyRecord).map(convertLabel);
+};
+const convertLabel = (labelElement) => {
+    const { name, value } = labelElement;
+    return {
+        name: ensureString(name),
+        value: ensureString(value),
+    };
+};
+const labelExists = (labels, name) => labels.some((l) => l.name === name);
+const findAllLabels = (labels, name) => labels.filter((l) => l.name === name);
+const maybeFindLabelValue = (labels, name) => labels.find((l) => l.name === name)?.value;
+const labelValueExistsIgnoreCase = (labels, value) => labels.some((l) => l.value?.toLowerCase() === value);
+const createLinks = (labels, labelName, linkType) => findAllLabels(labels, labelName).map(({ value }) => ({ name: value, url: value, type: linkType }));
+const resolveTestClass = (testCaseLabels, suiteLabels, suiteName, suiteTitle) => maybeFindLabelValue(testCaseLabels, TEST_CLASS_LABEL_NAME) ??
+    maybeFindLabelValue(suiteLabels, TEST_CLASS_LABEL_NAME) ??
+    suiteName ??
+    suiteTitle;
+const resolveTestMethod = (testCaseLabels, name, title) => maybeFindLabelValue(testCaseLabels, TEST_METHOD_LABEL_NAME) ?? name ?? title;
+const composeTestResultLabels = (allLabels, testClass, testMethod, suite) => {
+    const labels = allLabels.filter(({ name: labelName }) => !labelName || !RESERVER_LABEL_NAMES.has(labelName));
+    addLabel(labels, TEST_CLASS_LABEL_NAME, testClass);
+    addLabel(labels, TEST_METHOD_LABEL_NAME, testMethod);
+    addLabelIfNotExists(labels, SUITE_LABEL_NAME, suite);
+    return labels;
+};
+const addLabelIfNotExists = (labels, name, value) => {
+    if (!labelExists(labels, name)) {
+        addLabel(labels, name, value);
+    }
+};
+const addLabel = (labels, name, value) => {
+    if (value) {
+        labels.push({ name, value });
+    }
+};
+const parseSteps = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return undefined;
+    }
+    const { step: stepElement } = element;
+    if (!isStringAnyRecordArray(stepElement)) {
+        return undefined;
+    }
+    return stepElement.map((step) => {
+        const { name, title, status, start: startElement, stop: stopElement, steps: stepsElement, attachments: attachmentsElement, } = step;
+        const { start, stop, duration } = parseTime(startElement, stopElement);
+        const steps = [...(parseSteps(stepsElement) ?? []), ...(parseAttachments(attachmentsElement) ?? [])];
+        return {
+            name: ensureString(title) ?? ensureString(name) ?? DEFAULT_STEP_NAME,
+            status: convertStatus(ensureString(status)),
+            start,
+            stop,
+            duration,
+            steps,
+            type: "step",
+        };
+    });
+};
+const parseAttachments = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return undefined;
+    }
+    const { attachment: attachmentElement } = element;
+    if (!isStringAnyRecordArray(attachmentElement)) {
+        return undefined;
+    }
+    return attachmentElement.map((attachment) => {
+        const { title, source, type } = attachment;
+        return {
+            type: "attachment",
+            name: ensureString(title),
+            originalFileName: ensureString(source),
+            contentType: ensureString(type),
+        };
+    });
+};
+const parseParameters = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return undefined;
+    }
+    const { parameter } = element;
+    if (!isStringAnyRecordArray(parameter)) {
+        return undefined;
+    }
+    return parameter
+        .filter((p) => {
+        const { kind } = p;
+        if (!kind) {
+            return true;
+        }
+        const kindString = ensureString(kind);
+        return kindString?.toLowerCase() === "argument";
+    })
+        .map((p) => {
+        const { name, value } = p;
+        return { name: ensureString(name), value: ensureString(value) };
+    });
+};
+const convertStatus = (status) => {
+    switch (status?.toLowerCase() ?? "unknown") {
+        case "failed":
+            return "failed";
+        case "broken":
+            return "broken";
+        case "passed":
+            return "passed";
+        case "skipped":
+        case "canceled":
+        case "pending":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+};

package/dist/allure2/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const allure2: ResultsReader;

package/dist/allure2/index.js

@@ -0,0 +1,306 @@
+import { notNull } from "@allurereport/core-api";
+import { XMLParser } from "fast-xml-parser";
+import * as console from "node:console";
+import { randomUUID } from "node:crypto";
+import { parseProperties } from "../properties.js";
+import { ensureBoolean, ensureInt, ensureString } from "../utils.js";
+import { cleanBadXmlCharacters, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
+import { ParameterMode } from "./model.js";
+const arrayTags = new Set(["environment.parameter"]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: (tagName, jPath) => arrayTags.has(jPath),
+});
+const readerId = "allure2";
+export const allure2 = {
+    read: async (visitor, data) => {
+        if (data.getOriginalFileName().match(/-attachment(?:\..+)?/)) {
+            await visitor.visitAttachmentFile(data, { readerId });
+            return true;
+        }
+        if (data.getOriginalFileName().endsWith("-result.json")) {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecord(parsed)) {
+                    await processTestResult(visitor, parsed, data.getOriginalFileName());
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName().endsWith("-container.json")) {
+            const parsed = await data.asJson();
+            if (parsed) {
+                await processTestResultContainer(visitor, parsed);
+            }
+            return true;
+        }
+        if (data.getOriginalFileName() === "executor.json") {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecord(parsed)) {
+                    await processExecutor(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "categories.json") {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecordArray(parsed)) {
+                    await processCategories(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "environment.properties") {
+            try {
+                const raw = await data.asUtf8String();
+                if (raw) {
+                    const parsed = parseProperties(raw);
+                    if (parsed && isStringAnyRecord(parsed)) {
+                        await processEnvironment(visitor, parsed);
+                    }
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "environment.xml") {
+            try {
+                const asBuffer = await data.asBuffer();
+                if (!asBuffer) {
+                    return false;
+                }
+                const content = cleanBadXmlCharacters(asBuffer).toString("utf-8");
+                const parsed = xmlParser.parse(content);
+                if (isStringAnyRecord(parsed)) {
+                    await processEnvironmentXml(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const processTestResult = async (visitor, result, originalFileName) => {
+    const dest = {
+        uuid: ensureString(result.uuid),
+        fullName: ensureString(result.fullName),
+        name: ensureString(result.name),
+        testId: ensureString(result.testCaseId),
+        historyId: ensureString(result.historyId),
+        start: ensureInt(result.start),
+        stop: ensureInt(result.stop),
+        description: ensureString(result.description),
+        descriptionHtml: ensureString(result.descriptionHtml),
+        status: convertStatus(result.status),
+        message: ensureString(result?.statusDetails?.message),
+        trace: ensureString(result?.statusDetails?.trace),
+        actual: ensureString(result?.statusDetails?.actual, ""),
+        expected: ensureString(result?.statusDetails?.expected, ""),
+        flaky: ensureBoolean(result?.statusDetails?.flaky),
+        known: ensureBoolean(result?.statusDetails?.known),
+        muted: ensureBoolean(result?.statusDetails?.muted),
+        parameters: result?.parameters?.filter(notNull)?.map(convertParameter),
+        steps: [
+            ...(result?.steps?.filter(notNull)?.map(convertStep) ?? []),
+            ...(result?.attachments?.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+        links: result?.links?.filter(notNull)?.map(convertLink),
+        labels: result.labels?.filter(notNull)?.map(convertLabel),
+    };
+    await visitor.visitTestResult(dest, { readerId, metadata: { originalFileName } });
+};
+const processExecutor = async (visitor, result) => {
+    await visitor.visitMetadata({
+        allure2_executor: {
+            name: ensureString(result.name),
+            type: ensureString(result.type),
+            url: ensureString(result.url),
+            buildOrder: ensureInt(result.buildOrder),
+            buildName: ensureString(result.buildName),
+            buildUrl: ensureString(result.buildUrl),
+            reportName: ensureString(result.reportName),
+            reportUrl: ensureString(result.reportUrl),
+        },
+    }, { readerId });
+};
+const processCategories = async (visitor, result) => {
+    const data = result.map((value) => ({
+        name: ensureString(value.name),
+        description: ensureString(value.description),
+        descriptionHtml: ensureString(value.descriptionHtml),
+        messageRegex: ensureString(value.messageRegex),
+        traceRegex: ensureString(value.traceRegex),
+        matchedStatuses: Array.isArray(value.matchedStatuses)
+            ? value.matchedStatuses.map((v) => ensureString(v)).filter(notNull)
+            : [],
+        flaky: ensureBoolean(value.flaky),
+    }));
+    await visitor.visitMetadata({
+        allure2_categories: data,
+    }, { readerId });
+};
+const processEnvironmentXml = async (visitor, result) => {
+    const { environment } = result;
+    if (!isStringAnyRecord(environment)) {
+        return;
+    }
+    const { parameter: parameters } = environment;
+    if (!isStringAnyRecordArray(parameters)) {
+        return;
+    }
+    const data = [];
+    parameters.forEach((param) => {
+        const { key, value } = param;
+        const stringKey = ensureString(key);
+        const stringValue = ensureString(value);
+        if (stringKey && stringValue) {
+            data.push({ name: stringKey, values: [stringValue] });
+        }
+    });
+    await visitor.visitMetadata({
+        allure_environment: data,
+    }, {
+        readerId,
+    });
+};
+const processEnvironment = async (visitor, result) => {
+    const data = Object.keys(result).map((key) => {
+        const rawValue = result[key];
+        const value = typeof rawValue === "string" ? rawValue : JSON.stringify(rawValue);
+        return {
+            name: key,
+            values: [value],
+        };
+    });
+    await visitor.visitMetadata({
+        allure_environment: data,
+    }, {
+        readerId,
+    });
+};
+const processFixtures = async (visitor, fixtures, type, children) => {
+    if (fixtures) {
+        for (const fixture of fixtures) {
+            const dist = convertFixture(type, children, fixture);
+            await visitor.visitTestFixtureResult(dist, { readerId });
+        }
+    }
+};
+const processTestResultContainer = async (visitor, result) => {
+    if (result.children && result.children.length > 0) {
+        await processFixtures(visitor, result.befores, "before", result.children);
+        await processFixtures(visitor, result.afters, "after", result.children);
+    }
+};
+const convertStatus = (status) => {
+    switch ((status ?? "unknown").toLowerCase()) {
+        case "failed":
+            return "failed";
+        case "broken":
+            return "broken";
+        case "passed":
+            return "passed";
+        case "skipped":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+};
+const convertFixture = (type, children, fixture) => {
+    return {
+        uuid: randomUUID(),
+        testResults: children,
+        type,
+        name: fixture.name,
+        start: ensureInt(fixture.start),
+        stop: ensureInt(fixture.stop),
+        status: convertStatus(fixture.status),
+        message: ensureString(fixture?.statusDetails?.message),
+        trace: ensureString(fixture?.statusDetails?.trace),
+        steps: [
+            ...(fixture?.steps?.filter(notNull)?.map(convertStep) ?? []),
+            ...(fixture?.attachments?.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+    };
+};
+const convertStep = (step) => {
+    const steps = step?.steps ?? [];
+    const attachments = step?.attachments ?? [];
+    if (steps.length === 0 && attachments.length === 1 && step.name === attachments[0].name) {
+        return {
+            ...convertAttachment(attachments[0]),
+            start: step.start,
+            stop: step.stop,
+        };
+    }
+    return {
+        name: ensureString(step.name),
+        parameters: step?.parameters?.filter(notNull)?.map(convertParameter),
+        status: convertStatus(step.status),
+        message: ensureString(step?.statusDetails?.message),
+        trace: ensureString(step?.statusDetails?.trace),
+        steps: [
+            ...(steps.filter(notNull)?.map(convertStep) ?? []),
+            ...(attachments.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+        start: ensureInt(step.start),
+        stop: ensureInt(step.stop),
+        type: "step",
+    };
+};
+const convertParameter = ({ mode, name, value, excluded }) => {
+    return {
+        name: ensureString(name),
+        value: ensureString(value),
+        excluded: ensureBoolean(excluded),
+        hidden: mode === ParameterMode.HIDDEN,
+        masked: mode === ParameterMode.MASKED,
+    };
+};
+const convertAttachment = ({ name, type, source }) => {
+    return {
+        name: ensureString(name),
+        contentType: ensureString(type),
+        originalFileName: ensureString(source),
+        type: "attachment",
+    };
+};
+const convertLabel = ({ name, value }) => {
+    return {
+        name: ensureString(name),
+        value: ensureString(value),
+    };
+};
+const convertLink = ({ name, url, type }) => {
+    return {
+        name: ensureString(name),
+        url: ensureString(url),
+        type: ensureString(type),
+    };
+};