Do not highlight matched asymmetricMatcher in diffs

CHANGELOG.md

@@ -65,6 +65,8 @@
 - `[jest-utils]` Allow querying process.domain ([#9136](https://github.com/facebook/jest/pull/9136))
 - `[pretty-format]` Correctly detect memoized elements ([#9196](https://github.com/facebook/jest/pull/9196))
 - `[jest-fake-timers]` Support `util.promisify` on `setTimeout` ([#9180](https://github.com/facebook/jest/pull/9180))
+- `[jest-diff]` Do not highlight matched asymmetricMatcher in diffs ([#9257](https://github.com/facebook/jest/pull/9257))
+- `[jest-util]` Use `new` to `deepCyclicCopy` RegExp. Fix error of calling method after copied by `Object.create` ([#9257](https://github.com/facebook/jest/pull/9257))
 
 ### Chore & Maintenance
 

packages/expect/src/__tests__/__snapshots__/matchers.test.js.snap

@@ -364,6 +364,9 @@ exports[`.toBe() fails for: {"a": [Function a], "b": 2} and {"a": Any<Function>,
 
 <d>If it should pass with deep equality, replace "toBe" with "toStrictEqual"</>
 
+<d>Compared values serialize to the same structure.</>
+<d>Printing internal object structure without calling \`toJSON\` instead.</>
+
 <g>- Expected  - 1</>
 <r>+ Received  + 1</>
 

packages/jest-diff/package.json

@@ -13,6 +13,7 @@
     "chalk": "^3.0.0",
     "diff-sequences": "^24.9.0",
     "jest-get-type": "^24.9.0",
+    "jest-util": "^24.9.0",
     "pretty-format": "^24.9.0"
   },
   "devDependencies": {

packages/jest-diff/src/__tests__/diff.test.ts

@@ -192,24 +192,104 @@ line 4`;
 });
 
 describe('objects', () => {
-  const a = {a: {b: {c: 5}}};
-  const b = {a: {b: {c: 6}}};
-  const expected = [
-    '  Object {',
-    '    "a": Object {',
-    '      "b": Object {',
-    '-       "c": 5,',
-    '+       "c": 6,',
-    '      },',
-    '    },',
-    '  }',
-  ].join('\n');
+  describe('expand', () => {
+    const a = {a: {b: {c: 5}}};
+    const b = {a: {b: {c: 6}}};
+    const expected = [
+      '  Object {',
+      '    "a": Object {',
+      '      "b": Object {',
+      '-       "c": 5,',
+      '+       "c": 6,',
+      '      },',
+      '    },',
+      '  }',
+    ].join('\n');
 
-  test('(unexpanded)', () => {
-    expect(diff(a, b, unexpandedBe)).toBe(expected);
+    test('(unexpanded)', () => {
+      expect(diff(a, b, unexpandedBe)).toBe(expected);
+    });
+    test('(expanded)', () => {
+      expect(diff(a, b, expandedBe)).toBe(expected);
+    });
   });
-  test('(expanded)', () => {
-    expect(diff(a, b, expandedBe)).toBe(expected);
+
+  describe('asymmetricMatcher', () => {
+    test('jest asymmetricMatcher', () => {
+      const a = {
+        a: expect.any(Number),
+        b: expect.anything(),
+        c: expect.arrayContaining([1, 3]),
+        d: 'jest is awesome',
+        e: 'jest is awesome',
+        f: {
+          a: new Date(),
+          b: 'jest is awesome',
+        },
+        g: true,
+      };
+      const b = {
+        a: 1,
+        b: 'anything',
+        c: [1, 2, 3],
+        d: expect.stringContaining('jest'),
+        e: expect.stringMatching(/^jest/),
+        f: expect.objectContaining({
+          a: expect.any(Date),
+        }),
+        g: false,
+      };
+      const expected = [
+        '  Object {',
+        '    "a": Any<Number>,',
+        '    "b": Anything,',
+        '    "c": ArrayContaining [',
+        '      1,',
+        '      3,',
+        '    ],',
+        '    "d": StringContaining "jest",',
+        '    "e": StringMatching /^jest/,',
+        '    "f": ObjectContaining {',
+        '      "a": Any<Date>,',
+        '    },',
+        '-   "g": true,',
+        '+   "g": false,',
+        '  }',
+      ].join('\n');
+      expect(diff(a, b, optionsBe)).toBe(expected);
+    });
+
+    test('custom asymmetricMatcher', () => {
+      expect.extend({
+        equal5(received: any) {
+          if (received === 5)
+            return {
+              message: () => `expected ${received} not to be 5`,
+              pass: true,
+            };
+          return {
+            message: () => `expected ${received} to be 5`,
+            pass: false,
+          };
+        },
+      });
+      const a = {
+        a: 5,
+        b: true,
+      };
+      const b = {
+        a: expect.equal5(),
+        b: false,
+      };
+      const expected = [
+        '  Object {',
+        '    "a": equal5<>,',
+        '-   "b": true,',
+        '+   "b": false,',
+        '  }',
+      ].join('\n');
+      expect(diff(a, b, optionsBe)).toBe(expected);
+    });
   });
 });
 

packages/jest-diff/src/index.ts

@@ -8,6 +8,7 @@
 import prettyFormat = require('pretty-format');
 import chalk = require('chalk');
 import getType = require('jest-get-type');
+import {deepCyclicCopy} from 'jest-util';
 import {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff} from './cleanupSemantic';
 import {diffLinesRaw, diffLinesUnified, diffLinesUnified2} from './diffLines';
 import {diffStringsRaw, diffStringsUnified} from './printDiffs';
@@ -131,16 +132,17 @@ function compareObjects(
 ) {
   let difference;
   let hasThrown = false;
+  const {replacedA, replacedB} = replaceMatchedToAsymmetricMatcher(a, b);
 
   try {
-    const aCompare = prettyFormat(a, FORMAT_OPTIONS_0);
-    const bCompare = prettyFormat(b, FORMAT_OPTIONS_0);
+    const aCompare = prettyFormat(replacedA, FORMAT_OPTIONS_0);
+    const bCompare = prettyFormat(replacedB, FORMAT_OPTIONS_0);
 
     if (aCompare === bCompare) {
       difference = NO_DIFF_MESSAGE;
     } else {
-      const aDisplay = prettyFormat(a, FORMAT_OPTIONS);
-      const bDisplay = prettyFormat(b, FORMAT_OPTIONS);
+      const aDisplay = prettyFormat(replacedA, FORMAT_OPTIONS);
+      const bDisplay = prettyFormat(replacedB, FORMAT_OPTIONS);
 
       difference = diffLinesUnified2(
         aDisplay.split('\n'),
@@ -183,4 +185,26 @@ function compareObjects(
   return difference;
 }
 
+function replaceMatchedToAsymmetricMatcher(
+  a: Record<string, any>,
+  b: Record<string, any>,
+) {
+  const replacedA = deepCyclicCopy(a, {keepPrototype: true});
+  const replacedB = deepCyclicCopy(b, {keepPrototype: true});
+  Object.entries(replacedB).forEach(([key, bValue]) => {
+    const aValue = a[key];
+    if (isAsymmetricMatcher(bValue)) {
+      if (bValue.asymmetricMatch(aValue)) replacedA[key] = bValue;
+    } else if (isAsymmetricMatcher(aValue)) {
+      if (aValue.asymmetricMatch(bValue)) replacedB[key] = aValue;
+    }
+  });
+  return {replacedA, replacedB};
+}
+
+function isAsymmetricMatcher(data: any) {
+  const type = getType(data);
+  return type === 'object' && typeof data.asymmetricMatch === 'function';
+}
+
 export default diff;

packages/jest-diff/tsconfig.json

@@ -8,6 +8,7 @@
     {"path": "../diff-sequences"},
     {"path": "../jest-get-type"},
     {"path": "../pretty-format"},
-    {"path": "../test-utils"}
+    {"path": "../test-utils"},
+    {"path": "../jest-util"}
   ]
 }

packages/jest-util/src/__tests__/deepCyclicCopy.test.ts

@@ -235,3 +235,8 @@ it('keeps the prototype for objects when keepPrototype = true', () => {
   );
   spy.mockRestore();
 });
+
+it('RegExp should work correctly after copied', () => {
+  const regExp = deepCyclicCopy(/jest/i, {keepPrototype: true});
+  expect(regExp.test('JEST is awesome')).toBe(true);
+});

packages/jest-util/src/deepCyclicCopy.ts

@@ -33,6 +33,12 @@ function deepCyclicCopyObject<T>(
   options: DeepCyclicCopyOptions,
   cycles: WeakMap<any, any>,
 ): T {
+  if (object instanceof RegExp && options.keepPrototype) {
+    const result = new RegExp(object.source, object.flags);
+    result.lastIndex = object.lastIndex;
+    return result as typeof object;
+  }
+
   const newObject = options.keepPrototype
     ? Object.create(Object.getPrototypeOf(object))
     : {};