maestro: add signal handlers

Author: jochen-testingbot

src/providers/maestro.ts

@@ -48,6 +48,9 @@ export default class Maestro {
 
   private appId: number | undefined = undefined;
   private detectedPlatform: 'Android' | 'iOS' | undefined = undefined;
+  private activeRunIds: number[] = [];
+  private isShuttingDown = false;
+  private signalHandler: (() => void) | null = null;
 
   public constructor(credentials: Credentials, options: MaestroOptions) {
     this.credentials = credentials;
@@ -175,12 +178,22 @@ export default class Maestro {
         return { success: true, runs: [] };
       }
 
+      // Set up signal handlers before waiting for completion
+      this.setupSignalHandlers();
+
       if (!this.options.quiet) {
         logger.info('Waiting for test results...');
       }
       const result = await this.waitForCompletion();
+
+      // Clean up signal handlers
+      this.removeSignalHandlers();
+
       return result;
     } catch (error) {
+      // Clean up signal handlers on error
+      this.removeSignalHandlers();
+
       logger.error(error instanceof Error ? error.message : error);
       // Display the cause if available
       if (error instanceof Error && error.cause) {
@@ -522,8 +535,18 @@ export default class Maestro {
     const previousStatus: Map<number, MaestroRunInfo['status']> = new Map();
 
     while (attempts < this.MAX_POLL_ATTEMPTS) {
+      // Check if we're shutting down
+      if (this.isShuttingDown) {
+        throw new TestingBotError('Test run cancelled by user');
+      }
+
       const status = await this.getStatus();
 
+      // Track active run IDs for graceful shutdown
+      this.activeRunIds = status.runs
+        .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
+        .map((run) => run.id);
+
       // Log current status of runs (unless quiet mode)
       if (!this.options.quiet) {
         this.displayRunStatus(status.runs, startTime, previousStatus);
@@ -760,4 +783,92 @@ export default class Maestro {
 
     return null;
   }
+
+  private setupSignalHandlers(): void {
+    this.signalHandler = () => {
+      this.handleShutdown();
+    };
+
+    process.on('SIGINT', this.signalHandler);
+    process.on('SIGTERM', this.signalHandler);
+  }
+
+  private removeSignalHandlers(): void {
+    if (this.signalHandler) {
+      process.removeListener('SIGINT', this.signalHandler);
+      process.removeListener('SIGTERM', this.signalHandler);
+      this.signalHandler = null;
+    }
+  }
+
+  private handleShutdown(): void {
+    if (this.isShuttingDown) {
+      // Already shutting down, force exit on second signal
+      logger.warn('Force exiting...');
+      process.exit(1);
+    }
+
+    this.isShuttingDown = true;
+    this.clearLine();
+    logger.warn('Received interrupt signal, stopping test runs...');
+
+    // Stop all active runs
+    this.stopActiveRuns()
+      .then(() => {
+        logger.info('All test runs have been stopped.');
+        process.exit(1);
+      })
+      .catch((error) => {
+        logger.error(
+          `Failed to stop some test runs: ${error instanceof Error ? error.message : error}`,
+        );
+        process.exit(1);
+      });
+  }
+
+  private async stopActiveRuns(): Promise<void> {
+    if (!this.appId || this.activeRunIds.length === 0) {
+      return;
+    }
+
+    const stopPromises = this.activeRunIds.map((runId) =>
+      this.stopRun(runId).catch((error) => {
+        logger.error(
+          `Failed to stop run ${runId}: ${error instanceof Error ? error.message : error}`,
+        );
+      }),
+    );
+
+    await Promise.all(stopPromises);
+  }
+
+  private async stopRun(runId: number): Promise<void> {
+    if (!this.appId) {
+      return;
+    }
+
+    try {
+      await axios.post(
+        `${this.URL}/${this.appId}/${runId}/stop`,
+        {},
+        {
+          headers: {
+            'User-Agent': utils.getUserAgent(),
+          },
+          auth: {
+            username: this.credentials.userName,
+            password: this.credentials.accessKey,
+          },
+        },
+      );
+
+      if (!this.options.quiet) {
+        logger.info(`  Stopped run ${runId}`);
+      }
+    } catch (error) {
+      throw new TestingBotError(`Failed to stop run ${runId}`, {
+        cause: error,
+      });
+    }
+  }
 }

tests/providers/maestro.test.ts

@@ -1214,4 +1214,115 @@ describe('Maestro', () => {
       });
     });
   });
+
+  describe('Stop Run', () => {
+    beforeEach(() => {
+      maestro['appId'] = 1234;
+    });
+
+    it('should call stop API for a specific run', async () => {
+      axios.post = jest.fn().mockResolvedValue({ data: { success: true } });
+
+      await maestro['stopRun'](5678);
+
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://api.testingbot.com/v1/app-automate/maestro/1234/5678/stop',
+        {},
+        expect.objectContaining({
+          auth: {
+            username: 'testUser',
+            password: 'testKey',
+          },
+        }),
+      );
+    });
+
+    it('should stop multiple active runs', async () => {
+      axios.post = jest.fn().mockResolvedValue({ data: { success: true } });
+      maestro['activeRunIds'] = [5678, 9012];
+
+      await maestro['stopActiveRuns']();
+
+      expect(axios.post).toHaveBeenCalledTimes(2);
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://api.testingbot.com/v1/app-automate/maestro/1234/5678/stop',
+        {},
+        expect.any(Object),
+      );
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://api.testingbot.com/v1/app-automate/maestro/1234/9012/stop',
+        {},
+        expect.any(Object),
+      );
+    });
+
+    it('should not call stop API when no active runs', async () => {
+      axios.post = jest.fn();
+      maestro['activeRunIds'] = [];
+
+      await maestro['stopActiveRuns']();
+
+      expect(axios.post).not.toHaveBeenCalled();
+    });
+
+    it('should not call stop API when appId is not set', async () => {
+      axios.post = jest.fn();
+      maestro['appId'] = undefined;
+      maestro['activeRunIds'] = [5678];
+
+      await maestro['stopActiveRuns']();
+
+      expect(axios.post).not.toHaveBeenCalled();
+    });
+
+    it('should continue stopping other runs when one fails', async () => {
+      axios.post = jest
+        .fn()
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({ data: { success: true } });
+      maestro['activeRunIds'] = [5678, 9012];
+
+      // Should not throw
+      await maestro['stopActiveRuns']();
+
+      expect(axios.post).toHaveBeenCalledTimes(2);
+    });
+
+    it('should filter active run IDs correctly', () => {
+      const runs = [
+        {
+          id: 5678,
+          status: 'WAITING' as const,
+          capabilities: { deviceName: 'Pixel 6', platformName: 'Android' },
+          success: 0,
+        },
+        {
+          id: 9012,
+          status: 'READY' as const,
+          capabilities: { deviceName: 'Pixel 8', platformName: 'Android' },
+          success: 0,
+        },
+        {
+          id: 1111,
+          status: 'DONE' as const,
+          capabilities: { deviceName: 'Pixel 7', platformName: 'Android' },
+          success: 1,
+        },
+        {
+          id: 2222,
+          status: 'FAILED' as const,
+          capabilities: { deviceName: 'Pixel 5', platformName: 'Android' },
+          success: 0,
+        },
+      ];
+
+      // Simulate what waitForCompletion does to track active runs
+      const activeRunIds = runs
+        .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
+        .map((run) => run.id);
+
+      // Only WAITING and READY runs should be tracked
+      expect(activeRunIds).toEqual([5678, 9012]);
+    });
+  });
 });