jest-jasmine2: pretty-print non-Error errors

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

@@ -68,6 +68,55 @@ exports[`not throwing Error objects 4`] = `
 "
 `;
 
+exports[`not throwing Error objects 5`] = `
+"FAIL __tests__/during_tests.test.js
+  ✕ Promise thrown during test
+  ✕ Boolean thrown during test
+  ✕ undefined thrown during test
+  ✕ Object thrown during test
+  ✕ Error during test
+
+  ● Promise thrown during test
+
+    thrown: Promise {}
+      
+      at packages/jest-jasmine2/build/expectation_result_factory.js:42:47
+
+  ● Boolean thrown during test
+
+    thrown: false
+      
+      at packages/jest-jasmine2/build/expectation_result_factory.js:42:47
+
+  ● undefined thrown during test
+
+    thrown: undefined
+      
+      at packages/jest-jasmine2/build/expectation_result_factory.js:42:47
+
+  ● Object thrown during test
+
+    thrown: Object {
+      \\"notAnError\\": true,
+    }
+      
+      at packages/jest-jasmine2/build/expectation_result_factory.js:42:47
+
+  ● Error during test
+
+    ReferenceError: doesNotExist is not defined
+
+      18 | 
+      19 | test('Error during test', () => {
+    > 20 |   doesNotExist.alsoThisNot;
+      21 | });
+      22 | 
+      
+      at __tests__/during_tests.test.js:20:3
+
+"
+`;
+
 exports[`works with assertions in separate files 1`] = `
 "FAIL __tests__/test_macro.test.js
   ✕ use some imported macro to make assertion
@@ -142,7 +191,7 @@ exports[`works with node assert 1`] = `
 
   ● assert
 
-    assert.equal(received, expected) or assert(received) 
+    thrown: \\"assert.equal(received, expected) or assert(received) 
     
     Expected value to be (operator: ==):
       true
@@ -160,7 +209,7 @@ exports[`works with node assert 1`] = `
 
   ● assert with a message
 
-    assert.equal(received, expected) or assert(received) 
+    thrown: \\"assert.equal(received, expected) or assert(received) 
     
     Expected value to be (operator: ==):
       true
@@ -181,7 +230,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.ok
 
-    assert.equal(received, expected) or assert(received) 
+    thrown: \\"assert.equal(received, expected) or assert(received) 
     
     Expected value to be (operator: ==):
       true
@@ -199,7 +248,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.ok with a message
 
-    assert.equal(received, expected) or assert(received) 
+    thrown: \\"assert.equal(received, expected) or assert(received) 
     
     Expected value to be (operator: ==):
       true
@@ -220,7 +269,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.equal
 
-    assert.equal(received, expected) or assert(received) 
+    thrown: \\"assert.equal(received, expected) or assert(received) 
     
     Expected value to be (operator: ==):
       2
@@ -238,7 +287,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.notEqual
 
-    assert.notEqual(received, expected)
+    thrown: \\"assert.notEqual(received, expected)
     
     Expected value not to be (operator: !=):
       1
@@ -260,23 +309,23 @@ exports[`works with node assert 1`] = `
 
   ● assert.deepEqual
 
-    assert.deepEqual(received, expected)
+    thrown: \\"assert.deepEqual(received, expected)
     
     Expected value to deeply equal to:
-      {\\"a\\": {\\"b\\": {\\"c\\": 6}}}
+      {\\\\\\"a\\\\\\": {\\\\\\"b\\\\\\": {\\\\\\"c\\\\\\": 6}}}
     Received:
-      {\\"a\\": {\\"b\\": {\\"c\\": 5}}}
+      {\\\\\\"a\\\\\\": {\\\\\\"b\\\\\\": {\\\\\\"c\\\\\\": 5}}}
     
     Difference:
     
     - Expected
     + Received
     
       Object {
-        \\"a\\": Object {
-          \\"b\\": Object {
-    -       \\"c\\": 6,
-    +       \\"c\\": 5,
+        \\\\\\"a\\\\\\": Object {
+          \\\\\\"b\\\\\\": Object {
+    -       \\\\\\"c\\\\\\": 6,
+    +       \\\\\\"c\\\\\\": 5,
           },
         },
       }
@@ -292,12 +341,12 @@ exports[`works with node assert 1`] = `
 
   ● assert.deepEqual with a message
 
-    assert.deepEqual(received, expected)
+    thrown: \\"assert.deepEqual(received, expected)
     
     Expected value to deeply equal to:
-      {\\"a\\": {\\"b\\": {\\"c\\": 7}}}
+      {\\\\\\"a\\\\\\": {\\\\\\"b\\\\\\": {\\\\\\"c\\\\\\": 7}}}
     Received:
-      {\\"a\\": {\\"b\\": {\\"c\\": 5}}}
+      {\\\\\\"a\\\\\\": {\\\\\\"b\\\\\\": {\\\\\\"c\\\\\\": 5}}}
     
     Message:
       this is a message
@@ -308,10 +357,10 @@ exports[`works with node assert 1`] = `
     + Received
     
       Object {
-        \\"a\\": Object {
-          \\"b\\": Object {
-    -       \\"c\\": 7,
-    +       \\"c\\": 5,
+        \\\\\\"a\\\\\\": Object {
+          \\\\\\"b\\\\\\": Object {
+    -       \\\\\\"c\\\\\\": 7,
+    +       \\\\\\"c\\\\\\": 5,
           },
         },
       }
@@ -327,12 +376,12 @@ exports[`works with node assert 1`] = `
 
   ● assert.notDeepEqual
 
-    assert.notDeepEqual(received, expected)
+    thrown: \\"assert.notDeepEqual(received, expected)
     
     Expected value not to deeply equal to:
-      {\\"a\\": 1}
+      {\\\\\\"a\\\\\\": 1}
     Received:
-      {\\"a\\": 1}
+      {\\\\\\"a\\\\\\": 1}
     
     Difference:
     
@@ -349,7 +398,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.strictEqual
 
-    assert.strictEqual(received, expected)
+    thrown: \\"assert.strictEqual(received, expected)
     
     Expected value to be (operator: ===):
       NaN
@@ -367,7 +416,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.notStrictEqual
 
-    assert.notStrictEqual(received, expected)
+    thrown: \\"assert.notStrictEqual(received, expected)
     
     Expected value not to be (operator: !==):
       1
@@ -392,21 +441,21 @@ exports[`works with node assert 1`] = `
 
   ● assert.deepStrictEqual
 
-    assert.deepStrictEqual(received, expected)
+    thrown: \\"assert.deepStrictEqual(received, expected)
     
     Expected value to deeply and strictly equal to:
-      {\\"a\\": 2}
+      {\\\\\\"a\\\\\\": 2}
     Received:
-      {\\"a\\": 1}
+      {\\\\\\"a\\\\\\": 1}
     
     Difference:
     
     - Expected
     + Received
     
       Object {
-    -   \\"a\\": 2,
-    +   \\"a\\": 1,
+    -   \\\\\\"a\\\\\\": 2,
+    +   \\\\\\"a\\\\\\": 1,
       }
 
       57 | 
@@ -420,12 +469,12 @@ exports[`works with node assert 1`] = `
 
   ● assert.notDeepStrictEqual
 
-    assert.notDeepStrictEqual(received, expected)
+    thrown: \\"assert.notDeepStrictEqual(received, expected)
     
     Expected value not to deeply and strictly equal to:
-      {\\"a\\": 1}
+      {\\\\\\"a\\\\\\": 1}
     Received:
-      {\\"a\\": 1}
+      {\\\\\\"a\\\\\\": 1}
     
     Difference:
     
@@ -442,12 +491,13 @@ exports[`works with node assert 1`] = `
 
   ● assert.ifError
 
-    Error
-      1 thrown
+    thrown: 1
+      
+      at packages/jest-jasmine2/build/expectation_result_factory.js:42:47
 
   ● assert.doesNotThrow
 
-    assert.doesNotThrow(function)
+    thrown: \\"assert.doesNotThrow(function)
     
     Expected the function not to throw an error.
     Instead, it threw:
@@ -467,7 +517,7 @@ exports[`works with node assert 1`] = `
 
   ● assert.throws
 
-    assert.throws(function)
+    thrown: \\"assert.throws(function)
     
     Expected the function to throw an error.
     But it didn't throw anything.

integration-tests/__tests__/failures.test.js

@@ -52,6 +52,8 @@ test('not throwing Error objects', () => {
   expect(extractSummary(stderr).rest).toMatchSnapshot();
   stderr = runJest(dir, ['assertion_count.test.js']).stderr;
   expect(extractSummary(cleanupStackTrace(stderr)).rest).toMatchSnapshot();
+  stderr = runJest(dir, ['during_tests.test.js']).stderr;
+  expect(extractSummary(stderr).rest).toMatchSnapshot();
 });
 
 test('works with node assert', () => {
@@ -63,23 +65,23 @@ test('works with node assert', () => {
   if (Number(process.versions.node.split('.')[0]) >= 9) {
     expect(summary).toContain(`
     assert.doesNotThrow(function)
-    
+
     Expected the function not to throw an error.
     Instead, it threw:
       [Error: err!]
-    
+
     Message:
       Got unwanted exception.
     err!
     err!
 
-      69 | 
+      69 |
       70 | test('assert.doesNotThrow', () => {
     > 71 |   assert.doesNotThrow(() => {
       72 |     throw Error('err!');
       73 |   });
       74 | });
-      
+
       at __tests__/node_assertion_error.test.js:71:10
 `);
 

integration-tests/failures/__tests__/during_tests.test.js

@@ -0,0 +1,25 @@
+'use strict';
+
+test('Promise thrown during test', () => {
+  throw Promise.resolve(5);
+});
+
+test('Boolean thrown during test', () => {
+  // eslint-disable-next-line no-throw-literal
+  throw false;
+});
+
+test('undefined thrown during test', () => {
+  // eslint-disable-next-line no-throw-literal
+  throw undefined;
+});
+
+test('Object thrown during test', () => {
+  // eslint-disable-next-line no-throw-literal
+  throw {notAnError: true};
+});
+
+test('Error during test', () => {
+  // eslint-disable-next-line no-undef
+  doesNotExist.alsoThisNot;
+});

packages/jest-jasmine2/package.json

@@ -18,7 +18,8 @@
     "jest-message-util": "^22.4.0",
     "jest-snapshot": "^22.4.0",
     "jest-util": "^22.4.1",
-    "source-map-support": "^0.5.0"
+    "source-map-support": "^0.5.0",
+    "pretty-format": "^22.4.0"
   },
   "devDependencies": {
     "jest-runtime": "^22.4.2"

packages/jest-jasmine2/src/expectation_result_factory.js

@@ -7,26 +7,24 @@
  * @flow
  */
 
+import prettyFormat from 'pretty-format';
+
 function messageFormatter({error, message, passed}) {
   if (passed) {
     return 'Passed.';
   }
   if (message) {
     return message;
   }
-  if (!error) {
-    return '';
-  }
-  return error.message && error.name
-    ? `${error.name}: ${error.message}`
-    : `${error.toString()} thrown`;
+  return `thrown: ${prettyFormat(error, {maxDepth: 3})}`;
 }
 
 function stackFormatter(options, errorMessage) {
   if (options.passed) {
     return '';
   }
-  const {stack} = options.error || new Error(errorMessage);
+  const stack =
+    (options.error && options.error.stack) || new Error(errorMessage).stack;
   return stack;
 }