@devicecloud.dev/dcd 4.1.3 → 4.1.5

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

@@ -61,93 +61,16 @@ class ResultsPollingService {
                             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))) {
+                    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`);
                         }
-                        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');
-                            }
-                        }
+                        this.displayFinalResults(updatedResults, consoleUrl, json, logger);
                         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,
-                        };
+                        const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl);
                         if (output.status === 'FAILED') {
                             if (debug && logger) {
                                 logger(`DEBUG: Some tests failed, returning failed status`);
@@ -165,46 +88,137 @@ class ResultsPollingService {
                 }
                 catch (error) {
                     sequentialPollFailures++;
-                    if (debug && logger) {
-                        logger(`DEBUG: Error polling for results: ${error}`);
-                        logger(`DEBUG: Sequential poll failures: ${sequentialPollFailures}`);
+                    try {
+                        await this.handlePollingError(error, sequentialPollFailures, debug, logger);
                     }
-                    if (sequentialPollFailures > this.MAX_SEQUENTIAL_FAILURES) {
-                        // dropped poll requests shouldn't err user CI
+                    catch (error) {
                         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...');
+                        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

@@ -38,4 +38,10 @@ export declare class TestSubmissionService {
      * @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;
 }

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

@@ -20,29 +20,15 @@ class TestSubmissionService {
         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)}`);
+        const envObject = this.parseKeyValuePairs(env);
+        const metadataObject = this.parseKeyValuePairs(metadata);
+        if (Object.keys(envObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: Environment variables: ${JSON.stringify(envObject)}`);
         }
-        if (debug && logger) {
-            logger(`DEBUG: Compressing files from path: ${flowFile}`);
+        if (Object.keys(metadataObject).length > 0) {
+            this.logDebug(debug, logger, `DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
         }
+        this.logDebug(debug, logger, `DEBUG: Compressing files from path: ${flowFile}`);
         const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
             ? path.dirname(flowFile)
             : flowFile, [
@@ -52,24 +38,16 @@ class TestSubmissionService {
                 ...sequentialFlows,
             ]),
         ], commonRoot);
-        if (debug && logger) {
-            logger(`DEBUG: Compressed file size: ${buffer.length} bytes`);
-        }
+        this.logDebug(debug, 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('testFileNames', JSON.stringify(this.normalizePaths(testFileNames, commonRoot)));
+        testFormData.set('flowMetadata', JSON.stringify(this.normalizePathMap(flowMetadata, commonRoot)));
+        testFormData.set('testFileOverrides', JSON.stringify(this.normalizePathMap(flowOverrides, commonRoot)));
+        testFormData.set('sequentialFlows', JSON.stringify(this.normalizePaths(sequentialFlows, commonRoot)));
         testFormData.set('env', JSON.stringify(envObject));
         testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
         const configPayload = {
@@ -92,25 +70,53 @@ class TestSubmissionService {
         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)}`);
-            }
+            this.logDebug(debug, 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)
+        this.setOptionalFields(testFormData, {
+            androidApiLevel,
+            androidDevice,
+            iOSDevice,
+            iOSVersion,
+            name,
+            runnerType,
+        });
+        if (workspaceConfig) {
             testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+        }
         return testFormData;
     }
+    logDebug(debug, logger, message) {
+        if (debug && logger) {
+            logger(message);
+        }
+    }
+    normalizeFilePath(filePath, commonRoot) {
+        return filePath.replaceAll(commonRoot, '.').split(path.sep).join('/');
+    }
+    normalizePathMap(map, commonRoot) {
+        return Object.fromEntries(Object.entries(map).map(([key, value]) => [
+            this.normalizeFilePath(key, commonRoot),
+            value,
+        ]));
+    }
+    normalizePaths(paths, commonRoot) {
+        return paths.map((p) => this.normalizeFilePath(p, commonRoot));
+    }
+    parseKeyValuePairs(pairs) {
+        // eslint-disable-next-line unicorn/no-array-reduce
+        return pairs.reduce((acc, cur) => {
+            const [key, ...value] = cur.split('=');
+            // handle case where value includes an equals sign
+            acc[key] = value.join('=');
+            return acc;
+        }, {});
+    }
+    setOptionalFields(formData, fields) {
+        for (const [key, value] of Object.entries(fields)) {
+            if (value) {
+                formData.set(key, value.toString());
+            }
+        }
+    }
 }
 exports.TestSubmissionService = TestSubmissionService;

package/dist/services/version.service.d.ts

@@ -19,8 +19,9 @@ export declare class VersionService {
      * Resolve and validate Maestro version against API compatibility data
      * @param requestedVersion - Version requested by user (or undefined for default)
      * @param compatibilityData - API compatibility data
-     * @param debug - Enable debug logging
-     * @param logger - Optional logger function
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
      * @returns Validated Maestro version string
      * @throws Error if version is not supported
      */

package/dist/services/version.service.js

@@ -44,8 +44,9 @@ class VersionService {
      * Resolve and validate Maestro version against API compatibility data
      * @param requestedVersion - Version requested by user (or undefined for default)
      * @param compatibilityData - API compatibility data
-     * @param debug - Enable debug logging
-     * @param logger - Optional logger function
+     * @param options - Configuration options
+     * @param options.debug - Enable debug logging
+     * @param options.logger - Optional logger function
      * @returns Validated Maestro version string
      * @throws Error if version is not supported
      */