Add async stack traces for circus

integration-tests/__tests__/__snapshots__/failures.test.js.snap

@@ -144,7 +144,6 @@ exports[`not throwing Error objects 5`] = `
        9 | });
       10 | 
 
-      at packages/jest-jasmine2/build/jasmine/Spec.js:85:20
       at __tests__/during_tests.test.js:7:1
 
   ● Boolean thrown during test
@@ -159,7 +158,6 @@ exports[`not throwing Error objects 5`] = `
       13 |   throw false;
       14 | });
 
-      at packages/jest-jasmine2/build/jasmine/Spec.js:85:20
       at __tests__/during_tests.test.js:11:1
 
   ● undefined thrown during test
@@ -174,7 +172,6 @@ exports[`not throwing Error objects 5`] = `
       18 |   throw undefined;
       19 | });
 
-      at packages/jest-jasmine2/build/jasmine/Spec.js:85:20
       at __tests__/during_tests.test.js:16:1
 
   ● Object thrown during test
@@ -196,7 +193,6 @@ exports[`not throwing Error objects 5`] = `
       23 |   throw deepObject;
       24 | });
 
-      at packages/jest-jasmine2/build/jasmine/Spec.js:85:20
       at __tests__/during_tests.test.js:21:1
 
   ● Error during test
@@ -229,7 +225,7 @@ exports[`not throwing Error objects 5`] = `
 
   ● done(non-error)
 
-    Failed: Object {
+    thrown: Object {
       \\"notAnError\\": Array [
         Object {
           \\"hello\\": true,
@@ -246,12 +242,11 @@ exports[`not throwing Error objects 5`] = `
       38 | 
       39 | test('returned promise rejection', () => {
 
-      at packages/jest-jasmine2/build/jasmine/Env.js:537:34
       at __tests__/during_tests.test.js:36:3
 
   ● returned promise rejection
 
-    Failed: Object {
+    thrown: Object {
       \\"notAnError\\": Array [
         Object {
           \\"hello\\": true,
@@ -268,7 +263,6 @@ exports[`not throwing Error objects 5`] = `
       41 | });
       42 | 
 
-      at packages/jest-jasmine2/build/jasmine_async.js:102:24
       at __tests__/during_tests.test.js:39:1
 
 "

integration-tests/__tests__/failures.test.js

@@ -18,24 +18,31 @@ const normalizeDots = text => text.replace(/\.{1,}$/gm, '.');
 
 SkipOnWindows.suite();
 
+function cleanStderr(stderr) {
+  const {rest} = extractSummary(stderr);
+  return rest
+    .replace(/.*(jest-jasmine2|jest-circus).*\n/g, '')
+    .replace(new RegExp('Failed: Object {', 'g'), 'thrown: Object {');
+}
+
 test('not throwing Error objects', () => {
   let stderr;
   stderr = runJest(dir, ['throw_number.test.js']).stderr;
-  expect(extractSummary(stderr).rest).toMatchSnapshot();
+  expect(cleanStderr(stderr)).toMatchSnapshot();
   stderr = runJest(dir, ['throw_string.test.js']).stderr;
-  expect(extractSummary(stderr).rest).toMatchSnapshot();
+  expect(cleanStderr(stderr)).toMatchSnapshot();
   stderr = runJest(dir, ['throw_object.test.js']).stderr;
-  expect(extractSummary(stderr).rest).toMatchSnapshot();
+  expect(cleanStderr(stderr)).toMatchSnapshot();
   stderr = runJest(dir, ['assertion_count.test.js']).stderr;
-  expect(extractSummary(stderr).rest).toMatchSnapshot();
+  expect(cleanStderr(stderr)).toMatchSnapshot();
   stderr = runJest(dir, ['during_tests.test.js']).stderr;
-  expect(extractSummary(stderr).rest).toMatchSnapshot();
+  expect(cleanStderr(stderr)).toMatchSnapshot();
 });
 
 test('works with node assert', () => {
   const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
   const {stderr} = runJest(dir, ['node_assertion_error.test.js']);
-  let summary = normalizeDots(extractSummary(stderr).rest);
+  let summary = normalizeDots(cleanStderr(stderr));
 
   // Node 9 started to include the error for `doesNotThrow`
   // https://github.com/nodejs/node/pull/12167
@@ -127,7 +134,6 @@ test('works with node assert', () => {
       68 | });
       69 | 
 
-      at packages/jest-jasmine2/build/jasmine/Spec.js:85:20
       at __tests__/node_assertion_error.test.js:66:1
 `;
 
@@ -141,7 +147,7 @@ test('works with node assert', () => {
 test('works with assertions in separate files', () => {
   const {stderr} = runJest(dir, ['test_macro.test.js']);
 
-  expect(normalizeDots(extractSummary(stderr).rest)).toMatchSnapshot();
+  expect(normalizeDots(cleanStderr(stderr))).toMatchSnapshot();
 });
 
 test('works with async failures', () => {
@@ -158,7 +164,7 @@ test('works with async failures', () => {
 test('works with snapshot failures', () => {
   const {stderr} = runJest(dir, ['snapshot.test.js']);
 
-  const result = normalizeDots(extractSummary(stderr).rest);
+  const result = normalizeDots(cleanStderr(stderr));
 
   expect(
     result.substring(0, result.indexOf('Snapshot Summary')),
@@ -168,7 +174,7 @@ test('works with snapshot failures', () => {
 test('works with named snapshot failures', () => {
   const {stderr} = runJest(dir, ['snapshot_named.test.js']);
 
-  const result = normalizeDots(extractSummary(stderr).rest);
+  const result = normalizeDots(cleanStderr(stderr));
 
   expect(
     result.substring(0, result.indexOf('Snapshot Summary')),

packages/jest-circus/package.json

@@ -14,7 +14,8 @@
     "jest-matcher-utils": "^23.0.0",
     "jest-message-util": "^23.0.0",
     "jest-snapshot": "^23.0.0",
-    "jest-util": "^23.0.0"
+    "jest-util": "^23.0.0",
+    "pretty-format": "^23.0.0"
   },
   "devDependencies": {
     "jest-runtime": "^23.0.0"

packages/jest-circus/src/event_handler.js

@@ -43,33 +43,42 @@ const handler: EventHandler = (event, state): void => {
     }
     case 'add_hook': {
       const {currentDescribeBlock} = state;
-      const {fn, hookType: type, timeout} = event;
+      const {asyncError, fn, hookType: type, timeout} = event;
       const parent = currentDescribeBlock;
-      currentDescribeBlock.hooks.push({fn, parent, timeout, type});
+      currentDescribeBlock.hooks.push({asyncError, fn, parent, timeout, type});
       break;
     }
     case 'add_test': {
       const {currentDescribeBlock} = state;
-      const {fn, mode, testName: name, timeout} = event;
-      const test = makeTest(fn, mode, name, currentDescribeBlock, timeout);
-      test.mode === 'only' && (state.hasFocusedTests = true);
+      const {asyncError, fn, mode, testName: name, timeout} = event;
+      const test = makeTest(
+        fn,
+        mode,
+        name,
+        currentDescribeBlock,
+        timeout,
+        asyncError,
+      );
+      if (test.mode === 'only') {
+        state.hasFocusedTests = true;
+      }
       currentDescribeBlock.tests.push(test);
       break;
     }
     case 'hook_failure': {
       const {test, describeBlock, error, hook} = event;
-      const {type} = hook;
+      const {asyncError, type} = hook;
 
       if (type === 'beforeAll') {
         invariant(describeBlock, 'always present for `*All` hooks');
-        addErrorToEachTestUnderDescribe(describeBlock, error);
+        addErrorToEachTestUnderDescribe(describeBlock, error, asyncError);
       } else if (type === 'afterAll') {
         // Attaching `afterAll` errors to each test makes execution flow
         // too complicated, so we'll consider them to be global.
-        state.unhandledErrors.push(error);
+        state.unhandledErrors.push([error, asyncError]);
       } else {
         invariant(test, 'always present for `*Each` hooks');
-        test.errors.push(error);
+        test.errors.push([error, asyncError]);
       }
       break;
     }
@@ -87,7 +96,11 @@ const handler: EventHandler = (event, state): void => {
       break;
     }
     case 'test_fn_failure': {
-      event.test.errors.push(event.error);
+      const {
+        error,
+        test: {asyncError},
+      } = event;
+      event.test.errors.push([error, asyncError]);
       break;
     }
     case 'run_start': {

packages/jest-circus/src/format_node_assert_errors.js

@@ -7,12 +7,13 @@
  * @flow strict-local
  */
 
-import type {DiffOptions} from 'jest-diff/src/diff_strings.js';
+import type {DiffOptions} from 'jest-diff/src/diff_strings';
 import type {Event, State} from 'types/Circus';
 
 import {printExpected, printReceived} from 'jest-matcher-utils';
 import chalk from 'chalk';
 import diff from 'jest-diff';
+import prettyFormat from 'pretty-format';
 
 type AssertionError = {|
   actual: ?string,
@@ -34,31 +35,40 @@ const assertOperatorsMap = {
 const humanReadableOperators = {
   deepEqual: 'to deeply equal',
   deepStrictEqual: 'to deeply and strictly equal',
+  equal: 'to be equal',
   notDeepEqual: 'not to deeply equal',
   notDeepStrictEqual: 'not to deeply and strictly equal',
+  notEqual: 'to not be equal',
+  notStrictEqual: 'not be strictly equal',
+  strictEqual: 'to strictly be equal',
 };
 
 export default (event: Event, state: State) => {
   switch (event.name) {
     case 'test_done': {
-      let assert;
-      try {
-        // Use indirect require so that Metro Bundler does not attempt to
-        // bundle `assert`, which does not exist in React Native.
-        // eslint-disable-next-line no-useless-call
-        assert = require.call(null, 'assert');
-        event.test.errors = event.test.errors.map(error => {
-          return error instanceof assert.AssertionError
-            ? assertionErrorMessage(error, {expand: state.expand})
-            : error;
-        });
-      } catch (error) {
-        // We are running somewhere where `assert` isn't available, like a
-        // browser or React Native. Since assert isn't available, presumably
-        // none of the errors we get through this event listener will be
-        // `AssertionError`s, so we don't need to do anything.
-        break;
-      }
+      event.test.errors = event.test.errors.map(errors => {
+        let error;
+        if (Array.isArray(errors)) {
+          const [originalError, asyncError] = errors;
+
+          if (originalError == null) {
+            error = asyncError;
+          } else if (!originalError.stack) {
+            error = asyncError;
+
+            error.message = originalError.message
+              ? originalError.message
+              : `thrown: ${prettyFormat(originalError, {maxDepth: 3})}`;
+          } else {
+            error = originalError;
+          }
+        } else {
+          error = errors;
+        }
+        return error.code === 'ERR_ASSERTION'
+          ? {message: assertionErrorMessage(error, {expand: state.expand})}
+          : errors;
+      });
     }
   }
 };
@@ -76,12 +86,15 @@ const getOperatorName = (operator: ?string, stack: string) => {
   return '';
 };
 
-const operatorMessage = (operator: ?string, negator: boolean) =>
-  typeof operator === 'string'
-    ? operator.startsWith('!') || operator.startsWith('=')
-      ? `${negator ? 'not ' : ''}to be (operator: ${operator}):\n`
-      : `${humanReadableOperators[operator] || operator} to:\n`
+const operatorMessage = (operator: ?string) => {
+  const niceOperatorName = getOperatorName(operator, '');
+  // $FlowFixMe: we default to the operator itself, so holes in the map doesn't matter
+  const humanReadableOperator = humanReadableOperators[niceOperatorName];
+
+  return typeof operator === 'string'
+    ? `${humanReadableOperator || niceOperatorName} to:\n`
     : '';
+};
 
 const assertThrowingMatcherHint = (operatorName: string) => {
   return (
@@ -114,13 +127,13 @@ const assertMatcherHint = (operator: ?string, operatorName: string) => {
 };
 
 function assertionErrorMessage(error: AssertionError, options: DiffOptions) {
-  const {expected, actual, message, operator, stack} = error;
+  const {expected, actual, generatedMessage, message, operator, stack} = error;
   const diffString = diff(expected, actual, options);
-  const negator =
-    typeof operator === 'string' &&
-    (operator.startsWith('!') || operator.startsWith('not'));
-  const hasCustomMessage = !error.generatedMessage;
+  const hasCustomMessage = !generatedMessage;
   const operatorName = getOperatorName(operator, stack);
+  const trimmedStack = stack
+    .replace(message, '')
+    .replace(/AssertionError(.*)/g, '');
 
   if (operatorName === 'doesNotThrow') {
     return (
@@ -130,7 +143,7 @@ function assertionErrorMessage(error: AssertionError, options: DiffOptions) {
       chalk.reset(`Instead, it threw:\n`) +
       `  ${printReceived(actual)}` +
       chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
-      stack.replace(/AssertionError(.*)/g, '')
+      trimmedStack
     );
   }
 
@@ -141,19 +154,19 @@ function assertionErrorMessage(error: AssertionError, options: DiffOptions) {
       chalk.reset(`Expected the function to throw an error.\n`) +
       chalk.reset(`But it didn't throw anything.`) +
       chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
-      stack.replace(/AssertionError(.*)/g, '')
+      trimmedStack
     );
   }
 
   return (
     assertMatcherHint(operator, operatorName) +
     '\n\n' +
-    chalk.reset(`Expected value ${operatorMessage(operator, negator)}`) +
+    chalk.reset(`Expected value ${operatorMessage(operator)}`) +
     `  ${printExpected(expected)}\n` +
     chalk.reset(`Received:\n`) +
     `  ${printReceived(actual)}` +
     chalk.reset(hasCustomMessage ? '\n\nMessage:\n  ' + message : '') +
     (diffString ? `\n\nDifference:\n\n${diffString}` : '') +
-    stack.replace(/AssertionError(.*)/g, '')
+    trimmedStack
   );
 }