@allurereport/reader 3.0.0-beta.5 → 3.0.0-beta.6

package/dist/allure1/index.js

@@ -2,19 +2,35 @@ 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 arrayTags = new Set([
-    "test-suite.test-cases.test-case",
-    "test-suite.test-cases.test-case.steps.step",
-    "test-suite.test-cases.test-case.attachments.attachment",
-    "test-suite.test-cases.test-case.labels",
+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: (tagName, jPath) => arrayTags.has(jPath),
+    isArray: arrayTags.has.bind(arrayTags),
 });
 const readerId = "allure1";
 export const allure1 = {
@@ -49,7 +65,7 @@ const parseRootElement = async (visitor, xml) => {
     return await parseTestSuite(visitor, testSuite);
 };
 const parseTestSuite = async (visitor, testSuite) => {
-    const { "name": testSuiteName, "test-cases": testCases } = testSuite;
+    const { "name": testSuiteName, "title": testSuiteTitle, "description": descriptionElement, "test-cases": testCases, "labels": labelsElement, } = testSuite;
     if (!isStringAnyRecord(testCases)) {
         return false;
     }
@@ -57,20 +73,83 @@ const parseTestSuite = async (visitor, testSuite) => {
     if (!isStringAnyRecordArray(testCase)) {
         return false;
     }
+    const labels = parseLabels(labelsElement);
     for (const tc of testCase) {
-        await parseTestCase(visitor, { name: ensureString(testSuiteName) }, tc);
+        await parseTestCase(visitor, {
+            name: ensureString(testSuiteName),
+            title: ensureString(testSuiteTitle),
+            ...parseDescription(descriptionElement),
+            labels,
+        }, tc);
     }
     return true;
 };
 const parseTestCase = async (visitor, testSuite, testCase) => {
-    const { name: nameElement, status: statusElement, failure: failureElement, parameters: parametersElement, steps: stepsElement, start: startElement, stop: stopElement, } = testCase;
-    const name = ensureString(nameElement);
+    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);
-    await visitor.visitTestResult({ name, status, start, stop, duration, message, trace, parameters, steps }, { readerId });
+    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)) {
@@ -85,6 +164,50 @@ const parseTime = (startElement, 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;
@@ -94,11 +217,11 @@ const parseSteps = (element) => {
         return undefined;
     }
     return stepElement.map((step) => {
-        const { name, title, status, start: startElement, stop: stopElement, steps: stepsElement } = 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);
+        const steps = [...(parseSteps(stepsElement) ?? []), ...(parseAttachments(attachmentsElement) ?? [])];
         return {
-            name: ensureString(title) ?? ensureString(name),
+            name: ensureString(title) ?? ensureString(name) ?? DEFAULT_STEP_NAME,
             status: convertStatus(ensureString(status)),
             start,
             stop,
@@ -108,6 +231,24 @@ const parseSteps = (element) => {
         };
     });
 };
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader",
-  "version": "3.0.0-beta.5",
+  "version": "3.0.0-beta.6",
   "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
   "keywords": [
     "allure",
@@ -26,9 +26,9 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.5",
-    "@allurereport/plugin-api": "3.0.0-beta.5",
-    "@allurereport/reader-api": "3.0.0-beta.5",
+    "@allurereport/core-api": "3.0.0-beta.6",
+    "@allurereport/plugin-api": "3.0.0-beta.6",
+    "@allurereport/reader-api": "3.0.0-beta.6",
     "fast-xml-parser": "^4.5.0"
   },
   "devDependencies": {