@allurereport/reader 3.0.0-beta.9 → 3.0.1

package/dist/allure2/index.js

@@ -109,6 +109,7 @@ export const allure2 = {
 const processTestResult = async (visitor, result, originalFileName) => {
     const dest = {
         uuid: ensureString(result.uuid),
+        titlePath: result?.titlePath?.length ? result.titlePath : [],
         fullName: ensureString(result.fullName),
         name: ensureString(result.name),
         testId: ensureString(result.testCaseId),
@@ -120,6 +121,8 @@ const processTestResult = async (visitor, result, originalFileName) => {
         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),

package/dist/allure2/model.d.ts

@@ -42,6 +42,8 @@ export interface StatusDetails {
     known?: boolean;
     muted?: boolean;
     flaky?: boolean;
+    actual?: string;
+    expected?: string;
 }
 interface ExecutableItem {
     name?: string;
@@ -65,6 +67,7 @@ export interface TestResult extends ExecutableItem {
     testCaseId?: string;
     labels?: Label[];
     links?: Link[];
+    titlePath?: string[];
 }
 export interface TestResultContainer {
     uuid?: string;

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * from "./allure1/index.js";
 export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
 export * from "./junitxml/index.js";
+export * from "./xcresult/index.js";
 export * from "./attachments/index.js";
 export type * from "./model.js";

package/dist/index.js

@@ -2,4 +2,5 @@ export * from "./allure1/index.js";
 export * from "./allure2/index.js";
 export * from "./cucumberjson/index.js";
 export * from "./junitxml/index.js";
+export * from "./xcresult/index.js";
 export * from "./attachments/index.js";

package/dist/xcresult/bundle.d.ts

@@ -0,0 +1,7 @@
+export declare const XCRESULTTOOL_MISSING_MESSAGE = "'xcresulttool' is required to parse Xcode Result bundles, but we can't access it on this machine. This tool is a part of Xcode. Please make sure Xcode is installed. Visit this page to learn more about the installation:\n\n    https://developer.apple.com/documentation/safari-developer-tools/installing-xcode-and-simulators\n\nNote that 'xcresulttool' doesn't come with Command Line Tools for Xcode. You need to install the full Xcode package to get it. If you have both installed, make sure the full installation is selected. Switch to it with xcode-select if necessary (the path to Xcode's Developer directory might be different on your machine):\n\n    sudo xcode-select -s /Applications/Xcode.app/Contents/Developer\n\nThe original error that led to this message is shown below.\n";
+export declare const IS_MAC: boolean;
+export declare const isXcResultBundle: (directory: string) => Promise<boolean>;
+export declare const checkUniformTypeIdentifier: (itemPath: string, uti: string) => Promise<boolean | undefined>;
+export declare const isMostProbablyXcResultBundle: (directory: string) => Promise<boolean>;
+export declare const followsXcResultNaming: (directory: string) => boolean;
+export declare const findBundleInfoFile: (directory: string) => Promise<string | undefined>;

package/dist/xcresult/bundle.js

@@ -0,0 +1,68 @@
+import { invokeStdoutCliTool, isDefined } from "@allurereport/reader-api";
+import { lstat } from "node:fs/promises";
+import { platform } from "node:os";
+import path from "node:path";
+const XCODE_INSTALL_URL = "https://developer.apple.com/documentation/safari-developer-tools/installing-xcode-and-simulators";
+const XCODE_SWITCH_COMMAND = "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer";
+export const XCRESULTTOOL_MISSING_MESSAGE = `'xcresulttool' is required to parse Xcode Result bundles, but we can't \
+access it on this machine. This tool is a part of Xcode. Please make sure Xcode is installed. Visit this page to learn \
+more about the installation:
+
+    ${XCODE_INSTALL_URL}
+
+Note that 'xcresulttool' doesn't come with Command Line Tools for Xcode. You need to install the full Xcode package to \
+get it. If you have both installed, make sure the full installation is selected. Switch to it with xcode-select if \
+necessary (the path to Xcode's Developer directory might be different on your machine):
+
+    ${XCODE_SWITCH_COMMAND}
+
+The original error that led to this message is shown below.
+`;
+const MDLS_CONTENT_TYPE_PATTERN = /\s*"(?<uti>[^"]+)"/;
+const bundleInfoFilePaths = new Set([
+    "Info.plist",
+    "Contents/Info.plist",
+    "Support Files/Info.plist",
+    "Resources/Info.plist",
+]);
+export const IS_MAC = platform() === "darwin";
+export const isXcResultBundle = async (directory) => {
+    const hasXcResultUti = IS_MAC
+        ? await checkUniformTypeIdentifier(directory, "com.apple.xcode.resultbundle")
+        : undefined;
+    return hasXcResultUti ?? (await isMostProbablyXcResultBundle(directory));
+};
+export const checkUniformTypeIdentifier = async (itemPath, uti) => {
+    const mdlsArgs = ["-raw", "-attr", "kMDItemContentTypeTree", itemPath];
+    let contentTypeTreeAvailable = false;
+    try {
+        for await (const line of invokeStdoutCliTool("mdls", mdlsArgs, { encoding: "utf-8" })) {
+            const match = MDLS_CONTENT_TYPE_PATTERN.exec(line);
+            if (match) {
+                contentTypeTreeAvailable = true;
+                const [, matchedUti] = match;
+                if (matchedUti === uti) {
+                    return true;
+                }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return contentTypeTreeAvailable ? false : undefined;
+};
+export const isMostProbablyXcResultBundle = async (directory) => isDefined(await findBundleInfoFile(directory)) || followsXcResultNaming(directory);
+export const followsXcResultNaming = (directory) => directory.endsWith(".xcresult");
+export const findBundleInfoFile = async (directory) => {
+    for (const infoFilePath of bundleInfoFilePaths) {
+        const infoFileAbsPath = path.join(directory, infoFilePath);
+        try {
+            const stat = await lstat(infoFileAbsPath);
+            if (stat.isFile()) {
+                return infoFileAbsPath;
+            }
+        }
+        catch { }
+    }
+};

package/dist/xcresult/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsVisitor } from "@allurereport/reader-api";
+export declare const readXcResultBundle: (visitor: ResultsVisitor, directory: string) => Promise<boolean>;

package/dist/xcresult/index.js

@@ -0,0 +1,91 @@
+import console from "node:console";
+import { IS_MAC, XCRESULTTOOL_MISSING_MESSAGE, isXcResultBundle } from "./bundle.js";
+import { version } from "./xcresulttool/cli.js";
+import LegacyApiParser from "./xcresulttool/legacy/index.js";
+import { parseWithExportedAttachments } from "./xcresulttool/utils.js";
+const readerId = "xcresult";
+export const readXcResultBundle = async (visitor, directory) => {
+    if (await isXcResultBundle(directory)) {
+        if (!IS_MAC) {
+            console.warn(`It looks like ${directory} is a Mac OS bundle. Allure 3 can only parse such bundles on a Mac OS machine.`);
+            return false;
+        }
+        const xcResultToolVersion = await maybeGetXcResultToolVersion();
+        if (xcResultToolVersion) {
+            return await parseBundleWithXcResultTool(visitor, directory, xcResultToolVersion);
+        }
+        return true;
+    }
+    return false;
+};
+const maybeGetXcResultToolVersion = async () => {
+    try {
+        return await version();
+    }
+    catch (e) {
+        console.error(XCRESULTTOOL_MISSING_MESSAGE);
+        console.error(e);
+    }
+};
+const parseBundleWithXcResultTool = async (visitor, xcResultPath, xcResultToolVersion) => {
+    try {
+        if (isXcode16OrNewer(xcResultToolVersion)) {
+            await parseWithXcode16OrNewer(visitor, xcResultPath, xcResultToolVersion);
+        }
+        else {
+            await parseWithXcode15OrOlder(visitor, xcResultPath);
+        }
+        return true;
+    }
+    catch (e) {
+        console.error("error parsing", xcResultPath, e);
+    }
+    return false;
+};
+const parseWithXcode15OrOlder = async (visitor, xcResultPath) => {
+    const legacyApiParser = new LegacyApiParser({
+        xcResultPath,
+        xcode16Plus: false,
+    });
+    await tryApi(visitor, xcResultPath, legacyApiParser);
+};
+const parseWithXcode16OrNewer = async (visitor, xcResultPath, xcResultToolVersion) => {
+    await parseWithExportedAttachments(xcResultPath, async (createAttachmentFile) => {
+        const legacyApiParser = new LegacyApiParser({
+            xcResultPath,
+            createAttachmentFile,
+            xcode16Plus: true,
+        });
+        try {
+            await tryApi(visitor, xcResultPath, legacyApiParser);
+            return;
+        }
+        catch (e) {
+            console.error(e);
+            if (legacyApiParser.legacyApiSucceeded()) {
+                throw e;
+            }
+        }
+        throw new Error(`The legacy xcresulttool API can't be accessed in ${xcResultToolVersion}. ` +
+            "The new API is not yet supported by the reader. " +
+            "Please, see https://github.com/allure-framework/allure3/issues/110 for more details");
+    });
+};
+const tryApi = async (visitor, originalFileName, apiParser) => {
+    for await (const x of apiParser.parse()) {
+        if ("readContent" in x) {
+            await visitor.visitAttachmentFile(x, { readerId });
+        }
+        else {
+            visitor.visitTestResult(x, { readerId, metadata: { originalFileName } });
+        }
+    }
+};
+const isXcode16OrNewer = (versionText) => {
+    const versionMatch = versionText.match(/xcresulttool version (\d+)/);
+    if (versionMatch) {
+        const xcResultToolVersion = parseInt(versionMatch[1], 10);
+        return xcResultToolVersion >= 23000;
+    }
+    return false;
+};

package/dist/xcresult/model.d.ts

@@ -0,0 +1,61 @@
+import type { RawTestLabel, RawTestLink, RawTestParameter } from "@allurereport/reader-api";
+import type { XcTestResult } from "./xcresulttool/xcModel.js";
+export type XcAttachments = Map<string, XcAttachmentMetadata[]>;
+export type XcAttachmentMetadata = {
+    path: string;
+    name?: string;
+    timestamp?: number;
+};
+export type TestDetailsRunData = {
+    duration?: number;
+    result?: XcTestResult;
+    parameters?: (string | undefined)[];
+    emitted?: boolean;
+};
+export type TestRunCoordinates = {
+    device?: string;
+    testPlan?: string;
+    attempt?: number;
+    args?: TestRunArgs;
+};
+export type TestRunArgs = ({
+    parameter: string;
+    value: string;
+} | undefined)[];
+export type TestRunSelector = {
+    device?: string;
+    testPlan?: string;
+    attempt?: number;
+    args?: (string | undefined)[];
+};
+export type TestRunLookup<Data> = Map<string, Map<string, Map<string, Data[]>>>;
+export type TargetDescriptor = {
+    model?: string;
+    architecture?: string;
+    platform?: string;
+    osVersion?: string;
+};
+export type AllureApiCallBase<Type extends string, Value> = {
+    type: Type;
+    value: Value;
+};
+export type AllureNameApiCall = AllureApiCallBase<"name", string>;
+export type AllureDescriptionApiCall = AllureApiCallBase<"description", string>;
+export type AllurePreconditionApiCall = AllureApiCallBase<"precondition", string>;
+export type AllureExpectedResultApiCall = AllureApiCallBase<"expectedResult", string>;
+export type AllureLabelApiCall = AllureApiCallBase<"label", RawTestLabel>;
+export type AllureLinkApiCall = AllureApiCallBase<"link", RawTestLink>;
+export type AllureParameterApiCall = AllureApiCallBase<"parameter", RawTestParameter>;
+export type AllureFlakyApiCall = AllureApiCallBase<"flaky", boolean>;
+export type AllureMutedApiCall = AllureApiCallBase<"muted", boolean>;
+export type AllureKnownApiCall = AllureApiCallBase<"known", boolean>;
+export type AllureApiCall = AllureNameApiCall | AllureDescriptionApiCall | AllurePreconditionApiCall | AllureExpectedResultApiCall | AllureLabelApiCall | AllureLinkApiCall | AllureParameterApiCall | AllureFlakyApiCall | AllureMutedApiCall | AllureKnownApiCall;
+export type LabelsInputData = {
+    hostName: string | undefined;
+    projectName: string | undefined;
+    bundle: string | undefined;
+    suites: readonly string[];
+    className: string | undefined;
+    functionName: string | undefined;
+    tags: readonly string[];
+};

package/dist/xcresult/model.js

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

package/dist/xcresult/utils.d.ts

@@ -0,0 +1,42 @@
+import type { RawStep, RawTestLabel, RawTestResult, RawTestStatus, RawTestStepResult, Unknown } from "@allurereport/reader-api";
+import type { AllureApiCall, LabelsInputData, TargetDescriptor, TestRunArgs, TestRunCoordinates, TestRunLookup, TestRunSelector } from "./model.js";
+export declare const MS_IN_S = 1000;
+export declare const ALLURE_API_ACTIVITY_PREFIX = "allure.";
+export declare const statusPriorities: Map<RawTestStatus, number>;
+export declare const utiToMediaType: Record<string, string>;
+export declare const getMediaTypeByUti: (uti: string | undefined) => string | undefined;
+export declare const prependTitle: (title: string, text: string, spaces: number) => string;
+export declare const getWorstStatusWithDetails: (failureSteps: readonly RawTestStepResult[]) => Pick<RawTestStepResult, "status" | "message" | "trace">;
+export declare const countExpectedFailures: (failureSteps: readonly RawTestStepResult[]) => number;
+export declare const resolveFailureMessage: (firstFailureMessage: string | undefined, failuresCount: number, expectedFailuresCount: number) => string | undefined;
+export declare const getAggregatedFailureMessage: (message: string | undefined, failures: number, expected: number) => string;
+export declare const DEFAULT_BUNDLE_NAME = "The test bundle name is not defined";
+export declare const DEFAULT_SUITE_ID = "__unknown__";
+export declare const DEFAULT_SUITE_NAME = "The test suite name is not defined";
+export declare const DEFAULT_TEST_NAME = "The test name is not defined";
+export declare const DEFAULT_STEP_NAME = "The test name is not defined";
+export declare const DEFAULT_ATTACHMENT_NAME = "Attachment";
+export declare const DEFAULT_EXPECTED_FAILURE_REASON = "Expected failure";
+export declare const SURROGATE_DEVICE_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const SURROGATE_TEST_PLAN_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const SURROGATE_ARGS_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const getArgsKeyByValues: (values: readonly (string | undefined)[]) => string;
+export declare const getArgsKey: (args: TestRunArgs) => string;
+export declare const createTestRunLookup: <T>(entries: readonly (readonly [TestRunCoordinates, T])[]) => TestRunLookup<T>;
+export declare const lookupTestAttempts: <T>(lookup: TestRunLookup<T>, { args, device, testPlan }: TestRunSelector) => T[] | undefined;
+export declare const lookupTestAttempt: <Data>(lookup: TestRunLookup<Data>, selector: TestRunSelector) => Data | undefined;
+export declare const lookupNextTestAttempt: <Data>(lookup: TestRunLookup<Data>, selector: TestRunSelector, pred: (data: Data) => boolean) => Data | undefined;
+export declare const groupBy: <T, K>(values: readonly T[], keyFn: (v: T) => K) => Map<K, T[]>;
+export declare const mappedGroupBy: <T, K, G>(values: readonly T[], keyFn: (v: T) => K, groupMapFn: (group: T[]) => G) => Map<K, G>;
+export declare const getTargetDetails: ({ architecture, model, platform, osVersion }?: TargetDescriptor) => string | undefined;
+export declare const compareChronologically: ({ start: startA, stop: stopA }: RawStep, { start: startB, stop: stopB }: RawStep) => number;
+export declare const toSortedSteps: <T extends RawStep>(...stepArrays: readonly (readonly T[])[]) => T[];
+export declare const secondsToMilliseconds: (seconds: Unknown<number>) => number | undefined;
+export declare const parseAsAllureApiActivity: (title: string | undefined) => AllureApiCall | undefined;
+export declare const splitApiCallAndValue: (text: string) => {
+    apiCall: string;
+    value: string;
+};
+export declare const applyApiCalls: (testResult: RawTestResult, apiCalls: readonly AllureApiCall[]) => void;
+export declare const createTestLabels: ({ hostName, projectName, bundle, suites, className, functionName, tags, }: LabelsInputData) => RawTestLabel[];
+export declare const getDefaultAttachmentName: (index: number, length: number) => string;