Fixed #2582 - making sure the test results are not discarded when an …

…uncaught exception occurs.

lib/runner/process-listener.js

@@ -45,40 +45,25 @@ module.exports = class {
     this.uncaught(err);
   }
 
-  getCurrentPromise(err) {
+  async getCurrentPromise(err) {
     if (this.testRunner && this.testRunner.currentSuite) {
       this.testRunner.registerUncaughtErr(err);
       this.testRunner.currentSuite.emptyQueue();
 
-      return new Promise((resolve) => {
-        let runnable = this.testRunner.currentSuite.currentRunnable;
-
-        if (runnable) {
-          runnable.abort(err).then(_ => resolve());
-        } else {
-          resolve();
-        }
-      }).then(_ => {
-        if (this.testRunner.publishReport) {
-          this.testRunner.publishReport = false;
-
-          return Promise.all([
-            this.testRunner.closeOpenSessions(),
-            this.testRunner.reportResults()
-          ]).catch(err => {
-            this.testRunner.registerUncaughtErr(err);
-
-            return err;
-          });
-        }
-
-        return Promise.resolve();
-      });
+      const {currentRunnable} = this.testRunner.currentSuite;
+      if (currentRunnable) {
+        await currentRunnable.abort(err);
+      }
+
+      await this.testRunner.closeOpenSessions();
+
+      if (this.testRunner.publishReport) {
+        this.testRunner.publishReport = false;
+        await this.testRunner.reportResults();
+      }
     } else {
       Logger.error(err);
     }
-
-    return Promise.resolve();
   }
 
   uncaught(err) {

test/sampletests/withuncaughterrors/demoTestFine.js

@@ -0,0 +1,13 @@
+describe('passing test', function () {
+
+  this.tags = ['uncaught-error'];
+
+  test('demo Test Passing', function (client) {
+    client
+      .url('http://localhost')
+      .assert.elementPresent('#weblogin')
+      .waitForElementPresent('#weblogin')
+  });
+
+});
+

test/sampletests/withuncaughterrors/demoTestWithError.js

@@ -0,0 +1,20 @@
+describe('test with uncaught error', function () {
+
+  this.tags = ['uncaught-error'];
+
+  test('Passing test step', function (client) {
+    client
+      .url('http://localhost')
+      .assert.elementPresent('#weblogin');
+  });
+
+  test('Uncaught error test step', function (client) {
+    client.assert.elementPresent('#weblogin');
+
+    setTimeout(function () {
+      throw new Error('Test Error Uncaught');
+    }, 25);
+  });
+
+});
+

test/src/runner/cli/testParallelExecution.js

@@ -94,7 +94,7 @@ describe('test Parallel Execution', function() {
     assert.ok(runner.test_settings.test_workers);
 
     return runner.runTests().then(_ => {
-      assert.strictEqual(allArgs.length, 49);
+      assert.strictEqual(allArgs.length, 51);
       assert.strictEqual(runner.concurrency.globalExitCode, 0);
     });
   });
@@ -136,7 +136,7 @@ describe('test Parallel Execution', function() {
     });
 
     return runner.runTests().then(_ => {
-      assert.strictEqual(allArgs.length, 49);
+      assert.strictEqual(allArgs.length, 51);
     });
   });
 
@@ -159,13 +159,13 @@ describe('test Parallel Execution', function() {
     });
 
     runner.setup();
-    assert.deepEqual(runner.test_settings.test_workers, {
+    assert.deepStrictEqual(runner.test_settings.test_workers, {
       enabled: true,
       workers: 6
     });
 
     return runner.runTests().then(_ => {
-      assert.strictEqual(allArgs.length, 49);
+      assert.strictEqual(allArgs.length, 51);
     });
   });
 

test/src/runner/testRunnerUncaughtErrors.js

@@ -0,0 +1,87 @@
+const path = require('path');
+const assert = require('assert');
+const common = require('../../common.js');
+const MockServer = require('../../lib/mockserver.js');
+const NightwatchClient = common.require('index.js');
+
+describe('testRunWithUncaughtErrors', function() {
+
+  before(function(done) {
+    this.server = MockServer.init();
+    this.server.on('listening', () => {
+      done();
+    });
+  });
+
+  after(function(done) {
+    this.server.close(function() {
+      done();
+    });
+  });
+
+  beforeEach(function() {
+    process.removeAllListeners('exit');
+    process.removeAllListeners('uncaughtException');
+    process.removeAllListeners('unhandledRejection');
+  });
+
+  it('test runner with uncaught exception', function(done) {
+    let testsPath = path.join(__dirname, '../../sampletests/withuncaughterrors');
+    let errorReported = false;
+    let testErr;
+
+    let globals = {
+      reporter(results) {
+        if (results.errmessages.length) {
+          errorReported = true;
+          try {
+            assert.strictEqual(typeof results.modules.demoTestFine, 'object');
+            assert.strictEqual(typeof results.modules.demoTestWithError, 'object');
+            assert.strictEqual(results.passed, 4);
+            assert.strictEqual(results.errors, 1);
+            assert.strictEqual(results.assertions, 4);
+            assert.strictEqual(results.modules.demoTestFine.assertionsCount, 2);
+            assert.strictEqual(results.modules.demoTestFine.passedCount, 2);
+            assert.strictEqual(results.modules.demoTestWithError.assertionsCount, 2);
+            assert.strictEqual(results.modules.demoTestWithError.passedCount, 2);
+            assert.ok(results.errmessages[0].includes('Error: Test Error Uncaught'));
+          } catch (e) {
+            testErr = e;
+          }
+        }
+      }
+    };
+
+
+    const orig = process.exit;
+    process.exit = function(code) {};
+
+    NightwatchClient.runTests(testsPath, {
+      selenium: {
+        port: 10195,
+        version2: true,
+        start_process: true
+      },
+      output: true,
+      silent: false,
+      persist_globals: true,
+      globals: globals,
+      output_folder: false
+    });
+
+    setTimeout(function () {
+      process.exit = orig;
+      try {
+        if (testErr) {
+          done(testErr);
+          return;
+        }
+
+        assert.strictEqual(errorReported, true);
+        done();
+      } catch (e) {
+        done(e);
+      }
+    }, 500);
+  });
+});