Parallel: Report unhandled exceptions/rejections between spec files

Author: sgravrock

bin/worker.js

@@ -2,5 +2,8 @@ const cluster = require('node:cluster');
 const ParallelWorker = require('../lib/parallel_worker');
 const Loader = require('../lib/loader');
 
-const loader = new Loader();
-new ParallelWorker({loader, clusterWorker: cluster.worker});
+new ParallelWorker({
+  loader: new Loader(),
+  process,
+  clusterWorker: cluster.worker
+});

lib/parallel_runner.js

@@ -322,6 +322,16 @@ class ParallelRunner extends RunnerBase {
             runNextSpecFile();
             break;
 
+          case 'uncaughtException':
+            this.addTopLevelError_('lateError',
+              'Uncaught exception in worker process', msg.error);
+            break;
+
+          case 'unhandledRejection':
+            this.addTopLevelError_('lateError',
+              'Unhandled promise rejection in worker process', msg.error);
+            break;
+
           case 'reporterEvent':
             this.handleReporterEvent_(msg.eventName, msg.payload);
             break;
@@ -421,6 +431,19 @@ class ParallelRunner extends RunnerBase {
       );
     });
   }
+
+  addTopLevelError_(type, msgPrefix, serializedError) {
+    // Match how jasmine-core reports these in non-parallel situations
+    this.executionState_.failedExpectations.push({
+      actual: '',
+      expected: '',
+      globalErrorType: 'lateError',
+      matcherName: '',
+      message: `${msgPrefix}: ${serializedError.message}`,
+      passed: false,
+      stack: serializedError.stack,
+    });
+  }
 }
 
 function formatErrorFromWorker(error) {

lib/parallel_worker.js

@@ -19,6 +19,29 @@ class ParallelWorker {
           console.error('Jasmine worker got an unrecognized message:', msg);
       }
     });
+
+    // Install global error handlers now, before jasmine-core is booted.
+    // That allows jasmine-core to override them with its own more specific
+    // handling. These handlers will take care of errors that occur in between
+    // spec files.
+    for (const errorType of ['uncaughtException', 'unhandledRejection']) {
+      options.process.on(errorType, error => {
+        if (this.clusterWorker_.isConnected()) {
+          this.clusterWorker_.send({
+            type: errorType,
+            error: serializeError(error)
+          });
+        } else {
+          // Don't try to report errors after disconnect. If we do, it'll cause
+          // another unhandled exception. The resulting error-and-reporting loop
+          // can keep the runner from finishing.
+          console.error(`${errorType} in Jasmine worker process after disconnect:`, error);
+          console.error('This error cannot be reported properly because it ' +
+            'happened after the worker process was disconnected.'
+          );
+        }
+      });
+    }
   }
 
   configure(options) {

spec/parallel_runner_spec.js

@@ -655,6 +655,74 @@ describe('ParallelRunner', function() {
       }
     });
 
+    it('reports unhandled exceptions and promise rejections from workers', async function() {
+      this.testJasmine.numWorkers = 2;
+      this.testJasmine.loadConfig({
+        spec_dir: 'some/spec/dir'
+      });
+      this.testJasmine.addSpecFile('spec1.js');
+      this.testJasmine.addSpecFile('spec2.js');
+      const executePromise = this.testJasmine.execute();
+      await this.emitAllBooted();
+
+      await new Promise(resolve => setTimeout(resolve));
+      this.emitFileDone(this.cluster.workers[0], {
+        failedExpectations: ['failed expectation 1'],
+        deprecationWarnings: [],
+      });
+      this.cluster.workers[0].emit('message', {
+        type: 'uncaughtException',
+        error: {
+          message: 'not caught',
+          stack: 'it happened here'
+        },
+      });
+      this.cluster.workers[0].emit('message', {
+        type: 'unhandledRejection',
+        error: {
+          message: 'not handled',
+          stack: 'it happened there'
+        },
+      });
+      this.emitFileDone(this.cluster.workers[1], {
+        failedExpectations: ['failed expectation 2'],
+        deprecationWarnings: [''],
+      });
+
+      await this.disconnect();
+      await executePromise;
+
+      expect(this.consoleReporter.jasmineDone).toHaveBeenCalledWith(
+        jasmine.objectContaining({
+          overallStatus: 'failed',
+          failedExpectations: [
+            'failed expectation 1',
+            // We don't just pass these through from jasmine-core,
+            // so verify the actual output format.
+            {
+              actual: '',
+              expected: '',
+              globalErrorType: 'lateError',
+              matcherName: '',
+              message: 'Uncaught exception in worker process: not caught',
+              passed: false,
+              stack: 'it happened here',
+            },
+            {
+              actual: '',
+              expected: '',
+              globalErrorType: 'lateError',
+              matcherName: '',
+              message: 'Unhandled promise rejection in worker process: not handled',
+              passed: false,
+              stack: 'it happened there',
+            },
+            'failed expectation 2',
+          ],
+        })
+      );
+    });
+
     it('handles errors from reporters', async function() {
       const reportDispatcher = new StubParallelReportDispatcher();
       spyOn(reportDispatcher, 'installGlobalErrors');