@allurereport/reader 3.0.0-beta.9 → 3.0.1

package/dist/xcresult/xcresulttool/index.js

@@ -0,0 +1,311 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NewApiParser_instances, _NewApiParser_processXcNodes, _NewApiParser_processXcResultNode, _NewApiParser_processXcBundleNode, _NewApiParser_processXcTestSuiteNode, _NewApiParser_processXcTestCaseNode;
+import { ensureArray, ensureArrayWithItems, ensureInt, ensureLiteral, ensureObject, ensureString, isArray, isLiteral, isNumber, isObject, isString, } from "@allurereport/reader-api";
+import { randomUUID } from "node:crypto";
+import { DEFAULT_BUNDLE_NAME, DEFAULT_SUITE_NAME, DEFAULT_TEST_NAME, createTestRunLookup, getTargetDetails, lookupNextTestAttempt, secondsToMilliseconds, } from "../utils.js";
+import { getTestActivities, getTestDetails, getTests } from "./cli.js";
+import { XcresultParser } from "./model.js";
+import { XcTestNodeTypeValues, XcTestResultValues } from "./xcModel.js";
+const DURATION_PATTERN = /\d+\.\d+/;
+const ATTACHMENT_NAME_INFIX_PATTERN = /_\d+_[\dA-F]{8}-[\dA-F]{4}-[\dA-F]{4}-[\dA-F]{4}-[\dA-F]{12}/g;
+class NewApiParser extends XcresultParser {
+    constructor() {
+        super(...arguments);
+        _NewApiParser_instances.add(this);
+    }
+    async *parse() {
+        const tests = await getTests(this.xcResultPath);
+        const testNodes = ensureObject(tests)?.testNodes;
+        if (isArray(testNodes)) {
+            yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcNodes).call(this, testNodes, { suites: [] });
+        }
+    }
+}
+_NewApiParser_instances = new WeakSet(), _NewApiParser_processXcNodes = async function* _NewApiParser_processXcNodes(children, state) {
+    for (const child of children) {
+        if (isObject(child)) {
+            yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcResultNode).call(this, child, state);
+        }
+    }
+}, _NewApiParser_processXcResultNode = async function* _NewApiParser_processXcResultNode(node, state) {
+    const { nodeType } = node;
+    switch (ensureLiteral(nodeType, XcTestNodeTypeValues)) {
+        case "Unit test bundle":
+        case "UI test bundle":
+            yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcBundleNode).call(this, node, state);
+        case "Test Suite":
+            yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcTestSuiteNode).call(this, node, state);
+        case "Test Case":
+            yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcTestCaseNode).call(this, node, state);
+    }
+}, _NewApiParser_processXcBundleNode = async function* _NewApiParser_processXcBundleNode(node, state) {
+    const { children, name } = node;
+    yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcNodes).call(this, ensureArray(children) ?? [], {
+        ...state,
+        bundle: ensureString(name) ?? DEFAULT_BUNDLE_NAME,
+    });
+}, _NewApiParser_processXcTestSuiteNode = async function* _NewApiParser_processXcTestSuiteNode(node, state) {
+    const { children, name } = node;
+    const { suites } = state;
+    yield* __classPrivateFieldGet(this, _NewApiParser_instances, "m", _NewApiParser_processXcNodes).call(this, ensureArray(children) ?? [], {
+        ...state,
+        suites: [...suites, ensureString(name) ?? DEFAULT_SUITE_NAME],
+    });
+}, _NewApiParser_processXcTestCaseNode = async function* _NewApiParser_processXcTestCaseNode(node, { bundle, suites }) {
+    const { nodeIdentifier, name: displayName } = node;
+    if (isString(nodeIdentifier)) {
+        const testDetails = await getTestDetails(this.xcResultPath, nodeIdentifier);
+        const testActivities = await getTestActivities(this.xcResultPath, nodeIdentifier);
+        const { testName, tags, testRuns: detailsTestRuns, devices: testDetailsDevices, } = ensureObject(testDetails) ?? {};
+        const crossDeviceTesting = isArray(testDetailsDevices) && testDetailsDevices.length > 1;
+        const detailsRunLookup = createTestDetailsRunLookup(detailsTestRuns);
+        const name = ensureString(displayName) ?? ensureString(testName) ?? DEFAULT_TEST_NAME;
+        const fullName = convertFullName(nodeIdentifier, bundle);
+        const testCaseLabels = convertTestCaseLabels(bundle, suites, nodeIdentifier, tags);
+        const { testRuns: activityTestRuns } = ensureObject(testActivities) ?? {};
+        for (const activityTestRun of ensureArrayWithItems(activityTestRuns, isObject) ?? []) {
+            const { device: activityTestRunDevice, arguments: activityTestRunArguments, testPlanConfiguration: activityTestRunTestPlan, activities, } = activityTestRun;
+            const { labels: deviceLabels, parameters: deviceParameters, deviceId, } = processActivityTestRunDevice(activityTestRunDevice, crossDeviceTesting);
+            const { configurationId } = ensureObject(activityTestRunTestPlan) ?? {};
+            const args = convertActivitiesTestRunArgs(activityTestRunArguments);
+            const { duration, parameters = [], result = "unknown", } = findNextAttemptDataFromTestDetails(detailsRunLookup, {
+                device: deviceId,
+                testPlan: ensureString(configurationId),
+                args,
+            }) ?? {};
+            const createAttachmentFile = this.createAttachmentFile;
+            const { steps, attachmentFiles } = createAttachmentFile
+                ? await convertXcActivitiesToAllureSteps(this.createAttachmentFile, activities)
+                : { attachmentFiles: [] };
+            yield* attachmentFiles;
+            yield {
+                uuid: randomUUID(),
+                fullName,
+                name,
+                start: 0,
+                duration: duration,
+                status: convertXcResultToAllureStatus(result),
+                message: "",
+                trace: "",
+                steps,
+                labels: [...testCaseLabels, ...deviceLabels],
+                links: [],
+                parameters: [...deviceParameters, ...pairParameterNamesWithValues(parameters, args)],
+            };
+        }
+    }
+};
+export default NewApiParser;
+const convertXcActivitiesToAllureSteps = async (createAttachmentFile, activities, parentActivityAttachments = [].values()) => {
+    const attachmentFiles = [];
+    const steps = [];
+    let nextAttachmentOfParentActivity = parentActivityAttachments.next();
+    for (const { title: unvalidatedTitle, attachments, childActivities, startTime } of ensureArrayWithItems(activities, isObject) ?? []) {
+        const title = ensureString(unvalidatedTitle);
+        const start = isNumber(startTime) ? secondsToMilliseconds(startTime) : undefined;
+        const { potentialNames: potentialAttachmentNames, uuid: attachmentFileName, xcName, } = nextAttachmentOfParentActivity.done ? {} : nextAttachmentOfParentActivity.value;
+        const isAttachment = isString(title) && isAttachmentActivity(potentialAttachmentNames, title, childActivities, attachments);
+        if (isAttachment && attachmentFileName && xcName) {
+            const file = await createAttachmentFile(attachmentFileName, xcName);
+            if (file) {
+                attachmentFiles.push(file);
+            }
+            nextAttachmentOfParentActivity = parentActivityAttachments.next();
+            const attachmentStep = {
+                type: "attachment",
+                start,
+                name: title,
+                originalFileName: xcName,
+            };
+            steps.push(attachmentStep);
+            continue;
+        }
+        const stepAttachments = (ensureArrayWithItems(attachments, isObject) ?? [])
+            .map(({ name, uuid }) => (isString(name) && isString(uuid) ? { potentialNames: getPotentialFileNamesFromXcSuggestedName(name), uuid, xcName: name } : undefined))
+            .filter((entry) => typeof entry !== "undefined");
+        const { steps: substeps, attachmentFiles: substepAttachmentFiles } = await convertXcActivitiesToAllureSteps(createAttachmentFile, childActivities, stepAttachments.values());
+        const step = {
+            type: "step",
+            duration: 0,
+            message: "",
+            name: title,
+            parameters: [],
+            start,
+            status: "passed",
+            steps: substeps,
+            stop: 0,
+            trace: "",
+        };
+        attachmentFiles.push(...substepAttachmentFiles);
+        steps.push(step);
+    }
+    return { steps, attachmentFiles };
+};
+const isAttachmentActivity = (potentialAttachmentNames, title, childActivities, attachments) => typeof childActivities === "undefined" &&
+    typeof attachments === "undefined" &&
+    (potentialAttachmentNames?.has(title) ?? false);
+const getPotentialFileNamesFromXcSuggestedName = (xcSuggestedAttachmentName) => new Set([...xcSuggestedAttachmentName.matchAll(ATTACHMENT_NAME_INFIX_PATTERN)].map(({ 0: { length }, index }) => xcSuggestedAttachmentName.slice(0, index) + xcSuggestedAttachmentName.slice(index + length)));
+const convertXcResultToAllureStatus = (xcResult) => {
+    switch (xcResult) {
+        case "Expected Failure":
+            return "passed";
+        case "Failed":
+            return "failed";
+        case "Passed":
+            return "passed";
+        case "Skipped":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+};
+const pairParameterNamesWithValues = (names, values) => names
+    .slice(0, values.length)
+    .map((p, i) => {
+    const value = values[i];
+    return typeof p !== "undefined" && typeof value !== "undefined" ? { name: p, value } : undefined;
+})
+    .filter((p) => typeof p !== "undefined");
+const convertActivitiesTestRunArgs = (args) => isArray(args) ? args.map((a) => (isObject(a) && isString(a.value) ? a.value : undefined)) : [];
+const createTestDetailsRunLookup = (nodes) => createTestRunLookup(collectRunsFromTestDetails(nodes));
+const findNextAttemptDataFromTestDetails = (lookup, selector) => {
+    const attempt = lookupNextTestAttempt(lookup, selector, ({ emitted }) => !emitted);
+    if (attempt) {
+        attempt.emitted = true;
+    }
+    return attempt;
+};
+const collectRunsFromTestDetails = (nodes, coordinates = {}) => {
+    return (ensureArrayWithItems(nodes, isObject) ?? []).flatMap((node) => {
+        const { children, duration, nodeIdentifier, name: nodeName, result } = node;
+        let coordinateCreated = true;
+        let repetition;
+        switch (ensureLiteral(node.nodeType, XcTestNodeTypeValues)) {
+            case "Device":
+                if (isString(nodeIdentifier)) {
+                    coordinates = { ...coordinates, device: nodeIdentifier };
+                }
+            case "Repetition":
+                repetition = ensureInt(nodeIdentifier);
+                if (repetition) {
+                    coordinates = { ...coordinates, attempt: repetition };
+                }
+            case "Arguments":
+                if ("args" in coordinates) {
+                    return [];
+                }
+                if (isString(nodeName)) {
+                    coordinates = { ...coordinates, args: extractArguments(children) };
+                }
+            case "Test Plan Configuration":
+                if (isString(nodeIdentifier)) {
+                    coordinates = { ...coordinates, testPlan: nodeIdentifier };
+                }
+            default:
+                coordinateCreated = false;
+        }
+        const runs = collectRunsFromTestDetails(children, coordinates);
+        return runs.length
+            ? runs
+            : coordinateCreated
+                ? [
+                    coordinates,
+                    {
+                        duration: parseDuration(duration),
+                        parameters: coordinates.args?.map((arg) => arg?.parameter) ?? [],
+                        result: ensureLiteral(result, XcTestResultValues) ?? "unknown",
+                    },
+                ]
+                : [];
+    });
+};
+const extractArguments = (nodes) => {
+    if (isArray(nodes)) {
+        const argumentsNodeIndex = nodes.findIndex((node) => isObject(node) && isLiteral(node.nodeType, ["Arguments"]));
+        const { children } = nodes.splice(argumentsNodeIndex, 1)[0];
+        return (ensureArrayWithItems(children, isObject) ?? [])
+            .filter(({ nodeType }) => isLiteral(nodeType, ["Test Value"]))
+            .map(({ name }) => {
+            if (isString(name) && name) {
+                const colonIndex = name.indexOf(":");
+                if (colonIndex !== -1) {
+                    return {
+                        parameter: name.slice(0, colonIndex).trim(),
+                        value: name.slice(colonIndex + 1).trim(),
+                    };
+                }
+            }
+        });
+    }
+    return [];
+};
+const convertFullName = (testId, testBundle) => testBundle ? `${testBundle}/${testId}` : testId;
+const convertTestCaseLabels = (bundle, suites, testId, tags) => {
+    const labels = [];
+    if (bundle) {
+        labels.push({ name: "package", value: bundle });
+    }
+    const [testClass, testMethod] = convertTestClassAndMethod(testId);
+    if (testClass) {
+        labels.push({ name: "testClass", value: testClass });
+    }
+    if (testMethod) {
+        labels.push({ name: "testMethod", value: testMethod });
+    }
+    if (suites.length) {
+        if (suites.length === 1) {
+            labels.push({ name: "suite", value: suites[0] });
+        }
+        if (suites.length === 2) {
+            labels.push({ name: "suite", value: suites[0] }, { name: "subSuite", value: suites[1] });
+        }
+        else {
+            const [parentSuite, suite, ...subSuites] = suites;
+            labels.push({ name: "parentSuite", value: parentSuite }, { name: "suite", value: suite }, { name: "subSuite", value: subSuites.join(" > ") });
+        }
+    }
+    labels.push(...(ensureArrayWithItems(tags, isString)?.map((t) => ({ name: "tag", value: t })) ?? []));
+    return labels;
+};
+const processActivityTestRunDevice = (device, showDevice) => {
+    const labels = [];
+    const parameters = [];
+    const { architecture, deviceId, deviceName, modelName, osVersion, platform } = ensureObject(device) ?? {};
+    const host = convertHost(device);
+    if (isString(deviceName) && deviceName) {
+        labels.push({ name: "host", value: host });
+        parameters.push({ name: "Target", value: deviceName, hidden: !showDevice });
+        if (showDevice) {
+            const targetDetails = getTargetDetails({
+                architecture: ensureString(architecture),
+                model: ensureString(modelName),
+                platform: ensureString(platform),
+                osVersion: ensureString(osVersion),
+            });
+            if (targetDetails) {
+                parameters.push({ name: "Target details", value: targetDetails, excluded: true });
+            }
+        }
+    }
+    return { labels, parameters, deviceId: ensureString(deviceId) };
+};
+const convertHost = (device) => {
+    const { deviceName, deviceId } = ensureObject(device) ?? {};
+    return ensureString(deviceName) ?? ensureString(deviceId);
+};
+const convertTestClassAndMethod = (testId) => {
+    const parts = testId.split("/");
+    return [parts.slice(0, -1).join("."), parts.at(-1)];
+};
+const parseDuration = (duration) => {
+    if (isString(duration)) {
+        const match = DURATION_PATTERN.exec(duration);
+        if (match) {
+            return secondsToMilliseconds(parseFloat(match[0]));
+        }
+    }
+};

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

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