@allurereport/reader 3.19.0 → 3.20.0

package/dist/cucumbermessages/index.d.ts

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

package/dist/cucumbermessages/index.js

@@ -0,0 +1,210 @@
+import { randomUUID } from "node:crypto";
+import { BufferResultFile, } from "@allurereport/reader-api";
+import { isNonNullObject } from "../utils.js";
+const readerId = "cucumber-messages";
+const statusMap = new Map([
+    ["PASSED", "passed"],
+    ["FAILED", "failed"],
+    ["SKIPPED", "skipped"],
+    ["PENDING", "skipped"],
+    ["UNDEFINED", "broken"],
+    ["AMBIGUOUS", "broken"],
+]);
+const statusOrder = ["failed", "broken", "unknown", "skipped", "passed"];
+const stepKey = (executionId, stepId) => JSON.stringify([executionId, stepId]);
+export const cucumberMessages = {
+    readerId: () => readerId,
+    matches: (data) => /\.(jsonl|ndjson)$/.test(data.getOriginalFileName()),
+    read: async (visitor, data) => {
+        const originalFileName = data.getOriginalFileName();
+        try {
+            const content = await data.asUtf8String();
+            if (!content?.trim())
+                return false;
+            const messages = content
+                .split(/\r?\n/)
+                .filter((line) => line.trim())
+                .map((line) => JSON.parse(line));
+            if (!messages.every(isNonNullObject))
+                return false;
+            return await processMessages(visitor, originalFileName, messages);
+        }
+        catch (error) {
+            console.error("error parsing", originalFileName, error);
+            return false;
+        }
+    },
+};
+const processMessages = async (visitor, originalFileName, messages) => {
+    const pickles = new Map();
+    const cases = new Map();
+    const hooks = new Map();
+    const starts = new Map();
+    const finishes = new Map();
+    const stepStarts = new Map();
+    const stepFinishes = new Map();
+    const attachments = new Map();
+    for (const message of messages) {
+        if (message.pickle)
+            pickles.set(message.pickle.id, message.pickle);
+        if (message.testCase)
+            cases.set(message.testCase.id, message.testCase);
+        if (message.hook)
+            hooks.set(message.hook.id, message.hook);
+        if (message.testCaseStarted)
+            starts.set(message.testCaseStarted.id, message.testCaseStarted);
+        if (message.testCaseFinished)
+            finishes.set(message.testCaseFinished.testCaseStartedId, message.testCaseFinished);
+        if (message.testStepStarted) {
+            const event = message.testStepStarted;
+            stepStarts.set(stepKey(event.testCaseStartedId, event.testStepId), event);
+        }
+        if (message.testStepFinished) {
+            const event = message.testStepFinished;
+            stepFinishes.set(stepKey(event.testCaseStartedId, event.testStepId), event);
+        }
+        const attachment = message.attachment;
+        if (attachment?.testCaseStartedId &&
+            typeof attachment.body === "string" &&
+            (attachment.contentEncoding === "IDENTITY" || attachment.contentEncoding === "BASE64")) {
+            const group = attachments.get(attachment.testCaseStartedId) ?? [];
+            group.push(attachment);
+            attachments.set(attachment.testCaseStartedId, group);
+        }
+    }
+    const gherkin = indexGherkin(messages);
+    const context = { readerId, metadata: { originalFileName } };
+    for (const execution of starts.values()) {
+        const testCase = cases.get(execution.testCaseId);
+        const pickle = testCase && pickles.get(testCase.pickleId);
+        if (!testCase || !pickle)
+            throw new Error(`Missing test case or pickle for execution ${execution.id}`);
+        const { scenario, feature } = pickle.astNodeIds.map((id) => gherkin.scenarios.get(id)).find(Boolean) ?? {};
+        const example = pickle.astNodeIds.map((id) => gherkin.examples.get(id)).find(Boolean);
+        const line = pickle.location?.line ?? example?.line ?? scenario?.location.line;
+        const name = pickle.name || "The scenario's name is not defined";
+        const finish = finishes.get(execution.id);
+        const result = {
+            uuid: randomUUID(),
+            name,
+            fullName: `${pickle.uri}${line === undefined ? "" : `:${line}`}#${name}`,
+            testCaseName: scenario?.name,
+            description: scenario?.description,
+            parameters: example?.parameters,
+            labels: [
+                ...(feature ? [{ name: "feature", value: feature }] : []),
+                ...pickle.tags.map(({ name: value }) => ({ name: "tag", value })),
+            ],
+            start: milliseconds(execution.timestamp),
+            stop: milliseconds(finish?.timestamp),
+            steps: [],
+        };
+        const pickleSteps = new Map(pickle.steps.map((step) => [step.id, step]));
+        const executionAttachments = attachments.get(execution.id) ?? [];
+        const allSteps = [];
+        const fixtures = [];
+        for (const testStep of testCase.testSteps) {
+            const key = stepKey(execution.id, testStep.id);
+            const pickleStep = testStep.pickleStepId ? pickleSteps.get(testStep.pickleStepId) : undefined;
+            const hook = testStep.hookId ? hooks.get(testStep.hookId) : undefined;
+            const keyword = pickleStep?.astNodeIds.map((id) => gherkin.keywords.get(id)).find((value) => value !== undefined);
+            const step = {
+                ...convertStep(stepStarts.get(key), stepFinishes.get(key)),
+                name: pickleStep ? `${keyword ?? ""}${pickleStep.text}` : (hook?.name ?? "Hook"),
+                steps: await readAttachments(visitor, executionAttachments.filter((attachment) => attachment.testStepId === testStep.id), pickleStep),
+            };
+            allSteps.push(step);
+            const fixtureType = hook?.type === "BEFORE_TEST_CASE" ? "before" : hook?.type === "AFTER_TEST_CASE" ? "after" : undefined;
+            if (fixtureType) {
+                fixtures.push({ ...step, type: fixtureType, testResults: [result.uuid] });
+            }
+            else {
+                result.steps.push(step);
+            }
+        }
+        result.steps.push(...(await readAttachments(visitor, executionAttachments.filter((attachment) => !attachment.testStepId))));
+        const worst = allSteps.sort((a, b) => statusOrder.indexOf(a.status) - statusOrder.indexOf(b.status))[0];
+        result.status = finish ? (worst?.status ?? "unknown") : "unknown";
+        result.message = worst?.message;
+        result.trace = worst?.trace;
+        await visitor.visitTestResult(result, context);
+        for (const fixture of fixtures)
+            await visitor.visitTestFixtureResult(fixture, context);
+    }
+    return starts.size > 0;
+};
+const indexGherkin = (messages) => {
+    const scenarios = new Map();
+    const examples = new Map();
+    const keywords = new Map();
+    const visit = (children, feature) => {
+        for (const child of children) {
+            if (child.rule)
+                visit(child.rule.children, feature);
+            for (const step of child.scenario?.steps ?? child.background?.steps ?? [])
+                keywords.set(step.id, step.keyword);
+            if (!child.scenario)
+                continue;
+            const scenario = child.scenario;
+            scenarios.set(scenario.id, { scenario, feature });
+            for (const example of scenario.examples) {
+                for (const row of example.tableBody) {
+                    examples.set(row.id, {
+                        line: row.location.line,
+                        parameters: example.tableHeader?.cells.map((cell, index) => ({ name: cell.value, value: row.cells[index]?.value })) ??
+                            [],
+                    });
+                }
+            }
+        }
+    };
+    for (const message of messages) {
+        const feature = message.gherkinDocument?.feature;
+        if (feature)
+            visit(feature.children, feature.name);
+    }
+    return { scenarios, examples, keywords };
+};
+const milliseconds = (timestamp) => {
+    if (!timestamp)
+        return undefined;
+    const value = Number(timestamp.seconds) * 1000 + timestamp.nanos / 1000000;
+    return Number.isFinite(value) ? value : undefined;
+};
+const convertStep = (started, finished) => {
+    const result = finished?.testStepResult;
+    const start = milliseconds(started?.timestamp);
+    const duration = milliseconds(result?.duration);
+    return {
+        type: "step",
+        start,
+        stop: start !== undefined && duration !== undefined ? undefined : milliseconds(finished?.timestamp),
+        duration,
+        status: statusMap.get(result?.status ?? "UNKNOWN") ?? "unknown",
+        message: result?.exception?.message ?? result?.message,
+        trace: result?.exception?.stackTrace ?? result?.message,
+    };
+};
+const readAttachments = async (visitor, attachments, step) => {
+    const result = [];
+    const docString = step?.argument?.docString;
+    if (docString) {
+        result.push(await visitAttachment(visitor, "Description", Buffer.from(docString.content), docString.mediaType ?? "text/plain"));
+    }
+    const table = step?.argument?.dataTable;
+    if (table) {
+        const csv = table.rows
+            .map(({ cells }) => cells.map(({ value }) => `"${value.replaceAll('"', '""')}"`).join(","))
+            .join("\n");
+        result.push(await visitAttachment(visitor, "Data", Buffer.from(csv), "text/csv"));
+    }
+    for (const attachment of attachments) {
+        result.push(await visitAttachment(visitor, attachment.fileName ?? "Attachment", Buffer.from(attachment.body, attachment.contentEncoding === "BASE64" ? "base64" : "utf8"), attachment.mediaType));
+    }
+    return result;
+};
+const visitAttachment = async (visitor, name, content, contentType) => {
+    const file = new BufferResultFile(content, randomUUID());
+    await visitor.visitAttachmentFile(file, { readerId });
+    return { type: "attachment", name, contentType, originalFileName: file.getOriginalFileName() };
+};

package/dist/cucumbermessages/model.d.ts

@@ -0,0 +1,134 @@
+export type CucumberTimestamp = {
+    seconds: number | string;
+    nanos: number;
+};
+export type CucumberLocation = {
+    line: number;
+};
+export type CucumberTableRow = {
+    cells: {
+        value: string;
+    }[];
+};
+export type CucumberPickleStep = {
+    id: string;
+    text: string;
+    astNodeIds: string[];
+    argument?: {
+        docString?: {
+            content: string;
+            mediaType?: string;
+        };
+        dataTable?: {
+            rows: CucumberTableRow[];
+        };
+    };
+};
+export type CucumberPickle = {
+    id: string;
+    uri: string;
+    name: string;
+    language: string;
+    location?: CucumberLocation;
+    astNodeIds: string[];
+    tags: {
+        name: string;
+    }[];
+    steps: CucumberPickleStep[];
+};
+export type CucumberGherkinStep = {
+    id: string;
+    keyword: string;
+};
+export type CucumberScenario = {
+    id: string;
+    name: string;
+    description: string;
+    location: CucumberLocation;
+    steps: CucumberGherkinStep[];
+    examples: {
+        tableHeader?: CucumberTableRow;
+        tableBody: (CucumberTableRow & {
+            id: string;
+            location: CucumberLocation;
+        })[];
+    }[];
+};
+export type CucumberGherkinChild = {
+    scenario?: CucumberScenario;
+    background?: {
+        steps: CucumberGherkinStep[];
+    };
+    rule?: {
+        children: CucumberGherkinChild[];
+    };
+};
+export type CucumberGherkinDocument = {
+    uri?: string;
+    feature?: {
+        name: string;
+        children: CucumberGherkinChild[];
+    };
+};
+export type CucumberHook = {
+    id: string;
+    name?: string;
+    type?: string;
+};
+export type CucumberTestCase = {
+    id: string;
+    pickleId: string;
+    testSteps: {
+        id: string;
+        pickleStepId?: string;
+        hookId?: string;
+    }[];
+};
+export type CucumberTestCaseStarted = {
+    id: string;
+    testCaseId: string;
+    attempt: number;
+    timestamp: CucumberTimestamp;
+};
+export type CucumberTestCaseFinished = {
+    testCaseStartedId: string;
+    timestamp: CucumberTimestamp;
+    willBeRetried: boolean;
+};
+export type CucumberTestStepEvent = {
+    testCaseStartedId: string;
+    testStepId: string;
+    timestamp: CucumberTimestamp;
+};
+export type CucumberTestStepResult = {
+    status: string;
+    duration?: CucumberTimestamp;
+    message?: string;
+    exception?: {
+        type: string;
+        message?: string;
+        stackTrace?: string;
+    };
+};
+export type CucumberTestStepFinished = CucumberTestStepEvent & {
+    testStepResult: CucumberTestStepResult;
+};
+export type CucumberAttachment = {
+    body: string;
+    contentEncoding: "IDENTITY" | "BASE64";
+    mediaType: string;
+    fileName?: string;
+    testCaseStartedId?: string;
+    testStepId?: string;
+};
+export type CucumberMessage = {
+    gherkinDocument?: CucumberGherkinDocument;
+    pickle?: CucumberPickle;
+    hook?: CucumberHook;
+    testCase?: CucumberTestCase;
+    testCaseStarted?: CucumberTestCaseStarted;
+    testCaseFinished?: CucumberTestCaseFinished;
+    testStepStarted?: CucumberTestStepEvent;
+    testStepFinished?: CucumberTestStepFinished;
+    attachment?: CucumberAttachment;
+};

package/dist/cucumbermessages/model.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./allure1/index.js";
 export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
+export * from "./cucumbermessages/index.js";
 export * from "./junitxml/index.js";
 export * from "./xcresult/index.js";
 export * from "./attachments/index.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./allure1/index.js";
 export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
+export * from "./cucumbermessages/index.js";
 export * from "./junitxml/index.js";
 export * from "./xcresult/index.js";
 export * from "./attachments/index.js";

package/dist/junitxml/index.js

@@ -1,6 +1,9 @@
-import * as console from "node:console";
+import console from "node:console";
 import { randomUUID } from "node:crypto";
-import { BufferResultFile } from "@allurereport/reader-api";
+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 { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
 import { XMLParser } from "fast-xml-parser";
 import { ensureString } from "../utils.js";
 import { isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
@@ -37,7 +40,8 @@ export const junitXml = {
             if (!isStringAnyRecord(parsed)) {
                 return false;
             }
-            return await parseRootElement(visitor, parsed);
+            const reportDir = dirname(data instanceof PathResultFile ? data.path : originalFileName);
+            return await parseRootElement(visitor, parsed, reportDir);
         }
         catch (e) {
             console.error("error parsing", originalFileName, e);
@@ -46,7 +50,7 @@ export const junitXml = {
     },
     readerId: () => readerId,
 };
-const parseRootElement = async (visitor, xml) => {
+const parseRootElement = async (visitor, xml, reportDir) => {
     const { testsuite: testSuite } = xml;
     if (isEmptyElement(testSuite)) {
         return true;
@@ -67,26 +71,26 @@ const parseRootElement = async (visitor, xml) => {
             return false;
         }
         for (const testSuitesArrayElement of testSuitesArray) {
-            await parseTestSuite(visitor, testSuitesArrayElement, true);
+            await parseTestSuite(visitor, testSuitesArrayElement, true, reportDir);
         }
         return true;
     }
     if (!isStringAnyRecord(testSuite)) {
         return false;
     }
-    await parseTestSuite(visitor, testSuite, false);
+    await parseTestSuite(visitor, testSuite, false, reportDir);
     return true;
 };
-const parseTestSuite = async (visitor, testSuite, isAggregated) => {
+const parseTestSuite = async (visitor, testSuite, isAggregated, reportDir) => {
     const { name, package: packageAttribute, testcase } = testSuite;
     if (!isStringAnyRecordArray(testcase)) {
         return;
     }
     for (const testcaseElement of testcase) {
-        await parseTestCase(visitor, { name: ensureString(name), suitePackage: ensureString(packageAttribute) }, testcaseElement, isAggregated);
+        await parseTestCase(visitor, { name: ensureString(name), suitePackage: ensureString(packageAttribute) }, testcaseElement, isAggregated, reportDir);
     }
 };
-const parseTestCase = async (visitor, { name: suiteName, suitePackage }, testCase, isAggregated) => {
+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 = ensureString(nameAttribute);
     const className = ensureString(classNameAttribute);
@@ -100,12 +104,12 @@ const parseTestCase = async (visitor, { name: suiteName, suitePackage }, testCas
         status,
         message,
         trace,
-        steps: await parseAttachments(visitor, systemOut, systemErr),
+        steps: await parseAttachments(visitor, reportDir, systemOut, systemErr),
         labels: convertLabels({ suitePackage, suiteName, className, isAggregated }),
     }, { readerId });
 };
 const convertFullName = (className, name) => (className && name ? `${className}.${name}` : undefined);
-const parseAttachments = async (visitor, systemOut, systemErr) => {
+const parseAttachments = async (visitor, reportDir, systemOut, systemErr) => {
     const attachments = [];
     if (systemOut) {
         attachments.push(await visitPlainTextAttachment(visitor, STDOUT_ATTACHMENT_NAME, systemOut));
@@ -113,8 +117,46 @@ const parseAttachments = async (visitor, systemOut, systemErr) => {
     if (systemErr) {
         attachments.push(await visitPlainTextAttachment(visitor, STDERR_ATTACHMENT_NAME, 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 file = new BufferResultFile(content, `${randomUUID()}${extname(path)}`);
+            await visitor.visitAttachmentFile(file, { readerId });
+            attachments.push({
+                type: "attachment",
+                name: basename(path),
+                contentType: file.getContentType(),
+                originalFileName: file.getOriginalFileName(),
+            });
+        }
+        catch (error) {
+            console.warn(`Unable to read JUnit attachment "${path}":`, error);
+        }
+    }
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader",
-  "version": "3.19.0",
+  "version": "3.20.0",
   "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
   "keywords": [
     "allure",
@@ -26,9 +26,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.19.0",
-    "@allurereport/plugin-api": "3.19.0",
-    "@allurereport/reader-api": "3.19.0",
+    "@allurereport/core-api": "3.20.0",
+    "@allurereport/plugin-api": "3.20.0",
+    "@allurereport/reader-api": "3.20.0",
     "fast-xml-parser": "^5.11.1"
   },
   "devDependencies": {