@devicecloud.dev/dcd 4.1.2 → 4.1.4

package/dist/services/moropo.service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoropoService = void 0;
+const core_1 = require("@oclif/core");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const StreamZip = require("node-stream-zip");
+/**
+ * Service for downloading and extracting Moropo tests from the Moropo API
+ */
+class MoropoService {
+    MOROPO_API_URL = 'https://api.moropo.com/tests';
+    /**
+     * Download and extract Moropo tests from the API
+     * @param options Download configuration options
+     * @returns Path to the extracted Moropo tests directory
+     */
+    async downloadAndExtract(options) {
+        const { apiKey, branchName = 'main', debug = false, quiet = false, json = false, logger } = options;
+        this.logDebug(debug, logger, 'DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
+        this.logDebug(debug, logger, `DEBUG: Using branch name: ${branchName}`);
+        try {
+            if (!quiet && !json) {
+                core_1.ux.action.start('Downloading Moropo tests', 'Initializing', {
+                    stdout: true,
+                });
+            }
+            const response = await fetch(this.MOROPO_API_URL, {
+                headers: {
+                    accept: 'application/zip',
+                    'x-app-api-key': apiKey,
+                    'x-branch-name': branchName,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to download Moropo tests: ${response.statusText}`);
+            }
+            const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
+            this.logDebug(debug, logger, `DEBUG: Extracting Moropo tests to: ${moropoDir}`);
+            // Create moropo directory if it doesn't exist
+            if (!fs.existsSync(moropoDir)) {
+                fs.mkdirSync(moropoDir, { recursive: true });
+            }
+            // Download zip file
+            const zipPath = path.join(moropoDir, 'moropo-tests.zip');
+            await this.downloadZipFile(response, zipPath, { quiet, json });
+            this.showProgress(quiet, json, 'Extracting tests...');
+            // Extract zip file
+            await this.extractZipFile(zipPath, moropoDir);
+            if (!quiet && !json) {
+                core_1.ux.action.stop('completed');
+            }
+            this.logDebug(debug, logger, 'DEBUG: Successfully extracted Moropo tests');
+            // Create config.yaml file
+            this.createConfigFile(moropoDir);
+            this.logDebug(debug, logger, 'DEBUG: Created config.yaml file');
+            return moropoDir;
+        }
+        catch (error) {
+            if (!quiet && !json) {
+                core_1.ux.action.stop('failed');
+            }
+            this.logDebug(debug, logger, `DEBUG: Error downloading/extracting Moropo tests: ${error}`);
+            throw new Error(`Failed to download/extract Moropo tests: ${error}`);
+        }
+    }
+    createConfigFile(moropoDir) {
+        const configPath = path.join(moropoDir, 'config.yaml');
+        fs.writeFileSync(configPath, 'flows:\n- ./**/*.yaml\n- ./*.yaml\n');
+    }
+    async downloadZipFile(response, zipPath, options) {
+        const { quiet, json } = options;
+        const contentLength = response.headers.get('content-length');
+        const totalSize = contentLength ? Number.parseInt(contentLength, 10) : 0;
+        let downloadedSize = 0;
+        const fileStream = fs.createWriteStream(zipPath);
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Failed to get response reader');
+        }
+        let readerResult = await reader.read();
+        while (!readerResult.done) {
+            const { value } = readerResult;
+            downloadedSize += value.length;
+            if (!quiet && !json && totalSize) {
+                const progress = Math.round((downloadedSize / totalSize) * 100);
+                core_1.ux.action.status = `Downloading: ${progress}%`;
+            }
+            fileStream.write(value);
+            readerResult = await reader.read();
+        }
+        fileStream.end();
+        await new Promise((resolve) => {
+            fileStream.on('finish', () => {
+                resolve();
+            });
+        });
+    }
+    async extractZipFile(zipPath, extractPath) {
+        // eslint-disable-next-line new-cap
+        const zip = new StreamZip.async({ file: zipPath });
+        await zip.extract(null, extractPath);
+        await zip.close();
+        fs.unlinkSync(zipPath);
+    }
+    logDebug(debug, logger, message) {
+        if (debug && logger) {
+            logger(message);
+        }
+    }
+    showProgress(quiet, json, message) {
+        if (!quiet && !json) {
+            core_1.ux.action.status = message;
+        }
+    }
+}
+exports.MoropoService = MoropoService;

package/dist/services/report-download.service.d.ts

@@ -0,0 +1,43 @@
+export interface DownloadOptions {
+    apiKey: string;
+    apiUrl: string;
+    debug?: boolean;
+    logger?: (message: string) => void;
+    uploadId: string;
+    warnLogger?: (message: string) => void;
+}
+export interface ArtifactsDownloadOptions extends DownloadOptions {
+    artifactsPath?: string;
+    downloadType: 'ALL' | 'FAILED';
+}
+export interface ReportDownloadOptions extends DownloadOptions {
+    allurePath?: string;
+    htmlPath?: string;
+    junitPath?: string;
+    reportType: 'allure' | 'html' | 'junit';
+}
+/**
+ * Service for downloading test artifacts and reports
+ */
+export declare class ReportDownloadService {
+    /**
+     * Download test artifacts as a zip file
+     * @param options Download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    downloadArtifacts(options: ArtifactsDownloadOptions): Promise<void>;
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param options Report download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    downloadReports(options: ReportDownloadOptions): Promise<void>;
+    /**
+     * Download a specific report type
+     * @param type Report type to download
+     * @param filePath Path where report should be saved
+     * @param options Download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    private downloadReport;
+}

package/dist/services/report-download.service.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportDownloadService = void 0;
+const path = require("node:path");
+const api_gateway_1 = require("../gateways/api-gateway");
+/**
+ * Service for downloading test artifacts and reports
+ */
+class ReportDownloadService {
+    /**
+     * Download test artifacts as a zip file
+     * @param options Download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    async downloadArtifacts(options) {
+        const { apiUrl, apiKey, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
+        try {
+            if (debug && logger) {
+                logger(`DEBUG: Downloading artifacts: ${downloadType}`);
+            }
+            await api_gateway_1.ApiGateway.downloadArtifactsZip(apiUrl, apiKey, uploadId, downloadType, artifactsPath);
+            if (logger) {
+                logger('\n');
+                logger(`Test artifacts have been downloaded to ${artifactsPath}`);
+            }
+        }
+        catch (error) {
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading artifacts: ${error}`);
+            }
+            if (warnLogger) {
+                warnLogger('Failed to download artifacts');
+            }
+        }
+    }
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param options Report download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    async downloadReports(options) {
+        const { reportType, junitPath, allurePath, htmlPath, warnLogger, ...downloadOptions } = options;
+        switch (reportType) {
+            case 'junit': {
+                const reportPath = path.resolve(process.cwd(), junitPath || 'report.xml');
+                await this.downloadReport('junit', reportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            case 'allure': {
+                const reportPath = path.resolve(process.cwd(), allurePath || 'report.html');
+                await this.downloadReport('allure', reportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            case 'html': {
+                const htmlReportPath = path.resolve(process.cwd(), htmlPath || 'report.html');
+                await this.downloadReport('html', htmlReportPath, {
+                    ...downloadOptions,
+                    warnLogger,
+                });
+                break;
+            }
+            default: {
+                if (warnLogger) {
+                    warnLogger(`Unknown report type: ${reportType}`);
+                }
+            }
+        }
+    }
+    /**
+     * Download a specific report type
+     * @param type Report type to download
+     * @param filePath Path where report should be saved
+     * @param options Download configuration
+     * @returns Promise that resolves when download is complete
+     */
+    async downloadReport(type, filePath, options) {
+        const { apiUrl, apiKey, uploadId, debug = false, logger, warnLogger } = options;
+        try {
+            if (debug && logger) {
+                logger(`DEBUG: Downloading ${type.toUpperCase()} report`);
+            }
+            await api_gateway_1.ApiGateway.downloadReportGeneric(apiUrl, apiKey, uploadId, type, filePath);
+            if (logger) {
+                logger(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
+            }
+        }
+        catch (error) {
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading ${type.toUpperCase()} report: ${error}`);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (warnLogger) {
+                warnLogger(`Failed to download ${type.toUpperCase()} report: ${errorMessage}`);
+                if (errorMessage.includes('404')) {
+                    warnLogger(`No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`);
+                }
+                else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
+                    warnLogger('Permission denied. Check write permissions for the current directory.');
+                }
+                else if (errorMessage.includes('ENOENT')) {
+                    warnLogger('Directory does not exist. Make sure you have write access to the current directory.');
+                }
+            }
+        }
+    }
+}
+exports.ReportDownloadService = ReportDownloadService;

package/dist/services/results-polling.service.d.ts

@@ -0,0 +1,51 @@
+import { paths } from '../types/generated/schema.types';
+type TestResult = paths['/results/{uploadId}']['get']['responses']['200']['content']['application/json']['results'][number];
+/**
+ * Custom error for run failures that includes the polling result
+ */
+export declare class RunFailedError extends Error {
+    result: PollingResult;
+    constructor(result: PollingResult);
+}
+export interface PollingOptions {
+    apiKey: string;
+    apiUrl: string;
+    consoleUrl: string;
+    debug?: boolean;
+    json?: boolean;
+    logger?: (message: string) => void;
+    quiet?: boolean;
+    uploadId: string;
+}
+export interface PollingResult {
+    consoleUrl: string;
+    status: 'FAILED' | 'PASSED';
+    tests: Array<{
+        durationSeconds: null | number;
+        failReason?: string;
+        name: string;
+        status: string;
+    }>;
+    uploadId: string;
+}
+/**
+ * Service for polling test results from the API
+ */
+export declare class ResultsPollingService {
+    private readonly MAX_SEQUENTIAL_FAILURES;
+    private readonly POLL_INTERVAL_MS;
+    /**
+     * Poll for test results until all tests complete
+     * @param results Initial test results from submission
+     * @param options Polling configuration
+     * @returns Promise that resolves with final test results or rejects if tests fail
+     */
+    pollUntilComplete(results: TestResult[], options: PollingOptions): Promise<PollingResult>;
+    private buildPollingResult;
+    private calculateStatusSummary;
+    private displayFinalResults;
+    private filterLatestResults;
+    private handlePollingError;
+    private updateDisplayStatus;
+}
+export {};

package/dist/services/results-polling.service.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultsPollingService = exports.RunFailedError = void 0;
+const core_1 = require("@oclif/core");
+const cli_ux_1 = require("@oclif/core/lib/cli-ux");
+const api_gateway_1 = require("../gateways/api-gateway");
+const methods_1 = require("../methods");
+const connectivity_1 = require("../utils/connectivity");
+/**
+ * Custom error for run failures that includes the polling result
+ */
+class RunFailedError extends Error {
+    result;
+    constructor(result) {
+        super('RUN_FAILED');
+        this.result = result;
+        this.name = 'RunFailedError';
+    }
+}
+exports.RunFailedError = RunFailedError;
+/**
+ * Service for polling test results from the API
+ */
+class ResultsPollingService {
+    MAX_SEQUENTIAL_FAILURES = 10;
+    POLL_INTERVAL_MS = 5000;
+    /**
+     * Poll for test results until all tests complete
+     * @param results Initial test results from submission
+     * @param options Polling configuration
+     * @returns Promise that resolves with final test results or rejects if tests fail
+     */
+    async pollUntilComplete(results, options) {
+        const { apiUrl, apiKey, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        if (!json) {
+            core_1.ux.action.start('Waiting for results', 'Initializing', {
+                stdout: true,
+            });
+            if (logger) {
+                logger('\nYou can safely close this terminal and the tests will continue\n');
+            }
+        }
+        let sequentialPollFailures = 0;
+        let previousSummary = '';
+        if (debug && logger) {
+            logger(`DEBUG: Starting polling loop for results`);
+        }
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(async () => {
+                try {
+                    if (debug && logger) {
+                        logger(`DEBUG: Polling for results: ${uploadId}`);
+                    }
+                    const { results: updatedResults } = await api_gateway_1.ApiGateway.getResultsForUpload(apiUrl, apiKey, uploadId);
+                    if (!updatedResults) {
+                        throw new Error('no results');
+                    }
+                    if (debug && logger) {
+                        logger(`DEBUG: Poll received ${updatedResults.length} results`);
+                        for (const result of updatedResults) {
+                            logger(`DEBUG: Result status: ${result.test_file_name} - ${result.status}`);
+                        }
+                    }
+                    const { summary } = this.calculateStatusSummary(updatedResults);
+                    previousSummary = this.updateDisplayStatus(updatedResults, quiet, json, summary, previousSummary);
+                    const allComplete = updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status));
+                    if (allComplete) {
+                        if (debug && logger) {
+                            logger(`DEBUG: All tests completed, stopping poll`);
+                        }
+                        this.displayFinalResults(updatedResults, consoleUrl, json, logger);
+                        clearInterval(intervalId);
+                        const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl);
+                        if (output.status === 'FAILED') {
+                            if (debug && logger) {
+                                logger(`DEBUG: Some tests failed, returning failed status`);
+                            }
+                            reject(new RunFailedError(output));
+                        }
+                        else {
+                            if (debug && logger) {
+                                logger(`DEBUG: All tests passed, returning success status`);
+                            }
+                            sequentialPollFailures = 0;
+                            resolve(output);
+                        }
+                    }
+                }
+                catch (error) {
+                    sequentialPollFailures++;
+                    try {
+                        await this.handlePollingError(error, sequentialPollFailures, debug, logger);
+                    }
+                    catch (error) {
+                        clearInterval(intervalId);
+                        reject(error);
+                    }
+                }
+            }, this.POLL_INTERVAL_MS);
+        });
+    }
+    buildPollingResult(results, uploadId, consoleUrl) {
+        const resultsWithoutEarlierTries = this.filterLatestResults(results);
+        return {
+            consoleUrl,
+            status: resultsWithoutEarlierTries.some((result) => result.status === 'FAILED')
+                ? 'FAILED'
+                : 'PASSED',
+            tests: resultsWithoutEarlierTries.map((r) => ({
+                durationSeconds: r.duration_seconds,
+                failReason: r.status === 'FAILED' ? r.fail_reason || 'No reason provided' : undefined,
+                name: r.test_file_name,
+                status: r.status,
+            })),
+            uploadId,
+        };
+    }
+    calculateStatusSummary(results) {
+        const statusCounts = {};
+        for (const result of results) {
+            statusCounts[result.status] = (statusCounts[result.status] || 0) + 1;
+        }
+        const passed = statusCounts.PASSED || 0;
+        const failed = statusCounts.FAILED || 0;
+        const pending = statusCounts.PENDING || 0;
+        const running = statusCounts.RUNNING || 0;
+        const total = results.length;
+        const completed = passed + failed;
+        const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
+        return { completed, failed, passed, pending, running, summary, total };
+    }
+    displayFinalResults(results, consoleUrl, json, logger) {
+        if (json) {
+            return;
+        }
+        core_1.ux.action.stop('completed');
+        if (logger) {
+            logger('\n');
+        }
+        const hasFailedTests = results.some((result) => result.status === 'FAILED');
+        (0, cli_ux_1.table)(results, {
+            duration: {
+                get: (row) => row.duration_seconds
+                    ? (0, methods_1.formatDurationSeconds)(Number(row.duration_seconds))
+                    : '-',
+            },
+            status: { get: (row) => row.status },
+            test: {
+                get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
+            },
+            ...(hasFailedTests && {
+                // eslint-disable-next-line camelcase
+                fail_reason: {
+                    get: (row) => row.status === 'FAILED' && row.fail_reason ? row.fail_reason : '',
+                },
+            }),
+        }, { printLine: logger });
+        if (logger) {
+            logger('\n');
+            logger('Run completed, you can access the results at:');
+            logger(consoleUrl);
+            logger('\n');
+        }
+    }
+    filterLatestResults(results) {
+        return results.filter((result) => {
+            const originalTryId = result.retry_of || result.id;
+            const tries = results.filter((r) => r.retry_of === originalTryId || r.id === originalTryId);
+            return result.id === Math.max(...tries.map((t) => t.id));
+        });
+    }
+    async handlePollingError(error, sequentialPollFailures, debug, logger) {
+        if (debug && logger) {
+            logger(`DEBUG: Error polling for results: ${error}`);
+            logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+        }
+        if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
+            if (debug && logger) {
+                logger('DEBUG: Checking internet connectivity...');
+            }
+            const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
+            if (debug && logger) {
+                logger(`DEBUG: ${connectivityCheck.message}`);
+                for (const result of connectivityCheck.endpointResults) {
+                    if (result.success) {
+                        logger(`DEBUG: ✓ ${result.endpoint} - ${result.statusCode} (${result.latencyMs}ms)`);
+                    }
+                    else {
+                        logger(`DEBUG: ✗ ${result.endpoint} - ${result.error} (${result.latencyMs}ms)`);
+                    }
+                }
+            }
+            if (!connectivityCheck.connected) {
+                const endpointDetails = connectivityCheck.endpointResults
+                    .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                    .join('\n');
+                throw new Error(`Unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.`);
+            }
+            throw new Error(`unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts`);
+        }
+        if (logger) {
+            logger('unable to fetch results, trying again...');
+        }
+    }
+    updateDisplayStatus(results, quiet, json, summary, previousSummary) {
+        if (json) {
+            return previousSummary;
+        }
+        if (quiet) {
+            if (summary !== previousSummary) {
+                core_1.ux.action.status = summary;
+                return summary;
+            }
+        }
+        else {
+            core_1.ux.action.status = '\nStatus      Test\n─────────── ───────────────';
+            for (const { retry_of: isRetry, status, test_file_name: test, } of results) {
+                core_1.ux.action.status += `\n${status.padEnd(10, ' ')}  ${test} ${isRetry ? '(retry)' : ''}`;
+            }
+        }
+        return previousSummary;
+    }
+}
+exports.ResultsPollingService = ResultsPollingService;

package/dist/services/test-submission.service.d.ts

@@ -0,0 +1,47 @@
+import { IExecutionPlan } from './execution-plan.service';
+export interface TestSubmissionConfig {
+    androidApiLevel?: string;
+    androidDevice?: string;
+    appBinaryId: string;
+    cliVersion: string;
+    commonRoot: string;
+    continueOnFailure?: boolean;
+    debug?: boolean;
+    deviceLocale?: string;
+    env?: string[];
+    executionPlan: IExecutionPlan;
+    flowFile: string;
+    googlePlay?: boolean;
+    iOSDevice?: string;
+    iOSVersion?: string;
+    logger?: (message: string) => void;
+    maestroVersion: string;
+    metadata?: string[];
+    mitmHost?: string;
+    mitmPath?: string;
+    name?: string;
+    orientation?: string;
+    raw?: unknown;
+    report?: string;
+    retry?: number;
+    runnerType?: string;
+    showCrosshairs?: boolean;
+    skipChromeOnboarding?: boolean;
+}
+/**
+ * Service for building test submission form data
+ */
+export declare class TestSubmissionService {
+    /**
+     * Build FormData for test submission
+     * @param config Test submission configuration
+     * @returns FormData ready to be submitted to the API
+     */
+    buildTestFormData(config: TestSubmissionConfig): Promise<FormData>;
+    private logDebug;
+    private normalizeFilePath;
+    private normalizePathMap;
+    private normalizePaths;
+    private parseKeyValuePairs;
+    private setOptionalFields;
+}