Add showStack option

Author: mattphillips

README.md

@@ -134,9 +134,10 @@ Custom message [example](/example) with typescript
 - `expect(actual, message, options?)`
   - `actual`: The value you would normally pass into an `expect` to assert against with a given matcher.
   - `message`: String, the custom message you want to be printed should the `expect` fail.
-  - `options`: An optional object that controls if the custom message prefix and/or if the original matcher message are shown.
-    - type: `{ showPrefix: boolean, showMatcherMessage: boolean }`
-    - Note: `options` is optional and so are both `showPrefix` and `showMatcherMessage` which will be defaulted to `true`.
+  - `options`: An optional object that controls what is shown as part of the custom message.
+    - `showPrefix: boolean`: If `false` will not show the `Custom message:` prefix. Default: `true`
+    - `showMatcherMessage: boolean`: If `false` will not show the matchers original error message. Default: `true`
+    - `showStack: boolean`: If `false` will not show the matchers stack trace. Default: `true`
 
 ```js
 test('returns 2 when adding 1 and 1', () => {
@@ -153,10 +154,15 @@ test('returns 2 when adding 1 and 1', () => {
 
     Expected: 3
     Received: 2
+
+  1 |   test('returns 2 when adding 1 and 1', () => {
+> 2 |     expect(1 + 1, 'Woah this should be 2!').toBe(3);
+    |                                             ^
+  3 |   });
 */
 ```
 
-### ShowPrefix false
+### showPrefix: `false`
 
 ```js
 test('returns 2 when adding 1 and 1', () => {
@@ -172,10 +178,15 @@ test('returns 2 when adding 1 and 1', () => {
 
     Expected: 3
     Received: 2
+
+  1 |   test('returns 2 when adding 1 and 1', () => {
+> 2 |     expect(1 + 1, 'Woah this should be 2!', { showPrefix: false }).toBe(3);
+    |                                                                    ^
+  3 |   });
 */
 ```
 
-### ShowMatcherMessage false
+### showMatcherMessage: `false`
 
 ```js
 test('returns 2 when adding 1 and 1', () => {
@@ -187,6 +198,31 @@ test('returns 2 when adding 1 and 1', () => {
 
     Custom message:
       Woah this should be 2!
+
+  1 |   test('returns 2 when adding 1 and 1', () => {
+> 2 |     expect(1 + 1, 'Woah this should be 2!', { showMatcherMessage: false }).toBe(3);
+    |                                                                            ^
+  3 |   });
+*/
+```
+
+### showStack: `false`
+
+```js
+test('returns 2 when adding 1 and 1', () => {
+  expect(1 + 1, 'Woah this should be 2!', { showStack: false }).toBe(3);
+});
+// ↓ ↓ ↓ ↓ ↓ ↓
+/*
+  ● returns 2 when adding 1 and 1
+
+    Custom message:
+      Woah this should be 2!
+
+    expect(received).toBe(expected) // Object.is equality
+
+    Expected: 3
+    Received: 2
 */
 ```
 

src/withMessage.js

@@ -29,8 +29,13 @@ const wrapMatcher = (matcher, customMessage, config) => {
       const messagePrefix = config.showPrefix ? 'Custom message:\n  ' : '';
 
       const message = () => messagePrefix + customMessage + (config.showMatcherMessage ? '\n\n' + matcherMessage : '');
+      const e = new JestAssertionError({ ...matcherResult, message }, newMatcher);
 
-      throw new JestAssertionError({ ...matcherResult, message }, newMatcher);
+      if (!config.showStack) {
+        e.stack = null;
+      }
+
+      throw e;
     }
   };
   return newMatcher;
@@ -56,7 +61,8 @@ export default (expect) => {
     (actual, customMessage, options = {}) => {
       const config = {
         showMatcherMessage: typeof options.showMatcherMessage === 'boolean' ? options.showMatcherMessage : true,
-        showPrefix: typeof options.showPrefix === 'boolean' ? options.showPrefix : true
+        showPrefix: typeof options.showPrefix === 'boolean' ? options.showPrefix : true,
+        showStack: typeof options.showStack === 'boolean' ? options.showStack : true
       };
       let matchers = expect(actual); // partially apply expect to get all matchers and chain them
       if (customMessage) {

src/withMessage.test.js

@@ -158,7 +158,7 @@ describe('withMessage()', () => {
   });
 
   test('does not throw error with matcher message when `config.showMatcherMessage` is false', () => {
-    expect.assertions(2);
+    expect.assertions(3);
     const originalError = new Error('Boo');
     const matcherMessage = 'expected ACTUAL to not be ACTUAL';
     originalError.matcherResult = {
@@ -176,13 +176,14 @@ describe('withMessage()', () => {
     try {
       withMessage(expectMock)(ACTUAL, customMessage, { showMatcherMessage: false }).toBe(1);
     } catch (e) {
+      expect(e.stack).not.toBe(null);
       expect(e.message).toInclude(customMessage);
       expect(e.message).not.toInclude(matcherMessage);
     }
   });
 
   test('does not throw error with custom message prefix when `config.showPrefix` is false', () => {
-    expect.assertions(3);
+    expect.assertions(4);
     const originalError = new Error('Boo');
     const matcherMessage = 'expected ACTUAL to not be ACTUAL';
     originalError.matcherResult = {
@@ -200,14 +201,15 @@ describe('withMessage()', () => {
     try {
       withMessage(expectMock)(ACTUAL, customMessage, { showPrefix: false }).toBe(1);
     } catch (e) {
+      expect(e.stack).not.toBe(null);
       expect(e.message).not.toInclude('Custom message:\n');
       expect(e.message).toInclude(customMessage);
       expect(e.message).toInclude(matcherMessage);
     }
   });
 
   test('throws error containing only custom message prefix when `config.showPrefix` and `config.showMatcherMessage` are false', () => {
-    expect.assertions(3);
+    expect.assertions(4);
     const originalError = new Error('Boo');
     const matcherMessage = 'expected ACTUAL to not be ACTUAL';
     originalError.matcherResult = {
@@ -225,9 +227,36 @@ describe('withMessage()', () => {
     try {
       withMessage(expectMock)(ACTUAL, customMessage, { showPrefix: false, showMatcherMessage: false }).toBe(1);
     } catch (e) {
+      expect(e.stack).not.toBe(null);
       expect(e.message).not.toInclude('Custom message:\n');
       expect(e.message).not.toInclude(matcherMessage);
       expect(e.message).toInclude(customMessage);
     }
   });
+
+  test('throws error with empty stack when `config.showStack` is false', () => {
+    expect.assertions(4);
+    const originalError = new Error('Boo');
+    const matcherMessage = 'expected ACTUAL to not be ACTUAL';
+    originalError.matcherResult = {
+      actual: ACTUAL,
+      expected: 1,
+      message: matcherMessage,
+      pass: false
+    };
+    const toBeMock = jest.fn(() => {
+      throw originalError;
+    });
+    const expectMock = jest.fn(() => ({ toBe: toBeMock }));
+
+    const customMessage = 'should fail';
+    try {
+      withMessage(expectMock)(ACTUAL, customMessage, { showStack: false }).toBe(1);
+    } catch (e) {
+      expect(e.stack).toBe(null);
+      expect(e.message).toInclude('Custom message:\n');
+      expect(e.message).toInclude(matcherMessage);
+      expect(e.message).toInclude(customMessage);
+    }
+  });
 });

types/index.d.ts

@@ -3,7 +3,7 @@ declare namespace jest {
     <T = any>(
       actual: T,
       message?: string,
-      options?: { showMatcherMessage?: boolean; showPrefix?: boolean }
+      options?: { showMatcherMessage?: boolean; showPrefix?: boolean; showStack?: boolean }
     ): Matchers<T>;
   }
 }