@devicecloud.dev/dcd 4.1.5 → 4.1.7

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

@@ -6,6 +6,7 @@ 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");
+const styling_1 = require("../utils/styling");
 /**
  * Custom error for run failures that includes the polling result
  */
@@ -32,72 +33,46 @@ class ResultsPollingService {
      */
     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');
-            }
-        }
+        this.initializePollingDisplay(json, logger);
         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);
-                        }
-                    }
+        // Poll in a loop until all tests complete
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                const updatedResults = await this.fetchAndLogResults(apiUrl, apiKey, uploadId, debug, logger);
+                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) {
+                    return await this.handleCompletedTests(updatedResults, {
+                        consoleUrl,
+                        debug,
+                        json,
+                        logger,
+                        uploadId,
+                    });
                 }
-                catch (error) {
-                    sequentialPollFailures++;
-                    try {
-                        await this.handlePollingError(error, sequentialPollFailures, debug, logger);
-                    }
-                    catch (error) {
-                        clearInterval(intervalId);
-                        reject(error);
-                    }
+                // Reset failure counter on successful poll
+                sequentialPollFailures = 0;
+                // Wait before next poll
+                await this.sleep(this.POLL_INTERVAL_MS);
+            }
+            catch (error) {
+                // Re-throw RunFailedError immediately (test failures, not polling errors)
+                if (error instanceof RunFailedError) {
+                    throw error;
                 }
-            }, this.POLL_INTERVAL_MS);
-        });
+                sequentialPollFailures++;
+                // Handle polling errors (network issues, etc.)
+                await this.handlePollingError(error, sequentialPollFailures, debug, logger);
+                // Wait before retrying after an error
+                await this.sleep(this.POLL_INTERVAL_MS);
+            }
+        }
     }
     buildPollingResult(results, uploadId, consoleUrl) {
         const resultsWithoutEarlierTries = this.filterLatestResults(results);
@@ -126,42 +101,105 @@ class ResultsPollingService {
         const running = statusCounts.RUNNING || 0;
         const total = results.length;
         const completed = passed + failed;
-        const summary = `${completed}/${total} | ✓ ${passed} | ✗ ${failed} | ▶ ${running} | ⏸ ${pending}`;
+        const summary = (0, styling_1.formatTestSummary)({
+            completed,
+            failed,
+            passed,
+            pending,
+            running,
+            total,
+        });
         return { completed, failed, passed, pending, running, summary, total };
     }
     displayFinalResults(results, consoleUrl, json, logger) {
         if (json) {
             return;
         }
-        core_1.ux.action.stop('completed');
+        core_1.ux.action.stop(styling_1.colors.success('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))
-                    : '-',
+                get(row) {
+                    return row.duration_seconds
+                        ? styling_1.colors.dim((0, methods_1.formatDurationSeconds)(Number(row.duration_seconds)))
+                        : styling_1.colors.dim('-');
+                },
+            },
+            status: {
+                get(row) {
+                    const statusUpper = row.status.toUpperCase();
+                    switch (statusUpper) {
+                        case 'PASSED': {
+                            return styling_1.colors.success(row.status);
+                        }
+                        case 'FAILED': {
+                            return styling_1.colors.error(row.status);
+                        }
+                        case 'RUNNING': {
+                            return styling_1.colors.info(row.status);
+                        }
+                        case 'PENDING': {
+                            return styling_1.colors.warning(row.status);
+                        }
+                        default: {
+                            return styling_1.colors.dim(row.status);
+                        }
+                    }
+                },
             },
-            status: { get: (row) => row.status },
             test: {
-                get: (row) => `${row.test_file_name} ${row.retry_of ? '(retry)' : ''}`,
+                get(row) {
+                    const testName = row.test_file_name;
+                    const retry = row.retry_of ? styling_1.colors.dim(' (retry)') : '';
+                    return `${testName}${retry}`;
+                },
             },
             ...(hasFailedTests && {
                 // eslint-disable-next-line camelcase
                 fail_reason: {
-                    get: (row) => row.status === 'FAILED' && row.fail_reason ? row.fail_reason : '',
+                    get(row) {
+                        return row.status === 'FAILED' && row.fail_reason
+                            ? styling_1.colors.error(row.fail_reason)
+                            : '';
+                    },
                 },
             }),
         }, { printLine: logger });
         if (logger) {
             logger('\n');
-            logger('Run completed, you can access the results at:');
-            logger(consoleUrl);
+            logger(styling_1.colors.bold('Run completed') + styling_1.colors.dim(', you can access the results at:'));
+            logger(styling_1.colors.url(consoleUrl));
             logger('\n');
         }
     }
+    /**
+     * Fetch results from API and log debug information
+     * @param apiUrl API base URL
+     * @param apiKey API authentication key
+     * @param uploadId Upload ID to fetch results for
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns Promise resolving to test results
+     */
+    async fetchAndLogResults(apiUrl, apiKey, uploadId, debug, logger) {
+        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}`);
+            }
+        }
+        return updatedResults;
+    }
     filterLatestResults(results) {
         return results.filter((result) => {
             const originalTryId = result.retry_of || result.id;
@@ -169,6 +207,30 @@ class ResultsPollingService {
             return result.id === Math.max(...tries.map((t) => t.id));
         });
     }
+    /**
+     * Handle completed tests and return final result
+     * @param updatedResults Test results from API
+     * @param options Completion handling options
+     * @returns Promise resolving to final polling result
+     */
+    async handleCompletedTests(updatedResults, options) {
+        const { uploadId, consoleUrl, json, debug, logger } = options;
+        if (debug && logger) {
+            logger(`DEBUG: All tests completed, stopping poll`);
+        }
+        this.displayFinalResults(updatedResults, consoleUrl, json, logger);
+        const output = this.buildPollingResult(updatedResults, uploadId, consoleUrl);
+        if (output.status === 'FAILED') {
+            if (debug && logger) {
+                logger(`DEBUG: Some tests failed, returning failed status`);
+            }
+            throw new RunFailedError(output);
+        }
+        if (debug && logger) {
+            logger(`DEBUG: All tests passed, returning success status`);
+        }
+        return output;
+    }
     async handlePollingError(error, sequentialPollFailures, debug, logger) {
         if (debug && logger) {
             logger(`DEBUG: Error polling for results: ${error}`);
@@ -202,6 +264,32 @@ class ResultsPollingService {
             logger('unable to fetch results, trying again...');
         }
     }
+    /**
+     * Initialize the polling display UI
+     * @param json Whether to output in JSON format
+     * @param logger Optional logger function for output
+     * @returns void
+     */
+    initializePollingDisplay(json, logger) {
+        if (!json) {
+            core_1.ux.action.start(styling_1.colors.bold('Waiting for results'), styling_1.colors.dim('Initializing'), {
+                stdout: true,
+            });
+            if (logger) {
+                logger(styling_1.colors.dim('\nYou can safely close this terminal and the tests will continue\n'));
+            }
+        }
+    }
+    /**
+     * Sleep for the specified number of milliseconds
+     * @param ms Number of milliseconds to sleep
+     * @returns Promise that resolves after the delay
+     */
+    async sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
     updateDisplayStatus(results, quiet, json, summary, previousSummary) {
         if (json) {
             return previousSummary;
@@ -213,9 +301,17 @@ class ResultsPollingService {
             }
         }
         else {
-            core_1.ux.action.status = '\nStatus      Test\n─────────── ───────────────';
+            core_1.ux.action.status = styling_1.colors.dim('\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)' : ''}`;
+                const statusFormatted = status.toUpperCase() === 'PASSED'
+                    ? styling_1.colors.success(status.padEnd(10, ' '))
+                    : status.toUpperCase() === 'FAILED'
+                        ? styling_1.colors.error(status.padEnd(10, ' '))
+                        : status.toUpperCase() === 'RUNNING'
+                            ? styling_1.colors.info(status.padEnd(10, ' '))
+                            : styling_1.colors.warning(status.padEnd(10, ' '));
+                const retryText = isRetry ? styling_1.colors.dim(' (retry)') : '';
+                core_1.ux.action.status += `\n${statusFormatted}  ${test}${retryText}`;
             }
         }
         return previousSummary;

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

@@ -28,6 +28,17 @@ class TestSubmissionService {
         if (Object.keys(metadataObject).length > 0) {
             this.logDebug(debug, logger, `DEBUG: User metadata: ${JSON.stringify(metadataObject)}`);
         }
+        // Log non-YAML file assets being uploaded
+        if (referencedFiles.length > 0) {
+            const nonYamlFiles = referencedFiles.filter((file) => !file.endsWith('.yaml') && !file.endsWith('.yml'));
+            if (nonYamlFiles.length > 0) {
+                this.logDebug(debug, logger, `DEBUG: Uploading ${nonYamlFiles.length} non-YAML file asset(s):`);
+                for (const file of nonYamlFiles) {
+                    const normalizedPath = this.normalizeFilePath(file, commonRoot);
+                    this.logDebug(debug, logger, `DEBUG:   - ${normalizedPath}`);
+                }
+            }
+        }
         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)

package/dist/types/generated/schema.types.d.ts

@@ -443,6 +443,21 @@ export interface components {
             path: string;
             token: string;
             id: string;
+            b2?: {
+                strategy: 'simple' | 'large';
+                simple?: {
+                    uploadUrl: string;
+                    authorizationToken: string;
+                };
+                large?: {
+                    fileId: string;
+                    fileName: string;
+                    uploadPartUrls: Array<{
+                        uploadUrl: string;
+                        authorizationToken: string;
+                    }>;
+                };
+            };
         };
         ICheckForExistingUploadArgs: {
             sha: string;