errors + devicename

Author: jochen-testingbot

src/providers/base_provider.ts

@@ -6,6 +6,11 @@ import utils from '../utils';
 import Upload from '../upload';
 import platform from '../utils/platform';
 import logger from '../logger';
+import { handleAxiosError, isNetworkError } from '../utils/error-helpers';
+import {
+  checkInternetConnectivity,
+  formatConnectivityResults,
+} from '../utils/connectivity';
 
 /**
  * Common interface for run information shared by all providers
@@ -208,7 +213,8 @@ export default abstract class BaseProvider<
   }
 
   /**
-   * Extracts an error message from various error types
+   * Extracts an error message from various error types.
+   * For Axios errors, uses enhanced error handling with diagnostics.
    */
   protected extractErrorMessage(cause: unknown): string | null {
     if (typeof cause === 'string') {
@@ -220,7 +226,14 @@ export default abstract class BaseProvider<
     }
 
     if (cause && typeof cause === 'object') {
-      const axiosError = cause as {
+      // Use enhanced error handling for real Axios errors
+      if (axios.isAxiosError(cause)) {
+        const enhanced = handleAxiosError(cause, 'Request failed');
+        return enhanced.message;
+      }
+
+      // Handle error-like objects with response property (for backwards compatibility)
+      const axiosLikeError = cause as {
         response?: {
           status?: number;
           data?: { error?: string; errors?: string[]; message?: string };
@@ -229,18 +242,19 @@ export default abstract class BaseProvider<
       };
 
       // Check for 429 status code (credits depleted)
-      if (axiosError.response?.status === 429) {
+      if (axiosLikeError.response?.status === 429) {
         return 'Your TestingBot credits are depleted. Please upgrade your plan at https://testingbot.com/pricing';
       }
 
-      if (axiosError.response?.data?.errors) {
-        return axiosError.response.data.errors.join('\n');
+      // Extract error message from response data
+      if (axiosLikeError.response?.data?.errors) {
+        return axiosLikeError.response.data.errors.join('\n');
       }
-      if (axiosError.response?.data?.error) {
-        return axiosError.response.data.error;
+      if (axiosLikeError.response?.data?.error) {
+        return axiosLikeError.response.data.error;
       }
-      if (axiosError.response?.data?.message) {
-        return axiosError.response.data.message;
+      if (axiosLikeError.response?.data?.message) {
+        return axiosLikeError.response.data.message;
       }
 
       if (cause instanceof Error) {
@@ -266,6 +280,58 @@ export default abstract class BaseProvider<
     return null;
   }
 
+  /**
+   * Checks internet connectivity and logs diagnostic information.
+   * Useful when network errors occur to help users troubleshoot.
+   */
+  protected async checkAndReportConnectivity(): Promise<boolean> {
+    logger.info('Checking internet connectivity...');
+    const result = await checkInternetConnectivity();
+    logger.info(formatConnectivityResults(result));
+    return result.connected;
+  }
+
+  /**
+   * Performs a quick connectivity check before starting operations.
+   * Throws an error with diagnostics if no connection is available.
+   */
+  protected async ensureConnectivity(): Promise<void> {
+    const result = await checkInternetConnectivity();
+    if (!result.connected) {
+      logger.error('No internet connection detected.');
+      logger.error(formatConnectivityResults(result));
+      throw new TestingBotError(
+        'No internet connection. Please check your network and try again.',
+      );
+    }
+  }
+
+  /**
+   * Handles errors with enhanced diagnostics.
+   * For network errors, performs connectivity check.
+   */
+  protected async handleErrorWithDiagnostics(
+    error: unknown,
+    operation: string,
+  ): Promise<TestingBotError> {
+    if (axios.isAxiosError(error)) {
+      // For network errors, check connectivity
+      if (isNetworkError(error)) {
+        await this.checkAndReportConnectivity();
+      }
+      return handleAxiosError(error, operation);
+    }
+
+    if (error instanceof TestingBotError) {
+      return error;
+    }
+
+    return new TestingBotError(
+      `${operation}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      { cause: error instanceof Error ? error : undefined },
+    );
+  }
+
   /**
    * Formats elapsed time in human-readable format
    */

src/providers/espresso.ts

@@ -9,6 +9,12 @@ import TestingBotError from '../models/testingbot_error';
 import utils from '../utils';
 import BaseProvider from './base_provider';
 
+export interface EspressoRunEnvironment {
+  device?: string;
+  name?: string;
+  version?: string;
+}
+
 export interface EspressoRunInfo {
   id: number;
   status: 'WAITING' | 'READY' | 'DONE' | 'FAILED';
@@ -17,6 +23,7 @@ export interface EspressoRunInfo {
     platformName: string;
     version?: string;
   };
+  environment?: EspressoRunEnvironment;
   success: number;
   report?: string;
 }
@@ -94,6 +101,9 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
     }
 
     try {
+      // Quick connectivity check before starting uploads
+      await this.ensureConnectivity();
+
       if (!this.options.quiet) {
         logger.info('Uploading Espresso App');
       }
@@ -195,6 +205,7 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
             username: this.credentials.userName,
             password: this.credentials.accessKey,
           },
+          timeout: 30000, // 30 second timeout
         },
       );
 
@@ -223,9 +234,10 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
       if (error instanceof TestingBotError) {
         throw error;
       }
-      throw new TestingBotError(`Running Espresso test failed`, {
-        cause: error,
-      });
+      throw await this.handleErrorWithDiagnostics(
+        error,
+        'Running Espresso test failed',
+      );
     }
   }
 
@@ -239,6 +251,7 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
           username: this.credentials.userName,
           password: this.credentials.accessKey,
         },
+        timeout: 30000, // 30 second timeout
       });
 
       // Check for version update notification
@@ -247,9 +260,10 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
 
       return response.data;
     } catch (error) {
-      throw new TestingBotError(`Failed to get Espresso test status`, {
-        cause: error,
-      });
+      throw await this.handleErrorWithDiagnostics(
+        error,
+        'Failed to get Espresso test status',
+      );
     }
   }
 
@@ -284,7 +298,7 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
             const statusText =
               run.success === 1 ? 'Test completed successfully' : 'Test failed';
             console.log(
-              `  ${statusEmoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusText}`,
+              `  ${statusEmoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${statusText}`,
             );
           }
         }
@@ -300,7 +314,7 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
           logger.error(`${failedRuns.length} test run(s) failed:`);
           for (const run of failedRuns) {
             logger.error(
-              `  - Run ${run.id} (${run.capabilities.deviceName}): ${run.report || 'No report available'}`,
+              `  - Run ${run.id} (${this.getRunDisplayName(run)}): ${run.report || 'No report available'}`,
             );
           }
         }
@@ -350,16 +364,24 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
       const statusInfo = this.getStatusInfo(run.status);
 
       if (run.status === 'WAITING' || run.status === 'READY') {
-        const message = `  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text} (${elapsedStr})`;
+        const message = `  ${statusInfo.emoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${statusInfo.text} (${elapsedStr})`;
         process.stdout.write(`\r${message}`);
       } else if (statusChanged) {
         console.log(
-          `  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text}`,
+          `  ${statusInfo.emoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${statusInfo.text}`,
         );
       }
     }
   }
 
+  /**
+   * Get the display name for a run, preferring environment.name over capabilities.deviceName
+   * This shows the actual device used when a wildcard (*) was specified
+   */
+  private getRunDisplayName(run: EspressoRunInfo): string {
+    return run.environment?.name || run.capabilities.deviceName;
+  }
+
   private getStatusInfo(status: EspressoRunInfo['status']): {
     emoji: string;
     text: string;
@@ -405,6 +427,7 @@ export default class Espresso extends BaseProvider<EspressoOptions> {
           username: this.credentials.userName,
           password: this.credentials.accessKey,
         },
+        timeout: 30000, // 30 second timeout
       });
 
       // Check for version update notification