@allurereport/reader 3.0.0-beta.9 → 3.0.1

package/dist/xcresult/utils.js

@@ -0,0 +1,378 @@
+import { isDefined, isNumber } from "@allurereport/reader-api";
+import { randomUUID } from "node:crypto";
+export const MS_IN_S = 1000;
+export const ALLURE_API_ACTIVITY_PREFIX = "allure.";
+export const statusPriorities = new Map([
+    ["failed", 0],
+    ["broken", 1],
+    ["unknown", 2],
+    ["skipped", 3],
+    ["passed", 4],
+]);
+export const utiToMediaType = {
+    "public.plain-text": "text/plain",
+    "public.utf8-plain-text": "text/plain",
+    "public.utf16-external-plain-text": "text/plain",
+    "public.utf16-plain-text": "text/plain",
+    "public.rtf": "text/rtf",
+    "public.html": "text/html",
+    "public.xml": "text/xml",
+    "public.source-code": "text/plain",
+    "public.c-source": "text/plain",
+    "public.objective-c-source": "text/plain",
+    "public.c-plus-plus-source": "text/plain",
+    "public.objective-c-plus-​plus-source": "text/plain",
+    "public.c-header": "text/plain",
+    "public.c-plus-plus-header": "text/plain",
+    "com.sun.java-source": "text/plain",
+    "public.script": "text/plain",
+    "public.assembly-source": "text/plain",
+    "com.apple.rez-source": "text/plain",
+    "public.mig-source": "text/plain",
+    "com.apple.symbol-export": "text/plain",
+    "com.netscape.javascript-​source": "text/plain",
+    "public.shell-script": "text/plain",
+    "public.csh-script": "text/plain",
+    "public.perl-script": "text/plain",
+    "public.python-script": "text/plain",
+    "public.ruby-script": "text/plain",
+    "public.php-script": "text/plain",
+    "com.sun.java-web-start": "text/plain",
+    "com.apple.applescript.text": "text/plain",
+    "com.microsoft.windows-​executable": "application/x-msdownload",
+    "com.microsoft.windows-​dynamic-link-library": "application/x-msdownload",
+    "com.sun.java-archive": "application/java-archive",
+    "com.apple.quartz-​composer-composition": "application/x-quartzcomposer",
+    "org.gnu.gnu-tar-archive": "application/x-gtar",
+    "public.tar-archive": "application/x-tar",
+    "org.gnu.gnu-zip-archive": "application/gzip",
+    "org.gnu.gnu-zip-tar-archive": "application/gzip",
+    "com.apple.binhex-archive": "application/mac-binhex40",
+    "com.apple.macbinary-​archive": "application/x-macbinary",
+    "public.heic": "image/heic",
+    "public.heif": "image/heif",
+    "public.jpeg": "image/jpeg",
+    "public.jpeg-2000": "image/jp2",
+    "public.tiff": "image/tiff",
+    "com.apple.pict": "image/x-pict",
+    "public.png": "image/png",
+    "public.xbitmap-image": "image/x-quicktime",
+    "com.apple.quicktime-image": "image/x-quicktime",
+    "com.apple.quicktime-movie": "video/quicktime",
+    "public.avi": "video/x-msvideo",
+    "public.mpeg": "video/mpeg",
+    "public.mpeg-4": "video/mp4",
+    "public.3gpp": "video/3gpp",
+    "public.3gpp2": "video/3gpp2",
+    "public.mp3": "audio/mpeg",
+    "public.mpeg-4-audio": "audio/mp4",
+    "public.ulaw-audio": "audio/basic",
+    "public.aifc-audio": "audio/x-aiff",
+    "public.aiff-audio": "audio/x-aiff",
+    "com.pkware.zip-archive": "application/zip",
+    "com.adobe.pdf": "application/pdf",
+    "com.adobe.photoshop-image": "image/vnd.adobe.photoshop",
+    "com.compuserve.gif": "image/gif",
+    "com.microsoft.bmp": "image/bmp",
+    "com.microsoft.ico": "image/vnd.microsoft.icon",
+    "com.microsoft.word.doc": "application/msword",
+    "com.microsoft.excel.xls": "application/vnd.ms-excel",
+    "com.microsoft.powerpoint.ppt": "application/vnd.ms-powerpoint",
+    "com.microsoft.waveform-audio": "audio/x-wav",
+    "com.microsoft.advanced-systems-format": "video/x-ms-asf",
+    "com.microsoft.windows-media-wm": "video/x-ms-wm",
+    "com.microsoft.windows-media-wmv": "video/x-ms-wmv",
+    "com.microsoft.windows-media-wmp": "video/x-ms-wmp",
+    "com.microsoft.windows-media-wma": "video/x-ms-wma",
+    "com.microsoft.advanced-stream-redirector": "video/x-ms-asx",
+    "com.microsoft.windows-media-wmx": "video/x-ms-wmx",
+    "com.microsoft.windows-media-wvx": "video/x-ms-wvx",
+    "com.microsoft.windows-media-wax": "video/x-ms-wax",
+    "com.truevision.tga-image": "image/x-tga",
+    "com.sgi.sgi-image": "image/x-sgi",
+    "com.kodak.flashpix.image": "image/vnd.fpx",
+    "com.real.realmedia": "application/vnd.rn-realmedia",
+    "com.real.realaudio": "audio/vnd.rn-realaudio",
+    "com.real.smil": "application/smil",
+    "com.allume.stuffit-archive": "application/x-stuffit",
+};
+export const getMediaTypeByUti = (uti) => (uti ? utiToMediaType[uti] : undefined);
+export const prependTitle = (title, text, spaces) => [title, ...text.split("\n").map((l) => `${" ".repeat(spaces)}${l}`)].join("\n");
+export const getWorstStatusWithDetails = (failureSteps) => {
+    const sortedFailureSteps = [...failureSteps];
+    sortedFailureSteps.sort(({ status: statusA }, { status: statusB }) => statusPriorities.get(statusA ?? "unknown") - statusPriorities.get(statusB ?? "unknown"));
+    if (!sortedFailureSteps.length) {
+        return {};
+    }
+    const { status, trace, message: worstStepMessage } = sortedFailureSteps[0];
+    const totalFailuresCount = failureSteps.length;
+    const expectedFailuresCount = countExpectedFailures(failureSteps);
+    const message = resolveFailureMessage(worstStepMessage, totalFailuresCount, expectedFailuresCount);
+    return { status, message, trace };
+};
+export const countExpectedFailures = (failureSteps) => failureSteps.reduce((a, { status }) => (status === "passed" ? a + 1 : a), 0);
+export const resolveFailureMessage = (firstFailureMessage, failuresCount, expectedFailuresCount) => {
+    switch (failuresCount) {
+        case 0:
+            return undefined;
+        case 1:
+            return firstFailureMessage;
+        default:
+            return getAggregatedFailureMessage(firstFailureMessage, failuresCount, expectedFailuresCount);
+    }
+};
+export const getAggregatedFailureMessage = (message, failures, expected) => {
+    const [summary, prefix] = failures === expected
+        ? [`${failures} expected failures have occured`, "The first one is"]
+        : expected === 0
+            ? [`${failures} failures have occured`, "The first one is"]
+            : [`${failures} failures have occured (${expected} expected)`, "The first unexpected one is"];
+    return message ? prependTitle(`${summary}. ${prefix}:`, message, 2) : summary;
+};
+export const DEFAULT_BUNDLE_NAME = "The test bundle name is not defined";
+export const DEFAULT_SUITE_ID = "__unknown__";
+export const DEFAULT_SUITE_NAME = "The test suite name is not defined";
+export const DEFAULT_TEST_NAME = "The test name is not defined";
+export const DEFAULT_STEP_NAME = "The test name is not defined";
+export const DEFAULT_ATTACHMENT_NAME = "Attachment";
+export const DEFAULT_EXPECTED_FAILURE_REASON = "Expected failure";
+export const SURROGATE_DEVICE_ID = randomUUID();
+export const SURROGATE_TEST_PLAN_ID = randomUUID();
+export const SURROGATE_ARGS_ID = randomUUID();
+export const getArgsKeyByValues = (values) => values.map(String).join(",");
+export const getArgsKey = (args) => getArgsKeyByValues(args.map((arg) => arg?.value));
+export const createTestRunLookup = (entries) => mappedGroupBy(entries, ([{ device }]) => device ?? SURROGATE_DEVICE_ID, (deviceRuns) => mappedGroupBy(deviceRuns, ([{ testPlan }]) => testPlan ?? SURROGATE_TEST_PLAN_ID, (configRuns) => mappedGroupBy(configRuns, ([{ args }]) => (args && args.length ? getArgsKey(args) : SURROGATE_ARGS_ID), (argRuns) => {
+    argRuns.sort(([{ attempt: attemptA }], [{ attempt: attemptB }]) => (attemptA ?? 0) - (attemptB ?? 0));
+    return argRuns.map(([, data]) => data);
+})));
+export const lookupTestAttempts = (lookup, { args, device, testPlan }) => lookup
+    .get(device ?? SURROGATE_DEVICE_ID)
+    ?.get(testPlan ?? SURROGATE_TEST_PLAN_ID)
+    ?.get(args ? getArgsKeyByValues(args) : SURROGATE_ARGS_ID);
+export const lookupTestAttempt = (lookup, selector) => {
+    const attempts = lookupTestAttempts(lookup, selector);
+    const { attempt = 0 } = selector;
+    return attempts?.[attempt];
+};
+export const lookupNextTestAttempt = (lookup, selector, pred) => {
+    const attempts = lookupTestAttempts(lookup, selector);
+    return attempts?.find(pred);
+};
+export const groupBy = (values, keyFn) => values.reduce((m, v) => {
+    const key = keyFn(v);
+    if (!m.get(key)?.push(v)) {
+        m.set(key, [v]);
+    }
+    return m;
+}, new Map());
+export const mappedGroupBy = (values, keyFn, groupMapFn) => {
+    const result = new Map();
+    for (const [k, g] of groupBy(values, keyFn)) {
+        result.set(k, groupMapFn(g));
+    }
+    return result;
+};
+export const getTargetDetails = ({ architecture, model, platform, osVersion } = {}) => {
+    const osPart = platform ? (osVersion ? `${platform} ${osVersion}` : platform) : undefined;
+    return [model, architecture, osPart].filter(isDefined).join(", ") || undefined;
+};
+export const compareChronologically = ({ start: startA, stop: stopA }, { start: startB, stop: stopB }) => (startA ?? 0) - (startB ?? 0) || (stopA ?? 0) - (stopB ?? 0);
+export const toSortedSteps = (...stepArrays) => {
+    const allSteps = stepArrays.reduce((result, steps) => {
+        result.push(...steps);
+        return result;
+    }, []);
+    allSteps.sort(compareChronologically);
+    return allSteps;
+};
+export const secondsToMilliseconds = (seconds) => isNumber(seconds) ? Math.round(MS_IN_S * seconds) : undefined;
+export const parseAsAllureApiActivity = (title) => {
+    if (isPotentialAllureApiActivity(title)) {
+        const maybeApiCall = title.slice(ALLURE_API_ACTIVITY_PREFIX.length);
+        const { apiCall, value } = splitApiCallAndValue(maybeApiCall);
+        switch (apiCall) {
+            case "id":
+                return { type: "label", value: { name: "ALLURE_ID", value } };
+            case "name":
+                return { type: "name", value };
+            case "description":
+                return { type: "description", value };
+            case "precondition":
+                return { type: "precondition", value };
+            case "expectedResult":
+                return { type: "expectedResult", value };
+            case "flaky":
+                return { type: "flaky", value: parseBooleanApiArg(value) };
+            case "muted":
+                return { type: "muted", value: parseBooleanApiArg(value) };
+            case "known":
+                return { type: "known", value: parseBooleanApiArg(value) };
+            default:
+                return parseComplexAllureApiCall(apiCall, value);
+        }
+    }
+};
+export const splitApiCallAndValue = (text) => {
+    const apiValueSeparatorIndex = indexOfAny(text, ":", "=");
+    return apiValueSeparatorIndex === -1
+        ? { apiCall: text, value: "" }
+        : { apiCall: text.slice(0, apiValueSeparatorIndex).trim(), value: text.slice(apiValueSeparatorIndex + 1) };
+};
+export const applyApiCalls = (testResult, apiCalls) => {
+    const groupedApiCalls = mappedGroupBy(apiCalls, (v) => v.type, (g) => g.map(({ value }) => value));
+    for (const [type, values] of groupedApiCalls) {
+        applyApiCallGroup(testResult, type, values);
+    }
+};
+const applyApiCallGroup = (testResult, type, values) => {
+    switch (type) {
+        case "name":
+            testResult.name = values.at(-1);
+            break;
+        case "flaky":
+            testResult.flaky = values.at(-1);
+            break;
+        case "muted":
+            testResult.muted = values.at(-1);
+            break;
+        case "known":
+            testResult.known = values.at(-1);
+            break;
+        case "description":
+            testResult.description = mergeMarkdownBlocks(testResult.description, ...values);
+            break;
+        case "precondition":
+            testResult.precondition = mergeMarkdownBlocks(testResult.precondition, ...values);
+            break;
+        case "expectedResult":
+            testResult.expectedResult = mergeMarkdownBlocks(testResult.expectedResult, ...values);
+            break;
+        case "label":
+            testResult.labels = [...(testResult.labels ?? []), ...values];
+            break;
+        case "link":
+            testResult.links = [...(testResult.links ?? []), ...values];
+            break;
+        case "parameter":
+            testResult.parameters = [...(testResult.parameters ?? []), ...values];
+            break;
+    }
+};
+export const createTestLabels = ({ hostName, projectName, bundle, suites, className, functionName, tags, }) => {
+    const labels = [];
+    if (hostName) {
+        labels.push({ name: "host", value: hostName });
+    }
+    const packageName = [projectName, bundle].filter(isDefined).join(".");
+    if (packageName) {
+        labels.push({ name: "package", value: packageName });
+    }
+    if (className) {
+        labels.push({ name: "testClass", value: className });
+    }
+    if (functionName) {
+        labels.push({ name: "testMethod", value: functionName });
+    }
+    if (bundle) {
+        labels.push({ name: "parentSuite", value: bundle });
+    }
+    const [suite, ...subSuites] = suites;
+    if (suite) {
+        labels.push({ name: "suite", value: suite });
+    }
+    const subSuite = subSuites.join(" > ");
+    if (subSuite) {
+        labels.push({ name: "subSuite", value: subSuite });
+    }
+    labels.push(...tags.map((value) => ({ name: "tag", value })));
+    return labels;
+};
+export const getDefaultAttachmentName = (index, length) => {
+    return length > 1 ? `${DEFAULT_ATTACHMENT_NAME} ${index + 1}` : DEFAULT_ATTACHMENT_NAME;
+};
+const mergeMarkdownBlocks = (...blocks) => blocks.filter(isDefined).reduce((a, b) => `${a}\n\n${b}`);
+const isPotentialAllureApiActivity = (title) => isDefined(title) && title.startsWith(ALLURE_API_ACTIVITY_PREFIX);
+const parseComplexAllureApiCall = (apiCall, value) => {
+    const { apiFn, primaryOption, secondaryOptions } = splitApiFnAndOptions(apiCall);
+    switch (apiFn) {
+        case "label":
+            return primaryOption ? parseAllureLabelApiCall(primaryOption, value) : undefined;
+        case "link":
+            return parseAllureLinkApiCall(primaryOption, secondaryOptions, value);
+        case "issue":
+            return parseAllureLinkApiCall(primaryOption, ["issue"], value);
+        case "tms":
+            return parseAllureLinkApiCall(primaryOption, ["tms"], value);
+        case "parameter":
+            return primaryOption ? parseAllureParameterApiCall(primaryOption, secondaryOptions, value) : undefined;
+    }
+};
+const splitApiFnAndOptions = (apiCall) => {
+    const apiFnEnd = apiCall.indexOf(".");
+    if (apiFnEnd === -1) {
+        const { primaryOption: apiFn, secondaryOptions } = parseAllureApiCallOptions(apiCall);
+        return { apiFn, primaryOption: undefined, secondaryOptions };
+    }
+    return {
+        apiFn: apiCall.slice(0, apiFnEnd),
+        ...parseAllureApiCallOptions(apiCall.slice(apiFnEnd + 1)),
+    };
+};
+const parseAllureLabelApiCall = (name, value) => name ? { type: "label", value: { name, value } } : undefined;
+const parseAllureLinkApiCall = (name, [type], url) => {
+    return { type: "link", value: { name, type, url } };
+};
+const parseAllureParameterApiCall = (name, options, value) => {
+    const parameter = { name, value };
+    options.forEach((option) => {
+        switch (option.toLowerCase()) {
+            case "hidden":
+                parameter.hidden = true;
+                break;
+            case "excluded":
+                parameter.excluded = true;
+                break;
+            case "masked":
+                parameter.masked = true;
+                break;
+        }
+    });
+    return { type: "parameter", value: parameter };
+};
+const parseAllureApiCallOptions = (options) => {
+    const primaryEnd = options.indexOf("[");
+    if (primaryEnd !== -1) {
+        const primaryOption = decodeURIComponentSafe(options.slice(0, primaryEnd));
+        if (options.indexOf("]") === options.length - 1) {
+            return {
+                primaryOption,
+                secondaryOptions: options
+                    .slice(primaryEnd + 1, -1)
+                    .split(",")
+                    .map((v) => decodeURIComponentSafe(v.trim())),
+            };
+        }
+        return { primaryOption, secondaryOptions: [] };
+    }
+    return { primaryOption: decodeURIComponentSafe(options), secondaryOptions: [] };
+};
+const indexOfAny = (input, ...searchStrings) => {
+    const indices = searchStrings.map((search) => input.indexOf(search)).filter((i) => i !== -1);
+    switch (indices.length) {
+        case 0:
+            return -1;
+        case 1:
+            return indices[0];
+        default:
+            return Math.min(...indices);
+    }
+};
+const parseBooleanApiArg = (value) => !value || value.toLowerCase() === "true";
+const decodeURIComponentSafe = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};

package/dist/xcresult/xcresulttool/cli.d.ts

@@ -0,0 +1,10 @@
+import type { XcActivities, XcTestDetails, XcTests } from "./xcModel.js";
+export declare const xcrunJson: <T>(utilityName: string, ...args: readonly string[]) => Promise<import("@allurereport/reader-api").Unknown<T>>;
+export declare const xcrunBinary: (utilityName: string, ...args: readonly string[]) => Promise<Buffer | undefined>;
+export declare const xcresulttool: <T>(...args: readonly string[]) => Promise<import("@allurereport/reader-api").Unknown<T>>;
+export declare const xcresulttoolBinary: (...args: readonly string[]) => Promise<Buffer | undefined>;
+export declare const version: () => Promise<string>;
+export declare const getTests: (xcResultPath: string) => Promise<import("@allurereport/reader-api").Unknown<XcTests>>;
+export declare const getTestDetails: (xcResultPath: string, testId: string) => Promise<import("@allurereport/reader-api").Unknown<XcTestDetails>>;
+export declare const getTestActivities: (xcResultPath: string, testId: string) => Promise<import("@allurereport/reader-api").Unknown<XcActivities>>;
+export declare const exportAttachments: (xcResultPath: string, outputPath: string) => Promise<void>;

package/dist/xcresult/xcresulttool/cli.js

@@ -0,0 +1,42 @@
+import { collectCliToolStdoutText, invokeCliTool, invokeJsonCliTool, invokeStdoutCliTool, } from "@allurereport/reader-api";
+import console from "node:console";
+export const xcrunJson = async (utilityName, ...args) => {
+    try {
+        return await invokeJsonCliTool("xcrun", [utilityName, ...args], { timeout: 10000 });
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+export const xcrunBinary = async (utilityName, ...args) => {
+    try {
+        const chunks = [];
+        for await (const chunk of invokeStdoutCliTool("xcrun", [utilityName, ...args], { timeout: 60000 })) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+export const xcresulttool = async (...args) => await xcrunJson("xcresulttool", ...args);
+export const xcresulttoolBinary = async (...args) => await xcrunBinary("xcresulttool", ...args);
+export const version = async () => {
+    const stdout = await collectCliToolStdoutText("xcrun", ["xcresulttool", "version"], { timeout: 10000 });
+    return stdout.trim();
+};
+export const getTests = async (xcResultPath) => await xcresulttool("get", "test-results", "tests", "--path", xcResultPath);
+export const getTestDetails = async (xcResultPath, testId) => await xcresulttool("get", "test-results", "test-details", "--test-id", testId, "--path", xcResultPath);
+export const getTestActivities = async (xcResultPath, testId) => await xcresulttool("get", "test-results", "activities", "--test-id", testId, "--path", xcResultPath);
+export const exportAttachments = async (xcResultPath, outputPath) => {
+    await invokeCliTool("xcrun", [
+        "xcresulttool",
+        "export",
+        "attachments",
+        "--path",
+        xcResultPath,
+        "--output-path",
+        outputPath,
+    ]);
+};

package/dist/xcresult/xcresulttool/index.d.ts

@@ -0,0 +1,7 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import type { RawTestResult } from "@allurereport/reader-api";
+import { XcresultParser } from "./model.js";
+export default class NewApiParser extends XcresultParser {
+    #private;
+    parse(): AsyncGenerator<ResultFile | RawTestResult, void, unknown>;
+}