@expo/build-tools 22.0.0 → 22.3.0

package/dist/steps/functions/maestroResultParser.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export interface MaestroFlowResult {
     name: string;
     path: string;
@@ -23,6 +24,34 @@ export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcas
     file: string;
 })[];
 export declare function junitFileHasFileAttrs(junitFile: string): Promise<boolean>;
+declare const MaestroRunnerReportSchema: z.ZodObject<{
+    flows: z.ZodPipe<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        sourceFile: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"skipped">;
+    }, z.core.$strip>], "status">>, z.ZodTransform<{
+        name: string;
+        sourceFile: string;
+        status: "failed" | "passed";
+    }[], ({
+        name: string;
+        sourceFile: string;
+        status: "failed" | "passed";
+    } | {
+        status: "skipped";
+    })[]>>;
+}, z.core.$strip>;
+type MaestroRunnerReport = z.infer<typeof MaestroRunnerReportSchema>;
+export declare function parseFailedFlowsFromMaestroRunnerReport(args: {
+    reportDirectory: string;
+    workingDirectory: string;
+}): Promise<string[] | null>;
+export declare function parseMaestroRunnerReport(reportDirectory: string): Promise<MaestroRunnerReport | null>;
 export declare function parseMaestroResultsFromFileAttrs(junitDirectory: string): Promise<MaestroFlowResult[]>;
 /**
  * Returns the `file=` paths of the failing testcases in the given attempt's
@@ -75,3 +104,4 @@ export declare function copyLatestAttemptXml(args: {
     sourceDir: string;
     outputPath: string;
 }): Promise<void>;
+export {};

package/dist/steps/functions/maestroResultParser.js

@@ -7,6 +7,8 @@ exports.parseFailedFlowNamesFromJUnitFile = parseFailedFlowNamesFromJUnitFile;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.isFileAttrRun = isFileAttrRun;
 exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
+exports.parseFailedFlowsFromMaestroRunnerReport = parseFailedFlowsFromMaestroRunnerReport;
+exports.parseMaestroRunnerReport = parseMaestroRunnerReport;
 exports.parseMaestroResultsFromFileAttrs = parseMaestroResultsFromFileAttrs;
 exports.parseFailedFlowsFromFileAttrs = parseFailedFlowsFromFileAttrs;
 exports.parseMaestroResults = parseMaestroResults;
@@ -17,6 +19,7 @@ const results_1 = require("@expo/results");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
 // Per-attempt JUnit XML files use `*-attempt-N.xml` names; this extracts N.
 const ATTEMPT_PATTERN = /attempt-(\d+)/;
 const xmlParser = new fast_xml_parser_1.XMLParser({
@@ -25,10 +28,16 @@ const xmlParser = new fast_xml_parser_1.XMLParser({
     // Ensure single-element arrays are always arrays
     isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });
-// A `file=` attribute counts as present only when it is a non-empty string.
+// Official Maestro writes the flow path as a `file=` testcase attribute. maestro-runner writes
+// the same value as a `<property name="file" value="..."/>` child.
 function fileAttrOf(tc) {
     const f = tc?.['@_file'];
-    return typeof f === 'string' && f.length > 0 ? f : undefined;
+    if (typeof f === 'string' && f.length > 0) {
+        return f;
+    }
+    const properties = tc?.properties?.property ?? [];
+    const fileProperty = properties.find(property => property['@_name'] === 'file')?.['@_value'];
+    return typeof fileProperty === 'string' && fileProperty.length > 0 ? fileProperty : undefined;
 }
 function parseJUnitContent(content) {
     const results = [];
@@ -48,22 +57,40 @@ function parseJUnitContent(content) {
                 if (!name) {
                     continue;
                 }
+                // Standard JUnit marks skipped tests with a <skipped/> child (no failure/error). Exclude
+                // them so they aren't miscounted as passed, matching the report.json path which drops
+                // skipped flows.
+                if (tc.skipped != null) {
+                    continue;
+                }
                 const file = fileAttrOf(tc);
                 const timeStr = tc['@_time'];
                 const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
                 const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
-                const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
+                // maestro-runner puts the real error in the `message` attribute and the command
+                // label (e.g. `tapOn`) in the body; official Maestro only writes the body. Prefer
+                // `@_message` and fall back to `#text` so both stay correct.
                 const failureText = tc.failure != null
                     ? typeof tc.failure === 'string'
                         ? tc.failure
-                        : (tc.failure?.['#text'] ?? null)
+                        : (tc.failure?.['@_message'] ?? tc.failure?.['#text'] ?? null)
                     : null;
                 const errorText = tc.error != null
                     ? typeof tc.error === 'string'
                         ? tc.error
-                        : (tc.error?.['#text'] ?? null)
+                        : (tc.error?.['@_message'] ?? tc.error?.['#text'] ?? null)
                     : null;
                 const errorMessage = failureText ?? errorText ?? null;
+                // Official Maestro uses status="SUCCESS". maestro-runner uses standard JUnit semantics:
+                // a testcase passes when it has no failure or error child.
+                const statusAttribute = tc['@_status'];
+                const status = typeof statusAttribute === 'string'
+                    ? statusAttribute === 'SUCCESS'
+                        ? 'passed'
+                        : 'failed'
+                    : tc.failure == null && tc.error == null
+                        ? 'passed'
+                        : 'failed';
                 const rawProperties = tc.properties?.property ?? [];
                 const properties = {};
                 for (const prop of rawProperties) {
@@ -143,6 +170,52 @@ async function junitFileHasFileAttrs(junitFile) {
 async function fileExists(absPath) {
     return (await (0, results_1.asyncResult)(promises_1.default.stat(absPath))).ok;
 }
+// maestro-runner writes report.json as the source of truth for a run. Use it for runner control
+// flow because sourceFile preserves the exact flow path, while older runner JUnit reports flatten
+// it to a basename. Keep only passed and failed flows so the result matches Maestro JUnit reports,
+// which do not include skipped flows.
+const MaestroRunnerRecordedFlowSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    sourceFile: zod_1.z.string().min(1),
+    status: zod_1.z.enum(['passed', 'failed']),
+});
+const MaestroRunnerReportSchema = zod_1.z.object({
+    flows: zod_1.z
+        .array(zod_1.z.discriminatedUnion('status', [
+        MaestroRunnerRecordedFlowSchema,
+        zod_1.z.object({ status: zod_1.z.literal('skipped') }),
+    ]))
+        .transform(flows => flows.filter((flow) => flow.status !== 'skipped')),
+});
+async function parseFailedFlowsFromMaestroRunnerReport(args) {
+    const report = await parseMaestroRunnerReport(args.reportDirectory);
+    if (report === null) {
+        return null;
+    }
+    const failedPaths = [
+        ...new Set(report.flows.filter(flow => flow.status === 'failed').map(flow => flow.sourceFile)),
+    ];
+    if (failedPaths.length === 0) {
+        return null;
+    }
+    for (const flowPath of failedPaths) {
+        if (!(await fileExists(path_1.default.resolve(args.workingDirectory, flowPath)))) {
+            return null;
+        }
+    }
+    return failedPaths;
+}
+async function parseMaestroRunnerReport(reportDirectory) {
+    let report;
+    try {
+        report = JSON.parse(await promises_1.default.readFile(path_1.default.join(reportDirectory, 'report.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    const result = MaestroRunnerReportSchema.safeParse(report);
+    return result.success ? result.data : null;
+}
 // Group by `file=` so two same-named flows in different files stay separate.
 async function parseMaestroResultsFromFileAttrs(junitDirectory) {
     let junitEntries;

package/dist/steps/functions/maestroScreenshots.d.ts

@@ -21,6 +21,12 @@ export declare function harvestFailureScreenshotsAsync(args: {
     failedFlowNames: ReadonlySet<string>;
     logger: bunyan;
 }): Promise<HarvestedScreenshot[]>;
+export declare function harvestMaestroRunnerFailureScreenshotsAsync(args: {
+    reportDirectory: string;
+    capturedSinceMs: number;
+    attemptIndex: number;
+    logger: bunyan;
+}): Promise<HarvestedScreenshot[]>;
 export declare function computePureFailureFlowNames(testCases: readonly {
     name: string;
     status: 'passed' | 'failed';

package/dist/steps/functions/maestroScreenshots.js

@@ -5,10 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFailureScreenshotFilename = parseFailureScreenshotFilename;
 exports.harvestFailureScreenshotsAsync = harvestFailureScreenshotsAsync;
+exports.harvestMaestroRunnerFailureScreenshotsAsync = harvestMaestroRunnerFailureScreenshotsAsync;
 exports.computePureFailureFlowNames = computePureFailureFlowNames;
 exports.selectFailureScreenshots = selectFailureScreenshots;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const sentry_1 = require("../../sentry");
 // pre-v2.7.0 (Maestro <= 2.6.x): failure screenshots are flat files named
 // `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png` directly in the session dir.
 // The flow name may contain parentheses, so anchor on the `-(` after the epoch and the
@@ -109,6 +112,126 @@ async function harvestFailureScreenshotsAsync(args) {
     // `<flow>-2` collision to collapse (and deduping them would change historical behavior).
     return [...legacyShots, ...dedupeBundleShotsByFlowName(bundleShots)];
 }
+const MaestroRunnerCommandSchema = zod_1.z.object({
+    status: zod_1.z.string().optional(),
+    artifacts: zod_1.z
+        .object({
+        screenshotBefore: zod_1.z.string().optional(),
+        screenshotAfter: zod_1.z.string().optional(),
+    })
+        .optional(),
+    get subCommands() {
+        return zod_1.z.array(MaestroRunnerCommandSchema).optional();
+    },
+});
+const MaestroRunnerFlowDetailSchema = zod_1.z.object({
+    commands: zod_1.z.array(MaestroRunnerCommandSchema).optional(),
+});
+const MaestroRunnerScreenshotReportSchema = zod_1.z.object({
+    flows: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string().optional(),
+        status: zod_1.z.string().optional(),
+        dataFile: zod_1.z.string().optional(),
+    }))
+        .optional(),
+});
+// maestro-runner records failure screenshot paths in its report JSON instead of using the
+// official Maestro debug-directory layout. Never throws, so screenshots cannot change the test
+// result.
+async function harvestMaestroRunnerFailureScreenshotsAsync(args) {
+    let report;
+    try {
+        report = JSON.parse(await promises_1.default.readFile(path_1.default.join(args.reportDirectory, 'report.json'), 'utf8'));
+    }
+    catch (err) {
+        args.logger.info({ err }, `Skipping maestro-runner screenshot harvest: cannot read ${args.reportDirectory}.`);
+        return [];
+    }
+    const parsedReport = MaestroRunnerScreenshotReportSchema.safeParse(report);
+    if (!parsedReport.success) {
+        args.logger.warn({ err: parsedReport.error }, `Skipping maestro-runner screenshot harvest: unexpected report.json shape in ${args.reportDirectory}.`);
+        sentry_1.Sentry.capture('maestro-runner report.json failed schema validation', parsedReport.error);
+        return [];
+    }
+    const flows = parsedReport.data.flows ?? [];
+    const shots = [];
+    for (const { name, status, dataFile } of flows) {
+        if (status !== 'failed' || !name || !dataFile) {
+            continue;
+        }
+        const flowDataPath = resolvePathInsideDirectory(args.reportDirectory, dataFile);
+        if (!flowDataPath) {
+            args.logger.info(`Skipping maestro-runner flow data outside the report directory.`);
+            continue;
+        }
+        let screenshotPath;
+        try {
+            const detail = MaestroRunnerFlowDetailSchema.safeParse(JSON.parse(await promises_1.default.readFile(flowDataPath, 'utf8')));
+            if (!detail.success) {
+                args.logger.warn({ err: detail.error }, `Skipping malformed maestro-runner flow data ${flowDataPath}.`);
+                sentry_1.Sentry.capture('maestro-runner flow data failed schema validation', detail.error);
+                continue;
+            }
+            screenshotPath = findFailedMaestroRunnerScreenshot(detail.data.commands ?? []);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable maestro-runner flow data ${flowDataPath}.`);
+            continue;
+        }
+        if (!screenshotPath) {
+            continue;
+        }
+        const fileAbsPath = resolvePathInsideDirectory(args.reportDirectory, screenshotPath);
+        if (!fileAbsPath) {
+            args.logger.info(`Skipping maestro-runner screenshot outside the report directory.`);
+            continue;
+        }
+        let capturedAtMs;
+        try {
+            capturedAtMs = Math.round((await promises_1.default.stat(fileAbsPath)).mtimeMs);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable screenshot ${fileAbsPath}.`);
+            continue;
+        }
+        if (capturedAtMs < args.capturedSinceMs) {
+            continue;
+        }
+        const flowName = normalizeFlowName(name);
+        shots.push({
+            fileAbsPath,
+            displayName: `Failure Screenshot: ${flowName} (attempt ${args.attemptIndex + 1})`,
+            metadata: {
+                kind: 'maestro-test-screenshot',
+                flowName,
+                attemptIndex: args.attemptIndex,
+                capturedAtMs,
+            },
+        });
+    }
+    return shots;
+}
+function findFailedMaestroRunnerScreenshot(commands) {
+    for (const command of commands) {
+        if (command.status !== 'failed') {
+            continue;
+        }
+        const nested = findFailedMaestroRunnerScreenshot(command.subCommands ?? []);
+        const screenshot = nested ?? command.artifacts?.screenshotAfter ?? command.artifacts?.screenshotBefore;
+        if (screenshot) {
+            return screenshot;
+        }
+    }
+    return undefined;
+}
+function resolvePathInsideDirectory(directory, relativePath) {
+    const candidate = path_1.default.resolve(directory, relativePath);
+    const relative = path_1.default.relative(directory, candidate);
+    return relative !== '..' && !relative.startsWith(`..${path_1.default.sep}`) && !path_1.default.isAbsolute(relative)
+        ? candidate
+        : null;
+}
 // Maestro >= 2.7.0: resolve a bundle dir to its owning failed flow and return that flow's failure
 // screenshot — the highest-numbered step in `screenshots/`. A required failure halts the flow, so
 // the failed step is normally the last (highest-numbered) captured step; earlier warned steps have