@expo/build-tools 18.0.2 → 18.0.6

package/dist/customBuildContext.d.ts

@@ -1,6 +1,7 @@
 import { BuildJob, Env, Job, Metadata, StaticJobInterpolationContext } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildRuntimePlatform, ExternalBuildContextProvider } from '@expo/steps';
+import { Client } from '@urql/core';
 import { ArtifactToUpload, BuildContext } from './context';
 export interface BuilderRuntimeApi {
     uploadArtifact: (spec: {
@@ -20,6 +21,7 @@ export declare class CustomBuildContext<TJob extends Job = Job> implements Exter
      */
     readonly startTime: Date;
     readonly logger: bunyan;
+    readonly graphqlClient: Client;
     readonly runtimeApi: BuilderRuntimeApi;
     job: TJob;
     metadata?: Metadata;

package/dist/customBuildContext.js

@@ -34,6 +34,7 @@ class CustomBuildContext {
      */
     startTime;
     logger;
+    graphqlClient;
     runtimeApi;
     job;
     metadata;
@@ -43,6 +44,7 @@ class CustomBuildContext {
         this.job = buildCtx.job;
         this.metadata = buildCtx.metadata;
         this.logger = buildCtx.logger.child({ phase: eas_build_job_1.BuildPhase.CUSTOM });
+        this.graphqlClient = buildCtx.graphqlClient;
         this.projectSourceDirectory = path_1.default.join(buildCtx.workingdir, 'temporary-custom-build');
         this.projectTargetDirectory = path_1.default.join(buildCtx.workingdir, 'build');
         this.defaultWorkingDirectory = buildCtx.getReactNativeProjectDirectory();

package/dist/steps/easFunctions.js

@@ -22,6 +22,7 @@ const internalMaestroTest_1 = require("./functions/internalMaestroTest");
 const prebuild_1 = require("./functions/prebuild");
 const readIpaInfo_1 = require("./functions/readIpaInfo");
 const repack_1 = require("./functions/repack");
+const reportMaestroTestResults_1 = require("./functions/reportMaestroTestResults");
 const resolveAppleTeamIdFromCredentials_1 = require("./functions/resolveAppleTeamIdFromCredentials");
 const resolveBuildConfig_1 = require("./functions/resolveBuildConfig");
 const restoreBuildCache_1 = require("./functions/restoreBuildCache");
@@ -73,6 +74,7 @@ function getEasFunctions(ctx) {
         (0, createSubmissionEntity_1.createSubmissionEntityFunction)(),
         (0, uploadToAsc_1.createUploadToAscBuildFunction)(),
         (0, internalMaestroTest_1.createInternalEasMaestroTestFunction)(ctx),
+        (0, reportMaestroTestResults_1.createReportMaestroTestResultsFunction)(ctx),
     ];
     if (ctx.hasBuildJob()) {
         functions.push(...[

package/dist/steps/functions/internalMaestroTest.js

@@ -74,6 +74,10 @@ function createInternalEasMaestroTestFunction(ctx) {
                 id: 'test_reports_artifact_id',
                 required: false,
             }),
+            steps_1.BuildStepOutput.createProvider({
+                id: 'junit_report_directory',
+                required: false,
+            }),
         ],
         fn: async (stepCtx, { inputs: _inputs, env, outputs }) => {
             // inputs come in form of { value: unknown }. Here we parse them into a typed and validated object.
@@ -293,6 +297,9 @@ function createInternalEasMaestroTestFunction(ctx) {
                     stepCtx.logger.error({ err }, 'Failed to upload reports.');
                 }
             }
+            if (output_format === 'junit') {
+                outputs.junit_report_directory.set(maestroReportsDir);
+            }
             const generatedDeviceLogs = await node_fs_1.default.promises.readdir(deviceLogsDir);
             if (generatedDeviceLogs.length === 0) {
                 stepCtx.logger.warn('No device logs were successfully collected.');

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export interface MaestroFlowResult {
+    name: string;
+    path: string;
+    status: 'passed' | 'failed';
+    errorMessage: string | null;
+    duration: number;
+    retryCount: number;
+    tags: string[];
+    properties: Record<string, string>;
+}
+export declare function extractFlowKey(filename: string, prefix: string): string | null;
+export interface JUnitTestCaseResult {
+    name: string;
+    status: 'passed' | 'failed';
+    duration: number;
+    errorMessage: string | null;
+    tags: string[];
+    properties: Record<string, string>;
+}
+export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
+declare const FlowMetadataFileSchema: z.ZodObject<{
+    flow_name: z.ZodString;
+    flow_file_path: z.ZodString;
+}, z.core.$strip>;
+type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
+/**
+ * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
+ *
+ * The file contains:
+ * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
+ *   the flow filename without extension.
+ *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
+ * - `flow_file_path`: absolute path to the original flow YAML file.
+ * - `outputs`: screenshot defect data (unused here).
+ *
+ * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
+ * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
+ */
+export declare function parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
+export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+export {};

package/dist/steps/functions/maestroResultParser.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFlowKey = extractFlowKey;
+exports.parseJUnitTestCases = parseJUnitTestCases;
+exports.parseFlowMetadata = parseFlowMetadata;
+exports.parseMaestroResults = parseMaestroResults;
+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");
+// Maestro's TestDebugReporter creates timestamped directories, e.g. "2024-06-15_143022"
+const TIMESTAMP_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{6}$/;
+function extractFlowKey(filename, prefix) {
+    const match = filename.match(new RegExp(`^${prefix}-(.+)\\.json$`));
+    return match?.[1] ?? null;
+}
+const xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    // Ensure single-element arrays are always arrays
+    isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
+});
+async function parseJUnitTestCases(junitDirectory) {
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(junitDirectory);
+    }
+    catch {
+        return [];
+    }
+    const xmlFiles = entries.filter(f => f.endsWith('.xml'));
+    if (xmlFiles.length === 0) {
+        return [];
+    }
+    const results = [];
+    for (const xmlFile of xmlFiles) {
+        try {
+            const content = await promises_1.default.readFile(path_1.default.join(junitDirectory, xmlFile), 'utf-8');
+            const parsed = xmlParser.parse(content);
+            const testsuites = parsed?.testsuites?.testsuite;
+            if (!Array.isArray(testsuites)) {
+                continue;
+            }
+            for (const suite of testsuites) {
+                const testcases = suite?.testcase;
+                if (!Array.isArray(testcases)) {
+                    continue;
+                }
+                for (const tc of testcases) {
+                    const name = tc['@_name'];
+                    if (!name) {
+                        continue;
+                    }
+                    const timeStr = tc['@_time'];
+                    const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
+                    const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
+                    // Use @_status as primary indicator (more robust than checking <failure> presence)
+                    const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
+                    // Extract error message from <failure> or <error> elements
+                    const failureText = tc.failure != null
+                        ? typeof tc.failure === 'string'
+                            ? tc.failure
+                            : (tc.failure?.['#text'] ?? null)
+                        : null;
+                    const errorText = tc.error != null
+                        ? typeof tc.error === 'string'
+                            ? tc.error
+                            : (tc.error?.['#text'] ?? null)
+                        : null;
+                    const errorMessage = failureText ?? errorText ?? null;
+                    // Extract properties
+                    const rawProperties = tc.properties?.property ?? [];
+                    const properties = {};
+                    for (const prop of rawProperties) {
+                        const propName = prop['@_name'];
+                        const value = prop['@_value'];
+                        if (typeof propName !== 'string' || typeof value !== 'string') {
+                            continue;
+                        }
+                        properties[propName] = value;
+                    }
+                    // Extract tags from "tags" property (Maestro 2.2.0+, comma-separated)
+                    const tagsValue = properties['tags'];
+                    const tags = tagsValue
+                        ? tagsValue
+                            .split(',')
+                            .map(t => t.trim())
+                            .filter(Boolean)
+                        : [];
+                    delete properties['tags'];
+                    results.push({ name, status, duration, errorMessage, tags, properties });
+                }
+            }
+        }
+        catch {
+            // Skip malformed XML files
+            continue;
+        }
+    }
+    return results;
+}
+const FlowMetadataFileSchema = zod_1.z.object({
+    flow_name: zod_1.z.string(),
+    flow_file_path: zod_1.z.string(),
+});
+/**
+ * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
+ *
+ * The file contains:
+ * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
+ *   the flow filename without extension.
+ *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
+ * - `flow_file_path`: absolute path to the original flow YAML file.
+ * - `outputs`: screenshot defect data (unused here).
+ *
+ * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
+ * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
+ */
+async function parseFlowMetadata(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        return FlowMetadataFileSchema.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot) {
+    // 1. Parse JUnit XML files (primary source)
+    const junitResults = await parseJUnitTestCases(junitDirectory);
+    if (junitResults.length === 0) {
+        return [];
+    }
+    // 2. Parse ai-*.json from debug output for flow_file_path + retryCount
+    const flowPathMap = new Map(); // flowName → flowFilePath
+    const flowOccurrences = new Map(); // flowName → count
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(testsDirectory);
+    }
+    catch {
+        entries = [];
+    }
+    const timestampDirs = entries.filter(name => TIMESTAMP_DIR_PATTERN.test(name)).sort();
+    for (const dir of timestampDirs) {
+        const dirPath = path_1.default.join(testsDirectory, dir);
+        let files;
+        try {
+            files = await promises_1.default.readdir(dirPath);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const flowKey = extractFlowKey(file, 'ai');
+            if (!flowKey) {
+                continue;
+            }
+            const metadata = await parseFlowMetadata(path_1.default.join(dirPath, file));
+            if (!metadata) {
+                continue;
+            }
+            // Track latest path (last timestamp dir wins)
+            flowPathMap.set(metadata.flow_name, metadata.flow_file_path);
+            // Count occurrences for retryCount
+            flowOccurrences.set(metadata.flow_name, (flowOccurrences.get(metadata.flow_name) ?? 0) + 1);
+        }
+    }
+    // 3. Merge: JUnit results + ai-*.json metadata
+    const results = [];
+    for (const junit of junitResults) {
+        const flowFilePath = flowPathMap.get(junit.name);
+        const relativePath = flowFilePath
+            ? await relativizePathAsync(flowFilePath, projectRoot)
+            : junit.name; // fallback: use flow name if ai-*.json not found
+        const occurrences = flowOccurrences.get(junit.name) ?? 0;
+        const retryCount = Math.max(0, occurrences - 1);
+        results.push({
+            name: junit.name,
+            path: relativePath,
+            status: junit.status,
+            errorMessage: junit.errorMessage,
+            duration: junit.duration,
+            retryCount,
+            tags: junit.tags,
+            properties: junit.properties,
+        });
+    }
+    return results;
+}
+async function relativizePathAsync(flowFilePath, projectRoot) {
+    if (!path_1.default.isAbsolute(flowFilePath)) {
+        return flowFilePath;
+    }
+    // Resolve symlinks (e.g., /tmp -> /private/tmp on macOS) for consistent comparison
+    let resolvedRoot = projectRoot;
+    let resolvedFlow = flowFilePath;
+    try {
+        resolvedRoot = await promises_1.default.realpath(projectRoot);
+    }
+    catch { }
+    try {
+        resolvedFlow = await promises_1.default.realpath(flowFilePath);
+    }
+    catch { }
+    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
+    if (relative.startsWith('..')) {
+        return flowFilePath;
+    }
+    return relative;
+}

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

@@ -0,0 +1,3 @@
+import { BuildFunction } from '@expo/steps';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function createReportMaestroTestResultsFunction(ctx: CustomBuildContext): BuildFunction;

package/dist/steps/functions/reportMaestroTestResults.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReportMaestroTestResultsFunction = createReportMaestroTestResultsFunction;
+const steps_1 = require("@expo/steps");
+const gql_tada_1 = require("gql.tada");
+const maestroResultParser_1 = require("./maestroResultParser");
+const CREATE_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation CreateWorkflowDeviceTestCaseResults($input: CreateWorkflowDeviceTestCaseResultsInput!) {
+    workflowDeviceTestCaseResult {
+      createWorkflowDeviceTestCaseResults(input: $input) {
+        id
+      }
+    }
+  }
+`);
+const FLOW_STATUS_TO_TEST_CASE_RESULT_STATUS = {
+    passed: 'PASSED',
+    failed: 'FAILED',
+};
+function createReportMaestroTestResultsFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'report_maestro_test_results',
+        name: 'Report Maestro Test Results',
+        __metricsId: 'eas/report_maestro_test_results',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'junit_report_directory',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                defaultValue: '${{ env.HOME }}/.maestro/tests',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'tests_directory',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                defaultValue: '${{ env.HOME }}/.maestro/tests',
+            }),
+        ],
+        fn: async (stepsCtx, { inputs }) => {
+            const { logger } = stepsCtx;
+            const workflowJobId = stepsCtx.global.env.__WORKFLOW_JOB_ID;
+            if (!workflowJobId) {
+                logger.info('Not running in a workflow job, skipping test results report');
+                return;
+            }
+            const junitDirectory = inputs.junit_report_directory.value ?? '';
+            if (!junitDirectory) {
+                logger.info('No JUnit directory provided, skipping test results report');
+                return;
+            }
+            const testsDirectory = inputs.tests_directory.value;
+            try {
+                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, testsDirectory, stepsCtx.workingDirectory);
+                if (flowResults.length === 0) {
+                    logger.info('No maestro test results found, skipping report');
+                    return;
+                }
+                // Maestro allows overriding flow names via config, so different flow files can share
+                // the same name. JUnit XML only contains names (not file paths), making it impossible
+                // to map duplicates back to their original flow files. Skip and let the user fix it.
+                const names = flowResults.map(r => r.name);
+                const duplicates = names.filter((n, i) => names.indexOf(n) !== i);
+                if (duplicates.length > 0) {
+                    logger.error(`Duplicate test case names found in JUnit output: ${[...new Set(duplicates)].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
+                    return;
+                }
+                const testCaseResults = flowResults.flatMap(f => {
+                    const status = FLOW_STATUS_TO_TEST_CASE_RESULT_STATUS[f.status];
+                    if (!status) {
+                        return [];
+                    }
+                    return [
+                        {
+                            name: f.name,
+                            path: f.path,
+                            status,
+                            errorMessage: f.errorMessage,
+                            duration: f.duration,
+                            retryCount: f.retryCount,
+                            tags: f.tags,
+                            properties: f.properties,
+                        },
+                    ];
+                });
+                const result = await ctx.graphqlClient
+                    .mutation(CREATE_MUTATION, {
+                    input: {
+                        workflowJobId,
+                        testCaseResults,
+                    },
+                })
+                    .toPromise();
+                if (result.error) {
+                    logger.error({ error: result.error }, 'GraphQL error creating test case results');
+                    return;
+                }
+                logger.info(`Reported ${testCaseResults.length} test case result(s).`);
+            }
+            catch (error) {
+                logger.error({ err: error }, 'Failed to create test case results');
+            }
+        },
+    });
+}

package/dist/steps/utils/ios/AscApiClient.d.ts

@@ -38,10 +38,10 @@ declare const GetApi: {
                 attributes: z.ZodObject<{
                     assetDeliveryState: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             UPLOAD_COMPLETE: "UPLOAD_COMPLETE";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                         }>;
                         errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             code: z.ZodString;
@@ -76,9 +76,9 @@ declare const GetApi: {
                 attributes: z.ZodObject<{
                     state: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                             PROCESSING: "PROCESSING";
                         }>;
                         infos: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -203,10 +203,10 @@ declare const PatchApi: {
                 attributes: z.ZodObject<{
                     assetDeliveryState: z.ZodObject<{
                         state: z.ZodEnum<{
+                            FAILED: "FAILED";
                             AWAITING_UPLOAD: "AWAITING_UPLOAD";
                             UPLOAD_COMPLETE: "UPLOAD_COMPLETE";
                             COMPLETE: "COMPLETE";
-                            FAILED: "FAILED";
                         }>;
                         errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                             code: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.0.2",
+  "version": "18.0.6",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -53,6 +53,7 @@
     "@urql/core": "^6.0.1",
     "bplist-parser": "0.3.2",
     "fast-glob": "^3.3.2",
+    "fast-xml-parser": "^4.4.1",
     "fs-extra": "^11.2.0",
     "gql.tada": "^1.8.13",
     "joi": "^17.13.1",
@@ -96,5 +97,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "d5da4f416791938a7c1ffdaf83a7c644e7aa6261"
+  "gitHead": "df8ebc8f84809e52032661f9f08768650440e5c0"
 }