@expo/build-tools 18.4.0 → 18.6.0

package/dist/steps/functions/internalMaestroTest.js

@@ -1,534 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInternalEasMaestroTestFunction = createInternalEasMaestroTestFunction;
-exports.getMaestroTestCommand = getMaestroTestCommand;
-const eas_build_job_1 = require("@expo/eas-build-job");
-const logger_1 = require("@expo/logger");
-const results_1 = require("@expo/results");
-const steps_1 = require("@expo/steps");
-const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
-const node_path_1 = __importDefault(require("node:path"));
-const promises_1 = require("node:timers/promises");
-const zod_1 = require("zod");
-const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
-const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
-const findMaestroPathsFlowsToExecuteAsync_1 = require("../../utils/findMaestroPathsFlowsToExecuteAsync");
-const retry_1 = require("../../utils/retry");
-const strings_1 = require("../../utils/strings");
-function createInternalEasMaestroTestFunction(ctx) {
-    return new steps_1.BuildFunction({
-        namespace: 'eas',
-        id: '__maestro_test',
-        __metricsId: 'eas/__maestro_test',
-        inputProviders: [
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
-                id: 'platform',
-                required: true,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
-                id: 'flow_paths',
-                required: true,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
-                id: 'retries',
-                defaultValue: 1,
-                required: false,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
-                id: 'include_tags',
-                required: false,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
-                id: 'exclude_tags',
-                required: false,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
-                id: 'shards',
-                defaultValue: 1,
-                required: false,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
-                id: 'output_format',
-                required: false,
-            }),
-            steps_1.BuildStepInput.createProvider({
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
-                id: 'record_screen',
-                defaultValue: false,
-                required: false,
-            }),
-        ],
-        outputProviders: [
-            steps_1.BuildStepOutput.createProvider({
-                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.
-            const { platform, flow_paths, retries, include_tags, exclude_tags, shards, output_format, record_screen, } = zod_1.z
-                .object({
-                platform: zod_1.z.enum(['ios', 'android']),
-                flow_paths: zod_1.z.array(zod_1.z.string()),
-                retries: zod_1.z.number().default(1),
-                include_tags: zod_1.z.string().optional(),
-                exclude_tags: zod_1.z.string().optional(),
-                shards: zod_1.z.number().default(1),
-                output_format: zod_1.z.string().optional(),
-                record_screen: zod_1.z.boolean().default(false),
-            })
-                .parse(Object.fromEntries(Object.entries(_inputs).map(([key, value]) => [key, value.value])));
-            const flowPathsToExecute = [];
-            for (const flowPath of flow_paths) {
-                const flowPaths = await (0, findMaestroPathsFlowsToExecuteAsync_1.findMaestroPathsFlowsToExecuteAsync)({
-                    workingDirectory: stepCtx.workingDirectory,
-                    flowPath,
-                    logger: stepCtx.logger,
-                    includeTags: include_tags ? include_tags.split(',') : undefined,
-                    excludeTags: exclude_tags ? exclude_tags.split(',') : undefined,
-                });
-                if (flowPaths.length === 0) {
-                    stepCtx.logger.warn(`No flows to execute found in "${flowPath}".`);
-                    continue;
-                }
-                stepCtx.logger.info(`Marking for execution:\n- ${flowPaths
-                    .map(flowPath => node_path_1.default.relative(stepCtx.workingDirectory, flowPath))
-                    .join('\n- ')}`);
-                stepCtx.logger.info('');
-                flowPathsToExecute.push(...flowPaths);
-            }
-            // TODO: Add support for shards. (Shouldn't be too difficult.)
-            if (shards > 1) {
-                stepCtx.logger.warn('Sharding support has been temporarily disabled. Running tests on a single shard.');
-            }
-            // eas/__maestro_test does not start devices, it expects a single device to be already running
-            // and configured with the app. Here we find the booted device and stop it.
-            let sourceDeviceIdentifier;
-            switch (platform) {
-                case 'ios': {
-                    const bootedDevices = await IosSimulatorUtils_1.IosSimulatorUtils.getAvailableDevicesAsync({
-                        env,
-                        filter: 'booted',
-                    });
-                    if (bootedDevices.length === 0) {
-                        throw new Error('No booted iOS Simulator found.');
-                    }
-                    else if (bootedDevices.length > 1) {
-                        throw new Error('Multiple booted iOS Simulators found.');
-                    }
-                    const device = bootedDevices[0];
-                    stepCtx.logger.info(`Running tests on iOS Simulator: ${device.name}.`);
-                    stepCtx.logger.info(`Preparing Simulator for tests...`);
-                    await (0, steps_1.spawnAsync)('xcrun', ['simctl', 'shutdown', device.udid], {
-                        logger: stepCtx.logger,
-                        stdio: 'pipe',
-                    });
-                    sourceDeviceIdentifier = device.name;
-                    break;
-                }
-                case 'android': {
-                    const connectedDevices = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.getAttachedDevicesAsync({ env });
-                    if (connectedDevices.length === 0) {
-                        throw new Error('No booted Android Emulator found.');
-                    }
-                    else if (connectedDevices.length > 1) {
-                        throw new Error('Multiple booted Android Emulators found.');
-                    }
-                    const { serialId } = connectedDevices[0];
-                    const adbEmuAvdNameResult = await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'emu', 'avd', 'name'], {
-                        mode: logger_1.PipeMode.COMBINED,
-                        env,
-                    });
-                    const avdName = adbEmuAvdNameResult.stdout
-                        .replace(/\r\n/g, '\n')
-                        .split('\n')[0];
-                    stepCtx.logger.info(`Running tests on Android Emulator: ${avdName}.`);
-                    stepCtx.logger.info(`Preparing Emulator for tests...`);
-                    await (0, steps_1.spawnAsync)('adb', ['-s', serialId, 'emu', 'kill'], {
-                        stdio: 'pipe',
-                    });
-                    // Waiting for emulator to get killed, see ANDROID_EMULATOR_WAIT_TIME_BEFORE_KILL.
-                    await (0, promises_1.setTimeout)(1000);
-                    sourceDeviceIdentifier = avdName;
-                    break;
-                }
-            }
-            // During tests we generate reports and device logs. We store them in temporary directories
-            // and upload them once all tests are done. When a test is retried, new reports overwrite
-            // the old ones. The files are named "flow-${index}" for easier identification.
-            const maestroReportsDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'maestro-reports-'));
-            const deviceLogsDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'device-logs-'));
-            const failedFlows = [];
-            for (const [flowIndex, flowPath] of flowPathsToExecute.entries()) {
-                stepCtx.logger.info('');
-                for (let attemptCount = 0; attemptCount < retries; attemptCount++) {
-                    // Generate unique report path per attempt (not overwritten on retry)
-                    const outputPath = node_path_1.default.join(maestroReportsDir, [
-                        `${output_format ? output_format + '-' : ''}report-flow-${flowIndex + 1}-attempt-${attemptCount}`,
-                        MaestroOutputFormatToExtensionMap[output_format ?? 'noop'],
-                    ]
-                        .filter(Boolean)
-                        .join('.'));
-                    const localDeviceName = `eas-simulator-${flowIndex}-${attemptCount}`;
-                    // If the test passes, but the recording fails, we don't want to make the test fail,
-                    // so we return two separate results.
-                    const { fnResult: { fnResult, recordingResult }, logsResult, } = await withCleanDeviceAsync({
-                        platform,
-                        sourceDeviceIdentifier,
-                        localDeviceName,
-                        env,
-                        logger: stepCtx.logger,
-                        fn: async ({ deviceIdentifier }) => {
-                            return await maybeWithScreenRecordingAsync({
-                                shouldRecord: record_screen,
-                                platform,
-                                deviceIdentifier,
-                                env,
-                                logger: stepCtx.logger,
-                                fn: async () => {
-                                    stepCtx.logger.info('');
-                                    const [command, ...args] = getMaestroTestCommand({
-                                        flow_path: flowPath,
-                                        output_format,
-                                        output_path: outputPath,
-                                    });
-                                    try {
-                                        await (0, steps_1.spawnAsync)(command, args, {
-                                            logger: stepCtx.logger,
-                                            cwd: stepCtx.workingDirectory,
-                                            env,
-                                            stdio: 'pipe',
-                                        });
-                                    }
-                                    finally {
-                                        stepCtx.logger.info('');
-                                    }
-                                },
-                            });
-                        },
-                    });
-                    // Move device logs to the device logs directory.
-                    if (logsResult?.ok) {
-                        try {
-                            const extension = node_path_1.default.extname(logsResult.value.outputPath);
-                            const destinationPath = node_path_1.default.join(deviceLogsDir, `flow-${flowIndex}-attempt-${attemptCount}${extension}`);
-                            await node_fs_1.default.promises.rename(logsResult.value.outputPath, destinationPath);
-                        }
-                        catch (err) {
-                            stepCtx.logger.warn({ err }, 'Failed to prepare device logs for upload.');
-                        }
-                    }
-                    else if (logsResult?.reason) {
-                        stepCtx.logger.error({ err: logsResult.reason }, 'Failed to collect device logs.');
-                    }
-                    const isLastAttempt = fnResult.ok || attemptCount === retries - 1;
-                    if (isLastAttempt && recordingResult.value) {
-                        try {
-                            await ctx.runtimeApi.uploadArtifact({
-                                logger: stepCtx.logger,
-                                artifact: {
-                                    // TODO(sjchmiela): Add metadata to artifacts so we don't need to encode flow path and attempt in the name.
-                                    name: `Screen Recording (${flowIndex}-${node_path_1.default.basename(flowPath, node_path_1.default.extname(flowPath))})`,
-                                    paths: [recordingResult.value],
-                                    type: eas_build_job_1.GenericArtifactType.OTHER,
-                                },
-                            });
-                        }
-                        catch (err) {
-                            stepCtx.logger.warn({ err }, 'Failed to upload screen recording.');
-                        }
-                    }
-                    if (fnResult.ok) {
-                        stepCtx.logger.info(`Test passed.`);
-                        // Break out of the retry loop.
-                        break;
-                    }
-                    if (attemptCount < retries - 1) {
-                        stepCtx.logger.info(`Retrying test...`);
-                        stepCtx.logger.info('');
-                        continue;
-                    }
-                    // fnResult.reason is not super interesting, but it does print out the full command so we can keep it for debugging purposes.
-                    stepCtx.logger.error({ err: fnResult.reason }, 'Test errored.');
-                    failedFlows.push(flowPath);
-                }
-            }
-            stepCtx.logger.info('');
-            // When all tests are done, we upload the reports and device logs.
-            const generatedMaestroReports = await node_fs_1.default.promises.readdir(maestroReportsDir);
-            if (generatedMaestroReports.length === 0) {
-                stepCtx.logger.warn('No reports were generated.');
-            }
-            else {
-                stepCtx.logger.info(`Uploading reports...`);
-                try {
-                    const { artifactId } = await ctx.runtimeApi.uploadArtifact({
-                        logger: stepCtx.logger,
-                        artifact: {
-                            name: `${strings_1.PlatformToProperNounMap[platform]} Maestro Test Reports (${output_format})`,
-                            paths: [maestroReportsDir],
-                            type: eas_build_job_1.GenericArtifactType.OTHER,
-                        },
-                    });
-                    if (artifactId) {
-                        outputs.test_reports_artifact_id.set(artifactId);
-                    }
-                }
-                catch (err) {
-                    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.');
-            }
-            else {
-                stepCtx.logger.info(`Uploading device logs...`);
-                try {
-                    await ctx.runtimeApi.uploadArtifact({
-                        logger: stepCtx.logger,
-                        artifact: {
-                            name: `Maestro Test Device Logs`,
-                            paths: [deviceLogsDir],
-                            type: eas_build_job_1.GenericArtifactType.OTHER,
-                        },
-                    });
-                }
-                catch (err) {
-                    stepCtx.logger.error({ err }, 'Failed to upload device logs.');
-                }
-            }
-            stepCtx.logger.info('');
-            // If any tests failed, we throw an error to mark the step as failed.
-            if (failedFlows.length > 0) {
-                throw new Error(`Some Maestro tests failed:\n- ${failedFlows
-                    .map(flowPath => node_path_1.default.relative(stepCtx.workingDirectory, flowPath))
-                    .join('\n- ')}`);
-            }
-            else {
-                stepCtx.logger.info('All Maestro tests passed.');
-            }
-        },
-    });
-}
-function getMaestroTestCommand(params) {
-    let outputFormatFlags = [];
-    if (params.output_format) {
-        outputFormatFlags = [`--format`, params.output_format, `--output`, params.output_path];
-    }
-    return ['maestro', 'test', ...outputFormatFlags, params.flow_path];
-}
-const MaestroOutputFormatToExtensionMap = {
-    junit: 'xml',
-    html: 'html',
-};
-const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
-const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
-async function withCleanDeviceAsync({ platform, sourceDeviceIdentifier, localDeviceName, env, logger, fn, }) {
-    // Clone and start the device
-    let localDeviceIdentifier = null;
-    switch (platform) {
-        case 'ios': {
-            logger.info(`Cloning iOS Simulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
-            await IosSimulatorUtils_1.IosSimulatorUtils.cloneAsync({
-                sourceDeviceIdentifier: sourceDeviceIdentifier,
-                destinationDeviceName: localDeviceName,
-                env,
-            });
-            logger.info(`Starting iOS Simulator ${localDeviceName}...`);
-            const { udid } = await IosSimulatorUtils_1.IosSimulatorUtils.startAsync({
-                deviceIdentifier: localDeviceName,
-                env,
-            });
-            logger.info(`Waiting for iOS Simulator ${localDeviceName} to be ready...`);
-            await IosSimulatorUtils_1.IosSimulatorUtils.waitForReadyAsync({
-                udid,
-                env,
-            });
-            localDeviceIdentifier = localDeviceName;
-            break;
-        }
-        case 'android': {
-            await (0, retry_1.retryAsync)(async (attemptCount) => {
-                const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
-                const attempt = attemptCount + 1;
-                const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
-                let serialId = null;
-                try {
-                    logger.info(`Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
-                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
-                        sourceDeviceName: sourceDeviceIdentifier,
-                        destinationDeviceName: localDeviceName,
-                        env,
-                        logger,
-                    });
-                    logger.info(`Starting Android Emulator ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
-                    const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
-                        deviceName: localDeviceName,
-                        env,
-                    });
-                    serialId = startResult.serialId;
-                    logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
-                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
-                        serialId,
-                        env,
-                        timeoutMs,
-                        logger,
-                    });
-                    localDeviceIdentifier = serialId;
-                }
-                catch (err) {
-                    logger.warn({ err }, `Failed to start Android Emulator ${localDeviceName} on attempt ${attempt}/${maxAttempts}.`);
-                    try {
-                        if (serialId) {
-                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
-                                serialId,
-                                deviceName: localDeviceName,
-                                env,
-                            });
-                        }
-                        else {
-                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
-                                deviceName: localDeviceName,
-                                env,
-                            });
-                        }
-                    }
-                    catch (cleanupErr) {
-                        logger.warn({ err: cleanupErr }, `Failed to clean up Android Emulator ${localDeviceName}.`);
-                    }
-                    throw err;
-                }
-            }, {
-                logger,
-                retryOptions: {
-                    retries: ANDROID_STARTUP_RETRIES_COUNT,
-                    retryIntervalMs: 1_000,
-                },
-            });
-            break;
-        }
-    }
-    if (!localDeviceIdentifier) {
-        throw new Error('Device did not return an identifier after startup.');
-    }
-    // Run the function
-    const fnResult = await (0, results_1.asyncResult)(fn({ deviceIdentifier: localDeviceIdentifier }));
-    // Stop the device
-    let logsResult = null;
-    try {
-        switch (platform) {
-            case 'ios': {
-                logger.info(`Collecting logs from ${localDeviceName}...`);
-                logsResult = await (0, results_1.asyncResult)(IosSimulatorUtils_1.IosSimulatorUtils.collectLogsAsync({
-                    deviceIdentifier: localDeviceIdentifier,
-                    env,
-                }));
-                logger.info(`Cleaning up ${localDeviceName}...`);
-                await IosSimulatorUtils_1.IosSimulatorUtils.deleteAsync({
-                    deviceIdentifier: localDeviceIdentifier,
-                    env,
-                });
-                break;
-            }
-            case 'android': {
-                logger.info(`Collecting logs from ${localDeviceName}...`);
-                logsResult = await (0, results_1.asyncResult)(AndroidEmulatorUtils_1.AndroidEmulatorUtils.collectLogsAsync({
-                    serialId: localDeviceIdentifier,
-                    env,
-                }));
-                logger.info(`Cleaning up ${localDeviceName}...`);
-                await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
-                    serialId: localDeviceIdentifier,
-                    env,
-                });
-                break;
-            }
-        }
-    }
-    catch (err) {
-        logger.error(`Error cleaning up device: ${err}`);
-    }
-    return { fnResult: fnResult.enforceValue(), logsResult };
-}
-/** Runs provided `fn` function, optionally wrapping it with starting and stopping screen recording. */
-async function maybeWithScreenRecordingAsync({ shouldRecord, platform, deviceIdentifier, env, logger, fn, }) {
-    if (!shouldRecord) {
-        return { fnResult: await (0, results_1.asyncResult)(fn()), recordingResult: (0, results_1.result)(null) };
-    }
-    let recordingResult;
-    // Start screen recording
-    logger.info(`Starting screen recording on ${deviceIdentifier}...`);
-    switch (platform) {
-        case 'ios': {
-            recordingResult = await (0, results_1.asyncResult)(IosSimulatorUtils_1.IosSimulatorUtils.startScreenRecordingAsync({
-                deviceIdentifier: deviceIdentifier,
-                env,
-            }));
-            break;
-        }
-        case 'android': {
-            recordingResult = await (0, results_1.asyncResult)(AndroidEmulatorUtils_1.AndroidEmulatorUtils.startScreenRecordingAsync({
-                serialId: deviceIdentifier,
-                env,
-            }));
-            break;
-        }
-    }
-    if (!recordingResult.ok) {
-        logger.warn('Failed to start screen recording.', recordingResult.reason);
-    }
-    // Run the function
-    const fnResult = await (0, results_1.asyncResult)(fn());
-    // If recording failed there's nothing to stop, so we return the results
-    if (!recordingResult.ok) {
-        return { fnResult, recordingResult: (0, results_1.result)(recordingResult.reason) };
-    }
-    // If recording started, finish it
-    try {
-        logger.info(`Stopping screen recording on ${deviceIdentifier}...`);
-        switch (platform) {
-            case 'ios': {
-                await IosSimulatorUtils_1.IosSimulatorUtils.stopScreenRecordingAsync({
-                    recordingSpawn: recordingResult.value.recordingSpawn,
-                });
-                return {
-                    fnResult,
-                    // We know outputPath is defined, because startIosScreenRecording() should have filled it.
-                    recordingResult: (0, results_1.result)(recordingResult.value.outputPath),
-                };
-            }
-            case 'android': {
-                const { outputPath } = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.stopScreenRecordingAsync({
-                    serialId: deviceIdentifier,
-                    recordingSpawn: recordingResult.value.recordingSpawn,
-                    env,
-                });
-                return { fnResult, recordingResult: (0, results_1.result)(outputPath) };
-            }
-        }
-    }
-    catch (err) {
-        logger.warn('Failed to stop screen recording.', err);
-        return { fnResult, recordingResult: (0, results_1.result)(err) };
-    }
-}

package/dist/utils/findMaestroPathsFlowsToExecuteAsync.d.ts

@@ -1,8 +0,0 @@
-import { bunyan } from '@expo/logger';
-export declare function findMaestroPathsFlowsToExecuteAsync({ workingDirectory, flowPath, includeTags: _includeTags, excludeTags: _excludeTags, logger, }: {
-    workingDirectory: string;
-    flowPath: string;
-    includeTags: string[] | undefined;
-    excludeTags: string[] | undefined;
-    logger: bunyan;
-}): Promise<string[]>;