@devicecloud.dev/dcd 4.0.2 → 4.0.3-beta.1

package/dist/commands/cloud.d.ts

@@ -54,4 +54,15 @@ export default class Cloud extends Command {
     };
     private versionCheck;
     run(): Promise<any>;
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param reportType The type of report to download ('junit', 'allure', or 'all')
+     * @param apiUrl The base URL for the API server
+     * @param apiKey The API key for authentication
+     * @param uploadId The unique identifier for the test upload
+     * @param junitPath Optional file path where the JUnit report should be saved
+     * @param debug Whether debug logging is enabled
+     * @returns Promise that resolves when all reports have been downloaded
+     */
+    private handleReportDownloads;
 }

package/dist/commands/cloud.js

@@ -684,33 +684,9 @@ class Cloud extends core_1.Command {
                                     this.warn('Failed to download artifacts');
                                 }
                             }
-                            // Handle report download separately if --report junit is specified
-                            if (report === 'junit') {
-                                try {
-                                    if (debug) {
-                                        this.log('DEBUG: Downloading JUNIT report');
-                                    }
-                                    const reportPath = path.resolve(process.cwd(), junitPath || 'report.xml');
-                                    await api_gateway_1.ApiGateway.downloadReport(apiUrl, apiKey, results[0].test_upload_id, reportPath);
-                                    this.log('\n');
-                                    this.log(`JUNIT test report has been downloaded to ${reportPath}`);
-                                }
-                                catch (error) {
-                                    if (debug) {
-                                        this.log(`DEBUG: Error downloading JUNIT report: ${error}`);
-                                    }
-                                    const errorMessage = error instanceof Error ? error.message : String(error);
-                                    this.warn(`Failed to download JUNIT report: ${errorMessage}`);
-                                    if (errorMessage.includes('404')) {
-                                        this.warn('No JUNIT reports found for this upload. Make sure your tests were run with --report junit flag.');
-                                    }
-                                    else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
-                                        this.warn('Permission denied. Check write permissions for the current directory.');
-                                    }
-                                    else if (errorMessage.includes('ENOENT')) {
-                                        this.warn('Directory does not exist. Make sure you have write access to the current directory.');
-                                    }
-                                }
+                            // Handle report downloads based on --report flag
+                            if (report && ['allure', 'html', 'junit'].includes(report)) {
+                                await this.handleReportDownloads(report, apiUrl, apiKey, results[0].test_upload_id, junitPath, debug);
                             }
                             const resultsWithoutEarlierTries = updatedResults.filter((result) => {
                                 const originalTryId = result.retry_of || result.id;
@@ -811,5 +787,63 @@ class Cloud extends core_1.Command {
             }
         }
     }
+    /**
+     * Handle downloading reports based on the report type specified
+     * @param reportType The type of report to download ('junit', 'allure', or 'all')
+     * @param apiUrl The base URL for the API server
+     * @param apiKey The API key for authentication
+     * @param uploadId The unique identifier for the test upload
+     * @param junitPath Optional file path where the JUnit report should be saved
+     * @param debug Whether debug logging is enabled
+     * @returns Promise that resolves when all reports have been downloaded
+     */
+    // eslint-disable-next-line max-params
+    async handleReportDownloads(reportType, apiUrl, apiKey, uploadId, junitPath, debug) {
+        const downloadReport = async (type, filePath) => {
+            try {
+                if (debug) {
+                    this.log(`DEBUG: Downloading ${type.toUpperCase()} report`);
+                }
+                await api_gateway_1.ApiGateway.downloadReportGeneric(apiUrl, apiKey, uploadId, type, filePath);
+                this.log(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
+            }
+            catch (error) {
+                if (debug) {
+                    this.log(`DEBUG: Error downloading ${type.toUpperCase()} report: ${error}`);
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.warn(`Failed to download ${type.toUpperCase()} report: ${errorMessage}`);
+                if (errorMessage.includes('404')) {
+                    this.warn(`No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`);
+                }
+                else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
+                    this.warn('Permission denied. Check write permissions for the current directory.');
+                }
+                else if (errorMessage.includes('ENOENT')) {
+                    this.warn('Directory does not exist. Make sure you have write access to the current directory.');
+                }
+            }
+        };
+        switch (reportType) {
+            case 'junit': {
+                const reportPath = path.resolve(process.cwd(), junitPath || 'report.xml');
+                await downloadReport('junit', reportPath);
+                break;
+            }
+            case 'allure': {
+                const allureReportPath = path.resolve(process.cwd(), `allure-report-${uploadId}.zip`);
+                await downloadReport('allure', allureReportPath);
+                break;
+            }
+            case 'html': {
+                const htmlReportPath = path.resolve(process.cwd(), `html-report-${uploadId}.zip`);
+                await downloadReport('html', htmlReportPath);
+                break;
+            }
+            default: {
+                this.warn(`Unknown report type: ${reportType}`);
+            }
+        }
+    }
 }
 exports.default = Cloud;

package/dist/constants.js

@@ -194,8 +194,8 @@ exports.flags = {
     }),
     report: core_1.Flags.string({
         aliases: ['format'],
-        description: 'Runs Maestro with the --format flag, this will generate a report in the specified format',
-        options: ['junit', 'html'],
+        description: 'Generate and download test reports in the specified format. HTML reports will be returned in the Allure format, please see the documentation for more details.',
+        options: ['junit', 'allure', 'html'],
     }),
     retry: core_1.Flags.integer({
         description: 'Automatically retry the run up to the number of times specified (same as pressing retry in the UI) - this is free of charge',

package/dist/gateways/api-gateway.d.ts

@@ -1,10 +1,16 @@
 import { TAppMetadata } from '../types';
 export declare const ApiGateway: {
+    /**
+     * Standardized error handling for API responses
+     * @param res - The fetch response object
+     * @param operation - Description of the operation that failed
+     * @returns Never returns, always throws
+     */
+    handleApiError(res: Response, operation: string): Promise<never>;
     checkForExistingUpload(baseUrl: string, apiKey: string, sha: string): Promise<{
         appBinaryId: string;
         exists: boolean;
     }>;
-    downloadReport(baseUrl: string, apiKey: string, uploadId: string, reportPath?: string): Promise<void>;
     downloadArtifactsZip(baseUrl: string, apiKey: string, uploadId: string, results: "ALL" | "FAILED", artifactsPath?: string): Promise<void>;
     finaliseUpload(baseUrl: string, apiKey: string, id: string, metadata: TAppMetadata, path: string, sha: string): Promise<Record<string, never>>;
     getBinaryUploadUrl(baseUrl: string, apiKey: string, platform: "android" | "ios"): Promise<{
@@ -33,4 +39,14 @@ export declare const ApiGateway: {
         message?: string;
         results?: import("../types/schema.types").components["schemas"]["IDBResult"][];
     }>;
+    /**
+     * Generic report download method that handles both junit and allure reports
+     * @param baseUrl - API base URL
+     * @param apiKey - API key for authentication
+     * @param uploadId - Upload ID to download report for
+     * @param reportType - Type of report to download ('junit' or 'allure')
+     * @param reportPath - Optional custom path for the downloaded report
+     * @returns Promise that resolves when download is complete
+     */
+    downloadReportGeneric(baseUrl: string, apiKey: string, uploadId: string, reportType: "allure" | "junit" | "html", reportPath?: string): Promise<void>;
 };

package/dist/gateways/api-gateway.js

@@ -1,9 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiGateway = void 0;
-const fs = require("node:fs/promises");
 const path = require("node:path");
 exports.ApiGateway = {
+    /**
+     * Standardized error handling for API responses
+     * @param res - The fetch response object
+     * @param operation - Description of the operation that failed
+     * @returns Never returns, always throws
+     */
+    async handleApiError(res, operation) {
+        const errorText = await res.text();
+        let userMessage;
+        // Parse common API error formats
+        try {
+            const errorData = JSON.parse(errorText);
+            userMessage = errorData.message || errorData.error || errorText;
+        }
+        catch {
+            userMessage = errorText;
+        }
+        // Add context and improve readability
+        switch (res.status) {
+            case 400: {
+                throw new Error(`Invalid request: ${userMessage}`);
+            }
+            case 401: {
+                throw new Error(`Authentication failed. Please check your API key.`);
+            }
+            case 403: {
+                throw new Error(`Access denied. ${userMessage}`);
+            }
+            case 404: {
+                throw new Error(`Resource not found. ${userMessage}`);
+            }
+            case 429: {
+                throw new Error(`Rate limit exceeded. Please try again later.`);
+            }
+            case 500: {
+                throw new Error(`Server error occurred. Please try again or contact support.`);
+            }
+            default: {
+                throw new Error(`${operation} failed: ${userMessage} (HTTP ${res.status})`);
+            }
+        }
+    },
     async checkForExistingUpload(baseUrl, apiKey, sha) {
         const res = await fetch(`${baseUrl}/uploads/checkForExistingUpload`, {
             body: JSON.stringify({ sha }),
@@ -15,25 +56,6 @@ exports.ApiGateway = {
         });
         return res.json();
     },
-    async downloadReport(baseUrl, apiKey, uploadId, reportPath) {
-        const finalReportPath = reportPath || path.resolve(process.cwd(), `report-${uploadId}.xml`);
-        const url = `${baseUrl}/results/${uploadId}/report`;
-        const res = await fetch(url, {
-            headers: {
-                'x-app-api-key': apiKey,
-            },
-            method: 'GET',
-        });
-        if (!res.ok) {
-            const errorText = await res.text();
-            if (res.status === 404) {
-                throw new Error(`Upload ID '${uploadId}' not found or no results available for this upload`);
-            }
-            throw new Error(`Failed to download report: ${res.status} ${errorText}`);
-        }
-        const buffer = await res.arrayBuffer();
-        await fs.writeFile(finalReportPath, Buffer.from(buffer));
-    },
     async downloadArtifactsZip(baseUrl, apiKey, uploadId, results, artifactsPath = './artifacts.zip') {
         const res = await fetch(`${baseUrl}/results/${uploadId}/download`, {
             body: JSON.stringify({ results }),
@@ -44,7 +66,7 @@ exports.ApiGateway = {
             method: 'POST',
         });
         if (!res.ok) {
-            throw new Error(await res.text());
+            await this.handleApiError(res, 'Failed to download artifacts');
         }
         // Handle tilde expansion for home directory
         if (artifactsPath.startsWith('~/') || artifactsPath === '~') {
@@ -87,7 +109,7 @@ exports.ApiGateway = {
             method: 'POST',
         });
         if (!res.ok) {
-            throw new Error(await res.text());
+            await this.handleApiError(res, 'Failed to finalize upload');
         }
         return res.json();
     },
@@ -101,7 +123,7 @@ exports.ApiGateway = {
             method: 'POST',
         });
         if (!res.ok) {
-            throw new Error(await res.text());
+            await this.handleApiError(res, 'Failed to get upload URL');
         }
         return res.json();
     },
@@ -111,7 +133,7 @@ exports.ApiGateway = {
             headers: { 'x-app-api-key': apiKey },
         });
         if (!res.ok) {
-            throw new Error(await res.text());
+            await this.handleApiError(res, 'Failed to get results');
         }
         return res.json();
     },
@@ -129,7 +151,7 @@ exports.ApiGateway = {
             },
         });
         if (!response.ok) {
-            throw new Error(`Failed to fetch status: ${response.statusText}`);
+            await this.handleApiError(response, 'Failed to get upload status');
         }
         return response.json();
     },
@@ -142,8 +164,88 @@ exports.ApiGateway = {
             method: 'POST',
         });
         if (!res.ok) {
-            throw new Error(await res.text());
+            await this.handleApiError(res, 'Failed to upload test flows');
         }
         return res.json();
     },
+    /**
+     * Generic report download method that handles both junit and allure reports
+     * @param baseUrl - API base URL
+     * @param apiKey - API key for authentication
+     * @param uploadId - Upload ID to download report for
+     * @param reportType - Type of report to download ('junit' or 'allure')
+     * @param reportPath - Optional custom path for the downloaded report
+     * @returns Promise that resolves when download is complete
+     */
+    async downloadReportGeneric(baseUrl, apiKey, uploadId, reportType, reportPath) {
+        // Define endpoint and default filename mappings
+        const config = {
+            junit: {
+                endpoint: `/results/${uploadId}/report`,
+                defaultFilename: `report-${uploadId}.xml`,
+                notFoundMessage: `Upload ID '${uploadId}' not found or no results available for this upload`,
+                errorPrefix: 'Failed to download report',
+            },
+            allure: {
+                endpoint: `/allure/${uploadId}/download`,
+                defaultFilename: `allure-report-${uploadId}.zip`,
+                notFoundMessage: `Upload ID '${uploadId}' not found or no Allure report available for this upload`,
+                errorPrefix: 'Failed to download Allure report',
+            },
+            html: {
+                endpoint: `/results/${uploadId}/html-report`,
+                defaultFilename: `html-report-${uploadId}.zip`,
+                notFoundMessage: `Upload ID '${uploadId}' not found or no HTML report available for this upload`,
+                errorPrefix: 'Failed to download HTML report',
+            },
+        };
+        const { endpoint, defaultFilename, notFoundMessage, errorPrefix } = config[reportType];
+        const finalReportPath = reportPath || path.resolve(process.cwd(), defaultFilename);
+        const url = `${baseUrl}${endpoint}`;
+        // Make the download request
+        const res = await fetch(url, {
+            headers: {
+                'x-app-api-key': apiKey,
+            },
+            method: 'GET',
+        });
+        if (!res.ok) {
+            const errorText = await res.text();
+            if (res.status === 404) {
+                throw new Error(notFoundMessage);
+            }
+            throw new Error(`${errorPrefix}: ${res.status} ${errorText}`);
+        }
+        // Handle tilde expansion for home directory (applies to all report types)
+        let expandedPath = finalReportPath;
+        if (finalReportPath.startsWith('~/') || finalReportPath === '~') {
+            expandedPath = finalReportPath.replace(/^~/, 
+            // eslint-disable-next-line unicorn/prefer-module
+            require('node:os').homedir());
+        }
+        // Create directory structure if it doesn't exist
+        // eslint-disable-next-line unicorn/prefer-module
+        const { dirname } = require('node:path');
+        // eslint-disable-next-line unicorn/prefer-module
+        const { createWriteStream, mkdirSync } = require('node:fs');
+        // eslint-disable-next-line unicorn/prefer-module
+        const { finished } = require('node:stream/promises');
+        // eslint-disable-next-line unicorn/prefer-module
+        const { Readable } = require('node:stream');
+        const directory = dirname(expandedPath);
+        if (directory !== '.') {
+            try {
+                mkdirSync(directory, { recursive: true });
+            }
+            catch (error) {
+                // Ignore EEXIST errors (directory already exists)
+                if (error.code !== 'EEXIST') {
+                    throw error;
+                }
+            }
+        }
+        // Write the file using streaming for better memory efficiency
+        const fileStream = createWriteStream(expandedPath, { flags: 'wx' });
+        await finished(Readable.fromWeb(res.body).pipe(fileStream));
+    },
 };

package/oclif.manifest.json

@@ -374,12 +374,13 @@
           "aliases": [
             "format"
           ],
-          "description": "Runs Maestro with the --format flag, this will generate a report in the specified format",
+          "description": "Generate and download test reports in the specified format. HTML reports will be returned in the Allure format, please see the documentation for more details.",
           "name": "report",
           "hasDynamicHelp": false,
           "multiple": false,
           "options": [
             "junit",
+            "allure",
             "html"
           ],
           "type": "option"
@@ -581,5 +582,5 @@
       ]
     }
   },
-  "version": "4.0.2"
+  "version": "4.0.3-beta.1"
 }

package/package.json

@@ -80,7 +80,7 @@
     "version": "oclif readme && git add README.md",
     "test": "node scripts/test-runner.mjs"
   },
-  "version": "4.0.2",
+  "version": "4.0.3-beta.1",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },
@@ -94,4 +94,4 @@
   ],
   "types": "dist/index.d.ts",
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
-}
+}