Jest Equality Matcher For Strings That Disregards Whitespace

Question

Jest's toEqual matcher takes whitespace into account when checking for equality. When formatting the expected value in tests it is impossible to do so in a way that matches a string containing newlines, tabs etc.

Does Jest offer a way to disregard whitespace when matching?

Note: I edited the question to make it more generic.

What does `flatErrorMessage` look like? And what do you test? — Kosh, Jan 25 '18 at 19:40

score 13 · Accepted Answer · edited Feb 09 '21 at 04:08

As @Timo says, the only way of doing this appears to be with a custom matcher. Here is one that compresses all whitespace down to a single space for readability based on Jest's toEqual matcher. It will deal with tabs, newlines etc. It will give you pretty output like the included Jest matchers:

//matchStringIgnoringWhiteSpace.js

import { replace, map, equals } from 'ramda';
import { matcherHint, printReceived, printExpected } from 'jest-matcher-utils';
import diff from 'jest-diff';

const replaceWhitespace = replace(/\s+/g, ` `);
const compressWhitespace = map(replaceWhitespace);

const name = `toEqualWithCompressedWhitespace`;

export default function (received, expected) {
  const [
    receivedWithCompresssedWhitespace,
    expectedWithCompresssedWhitespace,
  ] = compressWhitespace([received, expected]);
  const pass = equals(
    receivedWithCompresssedWhitespace,
    expectedWithCompresssedWhitespace
  );
  const message = pass
    ? () =>
        `${matcherHint(`.not.${name}`)}\n\n` +
        `Uncompressed expected value:\n` +
        `  ${printExpected(expected)}\n` +
        `Expected value with compressed whitespace to not equal:\n` +
        `  ${printExpected(expectedWithCompresssedWhitespace)}\n` +
        `Uncompressed received value:\n` +
        `  ${printReceived(received)}\n` +
        `Received value with compressed whitespace:\n` +
        `  ${printReceived(receivedWithCompresssedWhitespace)}`
    : () => {
        const diffString = diff(
          expectedWithCompresssedWhitespace,
          receivedWithCompresssedWhitespace,
          {
            expand: this.expand,
          }
        );
        return (
          `${matcherHint(`.${name}`)}\n\n` +
          `Uncompressed expected value:\n` +
          `  ${printExpected(expected)}\n` +
          `Expected value with compressed whitespace to equal:\n` +
          `  ${printExpected(expectedWithCompresssedWhitespace)}\n` +
          `Uncompressed received value:\n` +
          `  ${printReceived(received)}\n` +
          `Received value with compressed whitespace:\n` +
          `  ${printReceived(receivedWithCompresssedWhitespace)}${
            diffString ? `\n\nDifference:\n\n${diffString}` : ``
          }`
        );
      };
  return {
    actual: received,
    expected,
    message,
    name,
    pass,
  };
};

To register the custom matcher you need to add it to your setupTests files. First register setupTests in your jest.config.js using the setupFilesAfterEnv field:

 setupFilesAfterEnv: `<rootDir>/path/to/setupTests.js`,

And then register the custom matcher on the expect object.

//setupTests.js

import toMatchStringIgnoringWhitespace from "<rootDir>/path/to/matchStringIgnoringWhiteSpace";

expect.extend({
    toMatchStringIgnoringWhitespace: toMatchStringIgnoringWhitespace
});

If you are using TypeScript you will also want to add the typings to the expect object following the instructions here.

This was super helpful -- only suggested change: `const replaceWhitespace = (str) => str.replace(/\s+/g, ' ').trim()` to account for whitespace at the beginning/end of the strings. — Chance Strickland, Jan 02 '19 at 21:10
Fantastic. I've updated your answer with most recent standard practises. — dwjohnston, Feb 09 '21 at 04:09
Ramda has been a dependency of this snippet since the initial version. — Tr1stan, Feb 23 '22 at 16:12

score 7 · Answer 2 · edited Mar 28 '23 at 14:33

7

As far as I know, there is no way to achieve this with Jest out of the box.

However, you can write your own reusable matcher using expect.extend. Remove all whitespace from both strings, e.g. via str.replace(/\s/g, ''), and compare the strings.

edited Mar 28 '23 at 14:33

Yohan Dahmani

1,670
21
33

answered Jan 25 '18 at 19:41

TimoStaudinger

41,396
16
88
94

score -4 · Answer 3 · answered Apr 13 '20 at 21:36

-4

While this is not a direct answer, you can also do:

mockedFunction.mock.calls[0] // To get array of arguments

// or 

mockedFunction.mock.calls[0][0] // to get first argument and so on

And then compare with equality.

answered Apr 13 '20 at 21:36

Trufa

39,971
43
126
190

Jest Equality Matcher For Strings That Disregards Whitespace

3 Answers3