@devicecloud.dev/dcd 4.1.2 → 4.1.3

package/dist/services/moropo.service.js

@@ -0,0 +1,113 @@
+"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;
+        if (debug && logger) {
+            logger('DEBUG: Moropo v1 API key detected, downloading tests from Moropo API');
+            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 contentLength = response.headers.get('content-length');
+            const totalSize = contentLength
+                ? Number.parseInt(contentLength, 10)
+                : 0;
+            let downloadedSize = 0;
+            const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
+            if (debug && logger) {
+                logger(`DEBUG: Extracting Moropo tests to: ${moropoDir}`);
+            }
+            // Create moropo directory if it doesn't exist
+            if (!fs.existsSync(moropoDir)) {
+                fs.mkdirSync(moropoDir, { recursive: true });
+            }
+            // Write zip file to moropo directory
+            const zipPath = path.join(moropoDir, 'moropo-tests.zip');
+            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();
+                });
+            });
+            if (!quiet && !json) {
+                core_1.ux.action.status = 'Extracting tests...';
+            }
+            // Extract zip file
+            // eslint-disable-next-line new-cap
+            const zip = new StreamZip.async({ file: zipPath });
+            await zip.extract(null, moropoDir);
+            await zip.close();
+            // Delete zip file after extraction
+            fs.unlinkSync(zipPath);
+            if (!quiet && !json) {
+                core_1.ux.action.stop('completed');
+            }
+            if (debug && logger) {
+                logger('DEBUG: Successfully extracted Moropo tests');
+            }
+            // Create config.yaml file
+            const configPath = path.join(moropoDir, 'config.yaml');
+            fs.writeFileSync(configPath, 'flows:\n- ./**/*.yaml\n- ./*.yaml\n');
+            if (debug && logger) {
+                logger('DEBUG: Created config.yaml file');
+            }
+            return moropoDir;
+        }
+        catch (error) {
+            if (!quiet && !json) {
+                core_1.ux.action.stop('failed');
+            }
+            if (debug && logger) {
+                logger(`DEBUG: Error downloading/extracting Moropo tests: ${error}`);
+            }
+            throw new Error(`Failed to download/extract Moropo tests: ${error}`);
+        }
+    }
+}
+exports.MoropoService = MoropoService;

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

@@ -0,0 +1,40 @@
+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
+     */
+    downloadArtifacts(options: ArtifactsDownloadOptions): Promise<void>;
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param options Report download configuration
+     */
+    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
+     */
+    private downloadReport;
+}

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

@@ -0,0 +1,110 @@
+"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
+     */
+    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
+     */
+    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
+     */
+    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,45 @@
+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>;
+}
+export {};

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

@@ -0,0 +1,210 @@
+"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}`);
+                        }
+                    }
+                    // Calculate summary statistics
+                    const statusCounts = {};
+                    for (const result of updatedResults) {
+                        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 = updatedResults.length;
+                    const completed = passed + failed;
+                    // Display quantitative summary in quiet mode only
+                    const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
+                    if (!json) {
+                        if (quiet) {
+                            // Only update status when the summary changes in quiet mode
+                            if (summary !== previousSummary) {
+                                core_1.ux.action.status = summary;
+                                previousSummary = summary;
+                            }
+                        }
+                        else {
+                            // Show detailed table in non-quiet mode (no summary)
+                            core_1.ux.action.status =
+                                '\nStatus      Test\n─────────── ───────────────';
+                            for (const { retry_of: isRetry, status, test_file_name: test, } of updatedResults) {
+                                core_1.ux.action.status += `\n${status.padEnd(10, ' ')}  ${test} ${isRetry ? '(retry)' : ''}`;
+                            }
+                        }
+                    }
+                    if (updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status))) {
+                        if (debug && logger) {
+                            logger(`DEBUG: All tests completed, stopping poll`);
+                        }
+                        if (!json) {
+                            core_1.ux.action.stop('completed');
+                            if (logger) {
+                                logger('\n');
+                            }
+                            const hasFailedTests = updatedResults.some((result) => result.status === 'FAILED');
+                            (0, cli_ux_1.table)(updatedResults, {
+                                status: { get: (row) => row.status },
+                                test: {
+                                    get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
+                                },
+                                duration: {
+                                    get: (row) => row.duration_seconds
+                                        ? (0, methods_1.formatDurationSeconds)(Number(row.duration_seconds))
+                                        : '-',
+                                },
+                                ...(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');
+                            }
+                        }
+                        clearInterval(intervalId);
+                        const resultsWithoutEarlierTries = updatedResults.filter((result) => {
+                            const originalTryId = result.retry_of || result.id;
+                            const tries = updatedResults.filter((r) => r.retry_of === originalTryId || r.id === originalTryId);
+                            return result.id === Math.max(...tries.map((t) => t.id));
+                        });
+                        const output = {
+                            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,
+                        };
+                        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++;
+                    if (debug && logger) {
+                        logger(`DEBUG: Error polling for results: ${error}`);
+                        logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+                    }
+                    if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
+                        // dropped poll requests shouldn't err user CI
+                        clearInterval(intervalId);
+                        // Check if the failure is due to internet connectivity issues
+                        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) {
+                            // Build detailed error message with endpoint diagnostics
+                            const endpointDetails = connectivityCheck.endpointResults
+                                .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                                .join('\n');
+                            reject(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.`));
+                            return;
+                        }
+                        reject(new Error(`unable to fetch results after ${this.MAX_SEQUENTIAL_FAILURES} attempts`));
+                        return;
+                    }
+                    if (logger) {
+                        logger('unable to fetch results, trying again...');
+                    }
+                }
+            }, this.POLL_INTERVAL_MS);
+        });
+    }
+}
+exports.ResultsPollingService = ResultsPollingService;

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

@@ -0,0 +1,41 @@
+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>;
+}

package/dist/services/test-submission.service.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSubmissionService = void 0;
+const path = require("node:path");
+const methods_1 = require("../methods");
+const mimeTypeLookupByExtension = {
+    zip: 'application/zip',
+};
+/**
+ * Service for building test submission form data
+ */
+class TestSubmissionService {
+    /**
+     * Build FormData for test submission
+     * @param config Test submission configuration
+     * @returns FormData ready to be submitted to the API
+     */
+    async buildTestFormData(config) {
+        const { appBinaryId, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], googlePlay = false, androidApiLevel, androidDevice, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, mitmHost, mitmPath, retry, continueOnFailure = true, report, showCrosshairs, skipChromeOnboarding, raw, debug = false, logger, } = config;
+        const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, referencedFiles, sequence, workspaceConfig, } = executionPlan;
+        const { flows: sequentialFlows = [] } = sequence ?? {};
+        const testFormData = new FormData();
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const envObject = env.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const metadataObject = metadata.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+        if (debug && logger && Object.keys(envObject).length > 0) {
+            logger(`DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
+        }
+        if (debug && logger && Object.keys(metadataObject).length > 0) {
+            logger(`DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
+        }
+        if (debug && logger) {
+            logger(`DEBUG: Compressing files from path: ${flowFile}`);
+        }
+        const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
+            ? path.dirname(flowFile)
+            : flowFile, [
+            ...new Set([
+                ...referencedFiles,
+                ...testFileNames,
+                ...sequentialFlows,
+            ]),
+        ], commonRoot);
+        if (debug && logger) {
+            logger(`DEBUG: Compressed file size: ${buffer.length} bytes`);
+        }
+        const blob = new Blob([buffer], {
+            type: mimeTypeLookupByExtension.zip,
+        });
+        testFormData.set('file', blob, 'flowFile.zip');
+        testFormData.set('appBinaryId', appBinaryId);
+        testFormData.set('testFileNames', JSON.stringify(testFileNames.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
+        testFormData.set('flowMetadata', JSON.stringify(Object.fromEntries(Object.entries(flowMetadata).map(([key, value]) => [
+            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
+            value,
+        ]))));
+        testFormData.set('testFileOverrides', JSON.stringify(Object.fromEntries(Object.entries(flowOverrides).map(([key, value]) => [
+            key.replaceAll(commonRoot, '.').split(path.sep).join('/'),
+            value,
+        ]))));
+        testFormData.set('sequentialFlows', JSON.stringify(sequentialFlows.map((t) => t.replaceAll(commonRoot, '.').split(path.sep).join('/'))));
+        testFormData.set('env', JSON.stringify(envObject));
+        testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
+        const configPayload = {
+            allExcludeTags,
+            allIncludeTags,
+            autoRetriesRemaining: retry,
+            continueOnFailure,
+            deviceLocale,
+            maestroVersion,
+            mitmHost,
+            mitmPath,
+            orientation,
+            raw: JSON.stringify(raw),
+            report,
+            showCrosshairs,
+            skipChromeOnboarding,
+            version: cliVersion,
+        };
+        testFormData.set('config', JSON.stringify(configPayload));
+        if (Object.keys(metadataObject).length > 0) {
+            const metadataPayload = { userMetadata: metadataObject };
+            testFormData.set('metadata', JSON.stringify(metadataPayload));
+            if (debug && logger) {
+                logger(`DEBUG: Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
+            }
+        }
+        if (androidApiLevel)
+            testFormData.set('androidApiLevel', androidApiLevel.toString());
+        if (androidDevice)
+            testFormData.set('androidDevice', androidDevice.toString());
+        if (iOSVersion)
+            testFormData.set('iOSVersion', iOSVersion.toString());
+        if (iOSDevice)
+            testFormData.set('iOSDevice', iOSDevice.toString());
+        if (name)
+            testFormData.set('name', name.toString());
+        if (runnerType)
+            testFormData.set('runnerType', runnerType.toString());
+        if (workspaceConfig)
+            testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+        return testFormData;
+    }
+}
+exports.TestSubmissionService = TestSubmissionService;