@allurereport/reader 3.21.0 → 3.22.1

package/README.md

@@ -14,6 +14,25 @@
 
 Set of Allure Reader implementations which allow to read different files formats as Allure Results files.
 
+### Open Test Reporting
+
+The `openTestReporting` reader supports the event-based and hierarchical XML formats from
+[Open Test Reporting](https://github.com/ota4j-team/open-test-reporting), using schema version **0.2.0** only.
+It is included among Allure's default readers, so no additional configuration is required.
+
+Reports are recognized by their XML namespaces, regardless of the producer, namespace prefixes, or `.xml` filename.
+Ancestor names provide suite grouping. When JUnit's optional type metadata is present, `TEST` and
+`CONTAINER_AND_TEST` nodes become test results, while `CONTAINER` nodes provide structure only. Test/container
+nodes also retain their child tests. Missing or unknown types use leaf-node inference, so other producers do not
+need JUnit metadata. Failed containers are reported as global errors, preserving their reasons and Java traces.
+The reader imports statuses, timing, reasons, tags, source information, infrastructure metadata, and the standard
+Java source and throwable extensions when present. Other unknown extensions are ignored.
+
+Core data and output attachments are preserved as JSON and text. File attachments are resolved relative to the
+report file's directory; absolute paths are accepted only within that directory. Symbolic links and paths outside
+the report directory are rejected. Missing or unsafe attachments produce a warning without preventing test import.
+Local file attachments require a filesystem-backed report, not an in-memory XML buffer.
+
 ## Install
 
 Use your favorite package manager to install the package:

package/dist/allure1/index.js

@@ -65,7 +65,7 @@ const parseRootElement = async (visitor, xml) => {
     return await parseTestSuite(visitor, testSuite);
 };
 const parseTestSuite = async (visitor, testSuite) => {
-    const { name: testSuiteName, title: testSuiteTitle, description: descriptionElement, "test-cases": testCases, labels: labelsElement, } = testSuite;
+    const { "name": testSuiteName, "title": testSuiteTitle, "description": descriptionElement, "test-cases": testCases, "labels": labelsElement, } = testSuite;
     if (!isStringAnyRecord(testCases)) {
         return false;
     }

package/dist/file-attachments.d.ts

@@ -0,0 +1 @@
+export declare const readAttachmentFile: (reportDir: string, path: string) => Promise<Buffer>;

package/dist/file-attachments.js

@@ -0,0 +1,24 @@
+import { constants } from "node:fs";
+import { lstat, readFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+export const readAttachmentFile = async (reportDir, path) => {
+    const root = resolve(reportDir);
+    const attachmentPath = resolve(root, path);
+    const relativePath = relative(root, attachmentPath);
+    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new Error("Attachment path must be inside the report directory");
+    }
+    const parts = relativePath.split(sep);
+    let currentPath = root;
+    for (const [index, part] of parts.entries()) {
+        currentPath = join(currentPath, part);
+        const stats = await lstat(currentPath);
+        if (stats.isSymbolicLink()) {
+            throw new Error("Symbolic links are not allowed in attachment paths");
+        }
+        if (index === parts.length - 1 && !stats.isFile()) {
+            throw new Error("Attachment path must refer to a regular file");
+        }
+    }
+    return readFile(attachmentPath, { flag: constants.O_RDONLY | constants.O_NOFOLLOW });
+};

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
 export * from "./cucumbermessages/index.js";
 export * from "./junitxml/index.js";
+export * from "./openTestReporting/index.js";
 export * from "./xcresult/index.js";
 export * from "./attachments/index.js";
 export type * from "./model.js";

package/dist/index.js

@@ -3,5 +3,6 @@ export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
 export * from "./cucumbermessages/index.js";
 export * from "./junitxml/index.js";
+export * from "./openTestReporting/index.js";
 export * from "./xcresult/index.js";
 export * from "./attachments/index.js";

package/dist/junitxml/index.js

@@ -1,10 +1,9 @@
 import console from "node:console";
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { lstat, readFile } from "node:fs/promises";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname } from "node:path";
 import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
 import { XMLParser } from "fast-xml-parser";
+import { readAttachmentFile } from "../file-attachments.js";
 import { ensureString } from "../utils.js";
 import { isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
 const MS_IN_S = 1000;
@@ -91,7 +90,7 @@ const parseTestSuite = async (visitor, testSuite, isAggregated, reportDir) => {
     }
 };
 const parseTestCase = async (visitor, { name: suiteName, suitePackage }, testCase, isAggregated, reportDir) => {
-    const { name: nameAttribute, failure, error, skipped, classname: classNameAttribute, time, "system-out": systemOutAttribute, "system-err": systemErrAttribute, } = testCase;
+    const { "name": nameAttribute, failure, error, skipped, "classname": classNameAttribute, time, "system-out": systemOutAttribute, "system-err": systemErrAttribute, } = testCase;
     const name = ensureString(nameAttribute);
     const className = ensureString(classNameAttribute);
     const systemOut = ensureString(systemOutAttribute);
@@ -119,8 +118,7 @@ const parseAttachments = async (visitor, reportDir, systemOut, systemErr) => {
     }
     for (const [, path] of systemOut?.matchAll(/\[\[ATTACHMENT\|([^\r\n]*?)\]\]/g) ?? []) {
         try {
-            const attachmentPath = await resolveAttachmentPath(reportDir, path);
-            const content = await readFile(attachmentPath, { flag: constants.O_RDONLY | constants.O_NOFOLLOW });
+            const content = await readAttachmentFile(reportDir, path);
             const file = new BufferResultFile(content, `${randomUUID()}${extname(path)}`);
             await visitor.visitAttachmentFile(file, { readerId });
             attachments.push({
@@ -136,27 +134,6 @@ const parseAttachments = async (visitor, reportDir, systemOut, systemErr) => {
     }
     return attachments;
 };
-const resolveAttachmentPath = async (reportDir, path) => {
-    const root = resolve(reportDir);
-    const attachmentPath = resolve(root, path);
-    const relativePath = relative(root, attachmentPath);
-    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-        throw new Error("Attachment path must be inside the report directory");
-    }
-    const parts = relativePath.split(sep);
-    let currentPath = root;
-    for (const [index, part] of parts.entries()) {
-        currentPath = join(currentPath, part);
-        const stats = await lstat(currentPath);
-        if (stats.isSymbolicLink()) {
-            throw new Error("Symbolic links are not allowed in attachment paths");
-        }
-        if (index === parts.length - 1 && !stats.isFile()) {
-            throw new Error("Attachment path must refer to a regular file");
-        }
-    }
-    return attachmentPath;
-};
 const visitPlainTextAttachment = async (visitor, name, content) => {
     const fileName = randomUUID();
     await visitor.visitAttachmentFile(new BufferResultFile(Buffer.from(content), fileName), { readerId });

package/dist/openTestReporting/attachments.d.ts

@@ -0,0 +1,5 @@
+import { type RawTestAttachment, type ResultsVisitor } from "@allurereport/reader-api";
+import { type ReportNode } from "./model.js";
+import { type XmlElement } from "./xml.js";
+export declare const attachmentElements: (path: ReportNode[]) => XmlElement[];
+export declare const visitAttachments: (visitor: ResultsVisitor, elementsToVisit: XmlElement[], reportDir: string | undefined) => Promise<RawTestAttachment[]>;

package/dist/openTestReporting/attachments.js

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto";
+import { basename, extname } from "node:path";
+import { BufferResultFile, isLiteral } from "@allurereport/reader-api";
+import { readAttachmentFile } from "../file-attachments.js";
+import { parseTime } from "./model.js";
+import { CORE, elements } from "./xml.js";
+export const attachmentElements = (path) => path
+    .flatMap((node) => node.info
+    .filter((info) => info.namespace === CORE && info.name === "attachments")
+    .flatMap((info) => info.children))
+    .filter((element) => element.namespace === CORE && isLiteral(element.name, ["data", "output", "file"]));
+export const visitAttachments = async (visitor, elementsToVisit, reportDir) => {
+    const attachments = [];
+    for (const element of elementsToVisit) {
+        let content;
+        let name;
+        let extension;
+        let contentType;
+        if (element.name === "file") {
+            const path = element.attributes.path;
+            if (!path) {
+                continue;
+            }
+            try {
+                if (reportDir === undefined) {
+                    throw new Error("Local attachments require a report file path");
+                }
+                content = await readAttachmentFile(reportDir, path);
+            }
+            catch (error) {
+                console.warn(`Unable to read Open Test Reporting attachment "${path}":`, error);
+                continue;
+            }
+            name = basename(path);
+            extension = extname(path);
+            contentType = element.attributes.mediaType;
+        }
+        else if (element.name === "data") {
+            content = Buffer.from(JSON.stringify(elements(element, "entry").flatMap((entry) => {
+                const key = entry.attributes.key;
+                return key === undefined ? [] : [{ key, value: entry.text }];
+            }), null, 2));
+            name = "Data";
+            extension = ".json";
+            contentType = "application/json";
+        }
+        else {
+            const source = element.attributes.source;
+            if (!source) {
+                continue;
+            }
+            content = Buffer.from(element.text);
+            name = source;
+            extension = ".txt";
+            contentType = "text/plain";
+        }
+        const file = new BufferResultFile(content, `${randomUUID()}${extension}`);
+        if (contentType !== undefined) {
+            file.contentType = contentType;
+        }
+        await visitor.visitAttachmentFile(file, { readerId: "open-test-reporting" });
+        attachments.push({
+            type: "attachment",
+            name,
+            originalFileName: file.getOriginalFileName(),
+            contentType: file.getContentType(),
+            contentLength: file.getContentLength(),
+            start: parseTime(element.attributes.time),
+        });
+    }
+    return attachments;
+};

package/dist/openTestReporting/index.d.ts

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

package/dist/openTestReporting/index.js

@@ -0,0 +1,92 @@
+import { dirname } from "node:path";
+import { PathResultFile, isLiteral, } from "@allurereport/reader-api";
+import { attachmentElements, visitAttachments } from "./attachments.js";
+import { infrastructureLabels, nodeMetadata, nodeType, resultDetails } from "./metadata.js";
+import { nodeStatus, reportNodes, resultElement } from "./model.js";
+import { parseXml } from "./xml.js";
+const readerId = "open-test-reporting";
+const suiteLabels = (ancestors) => {
+    const names = ancestors.map((node) => node.name);
+    if (names.length === 0) {
+        return [];
+    }
+    if (names.length === 1) {
+        return [{ name: "suite", value: names[0] }];
+    }
+    const labels = [
+        { name: "parentSuite", value: names[0] },
+        { name: "suite", value: names[1] },
+    ];
+    if (names.length > 2) {
+        labels.push({ name: "subSuite", value: names.slice(2).join(" > ") });
+    }
+    return labels;
+};
+const collectResults = (nodes, infrastructure) => {
+    const results = [];
+    const errors = [];
+    const visit = (node, ancestors) => {
+        const path = [...ancestors, node];
+        const names = path.map((entry) => entry.name);
+        const type = nodeType(node);
+        if (type === "CONTAINER") {
+            const status = nodeStatus(node);
+            if (isLiteral(status, ["failed", "broken"])) {
+                const details = resultDetails(resultElement(node));
+                errors.push({ ...details, message: `${names.join(" > ")}: ${details.message ?? status}` });
+            }
+        }
+        else if (isLiteral(type, ["TEST", "CONTAINER_AND_TEST"]) || node.children.length === 0) {
+            const metadata = nodeMetadata(path);
+            results.push({
+                result: {
+                    name: node.name,
+                    fullName: JSON.stringify(metadata.sourceIdentity === undefined ? names : [metadata.sourceIdentity, ...names]),
+                    titlePath: ancestors.map((entry) => entry.name),
+                    labels: [...suiteLabels(ancestors), ...infrastructure, ...metadata.labels],
+                    status: nodeStatus(node),
+                    ...resultDetails(resultElement(node)),
+                    start: node.start,
+                    stop: node.stop,
+                    duration: node.duration,
+                },
+                attachments: attachmentElements(path),
+            });
+        }
+        node.children.forEach((child) => visit(child, path));
+    };
+    nodes.forEach((node) => visit(node, []));
+    return { results, errors };
+};
+class OpenTestReportingReader {
+    readerId() {
+        return readerId;
+    }
+    matches(data) {
+        return data.getOriginalFileName().endsWith(".xml");
+    }
+    async read(visitor, data) {
+        try {
+            const content = await data.asUtf8String();
+            const root = content ? parseXml(content) : undefined;
+            const nodes = root ? reportNodes(root) : undefined;
+            if (!nodes) {
+                return false;
+            }
+            const { results, errors } = collectResults(nodes, infrastructureLabels(root));
+            const reportDir = data instanceof PathResultFile ? dirname(data.path) : undefined;
+            if (errors.length) {
+                await visitor.visitGlobals({ errors, attachments: [] }, { readerId });
+            }
+            for (const { result, attachments } of results) {
+                result.steps = await visitAttachments(visitor, attachments, reportDir);
+                await visitor.visitTestResult(result, { readerId });
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const openTestReporting = new OpenTestReportingReader();

package/dist/openTestReporting/metadata.d.ts

@@ -0,0 +1,13 @@
+import { type RawTestLabel } from "@allurereport/reader-api";
+import type { ReportNode } from "./model.js";
+import { type XmlElement } from "./xml.js";
+export declare const nodeType: (node: ReportNode) => string | undefined;
+export declare const nodeMetadata: (path: ReportNode[]) => {
+    sourceIdentity: string | undefined;
+    labels: RawTestLabel[];
+};
+export declare const infrastructureLabels: (root: XmlElement) => RawTestLabel[];
+export declare const resultDetails: (result: XmlElement | undefined) => {
+    message: string | undefined;
+    trace: string | undefined;
+};

package/dist/openTestReporting/metadata.js

@@ -0,0 +1,121 @@
+import { ensureLiteral, isLiteral } from "@allurereport/reader-api";
+import { CORE, elements } from "./xml.js";
+const JAVA = "https://schemas.opentest4j.org/reporting/java/0.2.0";
+const JUNIT = "https://schemas.junit.org/open-test-reporting";
+export const nodeType = (node) => node.info
+    .filter((info) => info.namespace === CORE && info.name === "metadata")
+    .flatMap((metadata) => elements(metadata, "type", JUNIT))
+    .at(-1)
+    ?.text.trim();
+const sourceDetails = (source) => {
+    const labels = [];
+    let identity;
+    const attributes = source.attributes;
+    if (source.namespace === CORE && isLiteral(source.name, ["directorySource", "fileSource"])) {
+        identity = attributes.path;
+        if (identity !== undefined) {
+            labels.push({ name: "path", value: identity });
+        }
+    }
+    else if (source.namespace === JAVA) {
+        if (isLiteral(source.name, ["classSource", "methodSource"])) {
+            const className = attributes.className;
+            identity = className;
+            if (className !== undefined) {
+                labels.push({ name: "testClass", value: className });
+                const dot = className.lastIndexOf(".");
+                if (dot !== -1) {
+                    labels.push({ name: "package", value: className.slice(0, dot) });
+                }
+            }
+            if (source.name === "methodSource" && attributes.methodName !== undefined) {
+                labels.push({ name: "testMethod", value: attributes.methodName });
+                identity = `${className === undefined ? "" : `${className}.`}${attributes.methodName}(${attributes.methodParameterTypes ?? ""})`;
+            }
+        }
+        else if (source.name === "classpathResourceSource") {
+            identity = attributes.resourceName;
+            if (identity !== undefined) {
+                labels.push({ name: "path", value: identity });
+            }
+        }
+        else if (source.name === "packageSource") {
+            identity = attributes.name;
+            if (identity !== undefined) {
+                labels.push({ name: "package", value: identity });
+            }
+        }
+    }
+    if (identity !== undefined) {
+        const position = elements(source, "filePosition", source.namespace)[0];
+        for (const name of ["line", "column"]) {
+            const value = position?.attributes[name];
+            if (value !== undefined) {
+                labels.push({ name, value });
+                identity += `:${value}`;
+            }
+        }
+    }
+    return { identity, labels };
+};
+export const nodeMetadata = (path) => {
+    const labels = [];
+    let sourceIdentity;
+    for (const node of path) {
+        for (const info of node.info) {
+            if (info.namespace !== CORE) {
+                continue;
+            }
+            if (info.name === "metadata") {
+                for (const tags of elements(info, "tags")) {
+                    labels.push(...elements(tags, "tag").map((tag) => ({ name: "tag", value: tag.text })));
+                }
+            }
+            else if (info.name === "sources") {
+                for (const source of info.children) {
+                    const details = sourceDetails(source);
+                    labels.push(...details.labels);
+                    sourceIdentity = details.identity ?? sourceIdentity;
+                }
+            }
+        }
+    }
+    const seen = new Set();
+    return {
+        sourceIdentity,
+        labels: labels.filter((label) => {
+            const key = JSON.stringify([label.name, label.value]);
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        }),
+    };
+};
+export const infrastructureLabels = (root) => {
+    const coreNames = new Map([
+        ["hostName", "host"],
+        ["userName", "user"],
+        ["operatingSystem", "os"],
+        ["cpuCores", "cpuCores"],
+    ]);
+    return elements(root, "infrastructure").flatMap((infrastructure) => infrastructure.children.flatMap((field) => {
+        const name = field.namespace === CORE
+            ? coreNames.get(field.name)
+            : field.namespace === JAVA
+                ? ensureLiteral(field.name, ["javaVersion", "fileEncoding", "heapSize"])
+                : undefined;
+        if (!name) {
+            return [];
+        }
+        const value = field.name === "heapSize" ? field.attributes.max : field.text;
+        return value === undefined ? [] : [{ name, value }];
+    }));
+};
+export const resultDetails = (result) => {
+    const throwable = result ? elements(result, "throwable", JAVA)[0] : undefined;
+    const trace = throwable?.text || undefined;
+    const reason = result ? elements(result, "reason")[0]?.text : undefined;
+    return { message: reason ?? trace?.split(/\r?\n/, 1)[0] ?? throwable?.attributes.type, trace };
+};

package/dist/openTestReporting/model.d.ts

@@ -0,0 +1,14 @@
+import { type RawTestStatus } from "@allurereport/reader-api";
+import { type XmlElement } from "./xml.js";
+export interface ReportNode {
+    name: string;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    info: XmlElement[];
+    children: ReportNode[];
+}
+export declare const resultElement: (node: ReportNode) => XmlElement | undefined;
+export declare const nodeStatus: (node: ReportNode) => RawTestStatus;
+export declare const parseTime: (value: string | undefined) => number | undefined;
+export declare const reportNodes: (root: XmlElement) => ReportNode[] | undefined;

package/dist/openTestReporting/model.js

@@ -0,0 +1,116 @@
+import { isDefined, isLiteral } from "@allurereport/reader-api";
+import { CORE, EVENTS, HIERARCHY, elements } from "./xml.js";
+const DEFAULT_TEST_NAME = "Default Test Name";
+const statuses = new Map([
+    ["SUCCESSFUL", "passed"],
+    ["FAILED", "failed"],
+    ["ERRORED", "broken"],
+    ["SKIPPED", "skipped"],
+    ["ABORTED", "skipped"],
+]);
+export const resultElement = (node) => node.info.filter((element) => element.namespace === CORE && element.name === "result").at(-1);
+export const nodeStatus = (node) => {
+    const status = resultElement(node)?.attributes.status;
+    return (status === undefined ? undefined : statuses.get(status)) ?? "unknown";
+};
+export const parseTime = (value) => {
+    if (!value || !/^\d{4,}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/.test(value)) {
+        return undefined;
+    }
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? time : undefined;
+};
+const durationMillis = (value, start) => {
+    const match = value?.match(/^(-)?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
+    if (!match || !match.slice(2).some(isDefined) || (value?.includes("T") && !match.slice(5).some(isDefined))) {
+        return undefined;
+    }
+    const sign = match[1] ? -1 : 1;
+    const [years, months, days, hours, minutes, seconds] = match.slice(2).map((part) => Number(part ?? 0));
+    if (start === undefined && (years || months)) {
+        return undefined;
+    }
+    const reference = start ?? 0;
+    const end = new Date(reference);
+    const day = end.getUTCDate();
+    end.setUTCDate(1);
+    end.setUTCFullYear(end.getUTCFullYear() + sign * years);
+    end.setUTCMonth(end.getUTCMonth() + sign * months);
+    const lastDay = new Date(end);
+    lastDay.setUTCMonth(lastDay.getUTCMonth() + 1, 0);
+    end.setUTCDate(Math.min(day, lastDay.getUTCDate()));
+    const duration = end.getTime() - reference + sign * (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+    return Number.isFinite(duration) ? duration : undefined;
+};
+const hierarchyNode = (element) => {
+    const start = parseTime(element.attributes.start);
+    const duration = durationMillis(element.attributes.duration, start);
+    return {
+        name: element.attributes.name || DEFAULT_TEST_NAME,
+        start,
+        duration,
+        stop: start === undefined || duration === undefined ? undefined : start + duration,
+        info: element.children,
+        children: elements(element, "child", HIERARCHY).map(hierarchyNode),
+    };
+};
+const eventNodes = (root) => {
+    const events = root.children.filter((element) => element.namespace === EVENTS && isLiteral(element.name, ["started", "reported", "finished"]));
+    const nodes = new Map();
+    const parents = new Map();
+    for (const event of events.filter((element) => element.name === "started")) {
+        const id = event.attributes.id;
+        if (!id || nodes.has(id)) {
+            continue;
+        }
+        nodes.set(id, {
+            name: event.attributes.name || DEFAULT_TEST_NAME,
+            start: parseTime(event.attributes.time),
+            info: [],
+            children: [],
+        });
+        parents.set(id, event.attributes.parentId);
+    }
+    for (const event of events) {
+        const id = event.attributes.id;
+        const node = id ? nodes.get(id) : undefined;
+        if (!node) {
+            continue;
+        }
+        node.info.push(...event.children);
+        if (event.name === "finished") {
+            const time = parseTime(event.attributes.time);
+            if (time !== undefined) {
+                node.stop = time;
+                node.duration = node.start === undefined ? undefined : time - node.start;
+            }
+        }
+    }
+    const roots = [];
+    const linkedParents = new Map();
+    for (const [id, node] of nodes) {
+        const parentId = parents.get(id);
+        const parent = parentId === undefined ? undefined : nodes.get(parentId);
+        let ancestor = parent;
+        while (ancestor && ancestor !== node) {
+            ancestor = linkedParents.get(ancestor);
+        }
+        if (!parent || ancestor === node) {
+            roots.push(node);
+        }
+        else {
+            parent.children.push(node);
+            linkedParents.set(node, parent);
+        }
+    }
+    return roots;
+};
+export const reportNodes = (root) => {
+    if (root.name === "events" && root.namespace === EVENTS) {
+        return eventNodes(root);
+    }
+    if (root.name === "execution" && root.namespace === HIERARCHY) {
+        return elements(root, "root", HIERARCHY).map(hierarchyNode);
+    }
+    return undefined;
+};

package/dist/openTestReporting/xml.d.ts

@@ -0,0 +1,12 @@
+export declare const CORE = "https://schemas.opentest4j.org/reporting/core/0.2.0";
+export declare const EVENTS = "https://schemas.opentest4j.org/reporting/events/0.2.0";
+export declare const HIERARCHY = "https://schemas.opentest4j.org/reporting/hierarchy/0.2.0";
+export interface XmlElement {
+    name: string;
+    namespace?: string;
+    attributes: Partial<Record<string, string>>;
+    children: XmlElement[];
+    text: string;
+}
+export declare const elements: (element: XmlElement, name: string, namespace?: string) => XmlElement[];
+export declare const parseXml: (content: string) => XmlElement | undefined;

package/dist/openTestReporting/xml.js

@@ -0,0 +1,56 @@
+import { ensureArrayWithItems, ensureObjectWithProps, ensureString, isObject, isString, } from "@allurereport/reader-api";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+export const CORE = "https://schemas.opentest4j.org/reporting/core/0.2.0";
+export const EVENTS = "https://schemas.opentest4j.org/reporting/events/0.2.0";
+export const HIERARCHY = "https://schemas.opentest4j.org/reporting/hierarchy/0.2.0";
+const parser = new XMLParser({
+    preserveOrder: true,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    parseTagValue: false,
+    trimValues: false,
+    ignoreDeclaration: true,
+    ignorePiTags: true,
+});
+export const elements = (element, name, namespace = CORE) => element.children.filter((child) => child.name === name && child.namespace === namespace);
+const convert = (nodes, inherited) => (ensureArrayWithItems(nodes, isObject) ?? []).flatMap((node) => {
+    const qualifiedName = Object.keys(node).find((key) => key !== ":@" && key !== "#text");
+    if (!qualifiedName) {
+        return [];
+    }
+    const children = ensureArrayWithItems(node[qualifiedName], isObject);
+    if (!children) {
+        return [];
+    }
+    const attributes = ensureObjectWithProps(node[":@"], isString) ?? {};
+    const namespaces = new Map(inherited);
+    for (const [name, value] of Object.entries(attributes)) {
+        if (value !== undefined && (name === "xmlns" || name.startsWith("xmlns:"))) {
+            namespaces.set(name === "xmlns" ? "" : name.slice(6), value);
+        }
+    }
+    const colon = qualifiedName.indexOf(":");
+    return [
+        {
+            name: colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1),
+            namespace: namespaces.get(colon === -1 ? "" : qualifiedName.slice(0, colon)),
+            attributes,
+            children: convert(children, namespaces),
+            text: children.map((child) => ensureString(child["#text"]) ?? "").join(""),
+        },
+    ];
+});
+export const parseXml = (content) => {
+    const markupTokens = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<!DOCTYPE\b|<(?:[^<>"']|"[^"]*"|'[^']*')*>/gi;
+    for (const [token] of content.matchAll(markupTokens)) {
+        if (/^<!DOCTYPE\b/i.test(token)) {
+            return undefined;
+        }
+    }
+    if (XMLValidator.validate(content) !== true) {
+        return undefined;
+    }
+    const parsed = parser.parse(content);
+    const roots = convert(parsed, new Map());
+    return roots.length === 1 ? roots[0] : undefined;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader",
-  "version": "3.21.0",
+  "version": "3.22.1",
   "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
   "keywords": [
     "allure",
@@ -21,28 +21,30 @@
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "test": "vitest run",
+    "test": "rimraf out && vp test run",
     "test:unit": "yarn test",
-    "lint": "oxlint --import-plugin src test features stories",
-    "lint:fix": "oxlint --import-plugin --fix src test features stories"
+    "lint": "vp lint --import-plugin src test features stories",
+    "lint:fix": "vp lint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.21.0",
-    "@allurereport/plugin-api": "3.21.0",
-    "@allurereport/reader-api": "3.21.0",
+    "@allurereport/core-api": "3.22.1",
+    "@allurereport/plugin-api": "3.22.1",
+    "@allurereport/reader-api": "3.22.1",
     "fast-xml-parser": "^5.11.1"
   },
   "devDependencies": {
-    "@allurereport/test-config": "3.21.0",
+    "@allurereport/common-config": "3.22.1",
     "@types/archiver": "^6.0.3",
     "@types/node": "^20",
-    "@vitest/coverage-istanbul": "^4.1.0",
+    "@vitest/coverage-istanbul": "5.0.4",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
     "archiver": "^7.0.1",
     "rimraf": "^6",
     "typescript": "^5",
-    "vitest": "^4.1.0"
+    "vite": "@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0",
+    "vitest": "5.0.4"
   }
 }