Do not highlight matched asymmetricMatcher in diffs

CHANGELOG.md

@@ -25,6 +25,7 @@
 - `[@jest/fake-timers]` Add Lolex as implementation of fake timers ([#8897](https://github.com/facebook/jest/pull/8897))
 - `[jest-get-type]` Add `BigInt` support. ([#8382](https://github.com/facebook/jest/pull/8382))
 - `[jest-matcher-utils]` Add `BigInt` support to `ensureNumbers` `ensureActualIsNumber`, `ensureExpectedIsNumber` ([#8382](https://github.com/facebook/jest/pull/8382))
+- `[jest-matcher-utils]` Ignore highlighting matched asymmetricMatcher in diffs ([#9257](https://github.com/facebook/jest/pull/9257))
 - `[jest-reporters]` Export utils for path formatting ([#9162](https://github.com/facebook/jest/pull/9162))
 - `[jest-runner]` Warn if a worker had to be force exited ([#8206](https://github.com/facebook/jest/pull/8206))
 - `[jest-runtime]` [**BREAKING**] Do not export `ScriptTransformer` - it can be imported from `@jest/transform` instead ([#9256](https://github.com/facebook/jest/pull/9256))
@@ -54,6 +55,7 @@
 - `[jest-diff]` Rename some new options and change their default values ([#9077](https://github.com/facebook/jest/pull/9077))
 - `[jest-environment-node]` Fix `TextEncoder.encode` not referencing same global `Uint8Array` constructor ([#9261](https://github.com/facebook/jest/pull/9261))
 - `[jest-fake-timers]` `getTimerCount` will not include cancelled immediates ([#8764](https://github.com/facebook/jest/pull/8764))
+- `[jest-fake-timers]` Support `util.promisify` on `setTimeout` ([#9180](https://github.com/facebook/jest/pull/9180))
 - `[jest-jasmine2, jest-circus]` Improve error message format for Node's assert.fail ([#9262](https://github.com/facebook/jest/pull/9262))
 - `[jest-leak-detector]` [**BREAKING**] Use `weak-napi` instead of `weak` package ([#8686](https://github.com/facebook/jest/pull/8686))
 - `[jest-mock]` Fix for mockReturnValue overriding mockImplementationOnce ([#8398](https://github.com/facebook/jest/pull/8398))
@@ -68,9 +70,8 @@
 - `[jest-transform]` Properly cache transformed files across tests ([#8890](https://github.com/facebook/jest/pull/8890))
 - `[jest-transform]` Don't fail the test suite when a generated source map is invalid ([#9058](https://github.com/facebook/jest/pull/9058))
 - `[jest-types]` [**BREAKING**] Use less `null | undefined` in config types ([#9200](https://github.com/facebook/jest/pull/9200))
-- `[jest-utils]` Allow querying process.domain ([#9136](https://github.com/facebook/jest/pull/9136))
+- `[jest-util]` 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))
 
 ### Chore & Maintenance
 

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

@@ -364,14 +364,8 @@ 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"</>
 
-<g>- Expected  - 1</>
-<r>+ Received  + 1</>
-
-<d>  Object {</>
-<g>-   "a": Any<Function>,</>
-<r>+   "a": [Function a],</>
-<d>    "b": 2,</>
-<d>  }</>
+Expected: <g>{"a": Any<Function>, "b": 2}</>
+Received: <r>{"a": [Function a], "b": 2}</>
 `;
 
 exports[`.toBe() fails for: {"a": 1} and {"a": 1} 1`] = `

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

@@ -192,24 +192,26 @@ 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('(expanded)', () => {
-    expect(diff(a, b, expandedBe)).toBe(expected);
+    test('(unexpanded)', () => {
+      expect(diff(a, b, unexpandedBe)).toBe(expected);
+    });
+    test('(expanded)', () => {
+      expect(diff(a, b, expandedBe)).toBe(expected);
+    });
   });
 });
 

packages/jest-matcher-utils/src/Replaceable.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import getType = require('jest-get-type');
+
+const supportTypes = ['map', 'array', 'object'];
+
+type ReplaceableForEachCallBack = (value: any, key: any, object: any) => void;
+
+export default class Replaceable {
+  object: any;
+  type: string;
+
+  constructor(object: any) {
+    this.object = object;
+    this.type = getType(object);
+    if (!supportTypes.includes(this.type)) {
+      throw new Error(`Type ${this.type} is not support in Replaceable!`);
+    }
+  }
+
+  static isReplaceable(obj1: any, obj2: any): boolean {
+    const obj1Type = getType(obj1);
+    const obj2Type = getType(obj2);
+    return obj1Type === obj2Type && supportTypes.includes(obj1Type);
+  }
+
+  forEach(cb: ReplaceableForEachCallBack): void {
+    if (this.type === 'object') {
+      Object.entries(this.object).forEach(([key, value]) => {
+        cb(value, key, this.object);
+      });
+    } else {
+      this.object.forEach(cb);
+    }
+  }
+
+  get(key: any): any {
+    if (this.type === 'map') {
+      return this.object.get(key);
+    }
+    return this.object[key];
+  }
+
+  set(key: any, value: any): void {
+    if (this.type === 'map') {
+      this.object.set(key, value);
+    } else {
+      this.object[key] = value;
+    }
+  }
+}

packages/jest-matcher-utils/src/__tests__/Replaceable.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import Replaceable from '../Replaceable';
+
+describe('Replaceable', () => {
+  describe('constructor', () => {
+    test('init with object', () => {
+      const replaceable = new Replaceable({a: 1, b: 2});
+      expect(replaceable.object).toEqual({a: 1, b: 2});
+      expect(replaceable.type).toBe('object');
+    });
+
+    test('init with array', () => {
+      const replaceable = new Replaceable([1, 2, 3]);
+      expect(replaceable.object).toEqual([1, 2, 3]);
+      expect(replaceable.type).toBe('array');
+    });
+
+    test('init with Map', () => {
+      const replaceable = new Replaceable(
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      );
+      expect(replaceable.object).toEqual(
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      );
+      expect(replaceable.type).toBe('map');
+    });
+
+    test('init with other type should throw error', () => {
+      expect(() => {
+        //eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const replaceable = new Replaceable(new Date());
+      }).toThrow('Type date is not support in Replaceable!');
+    });
+  });
+
+  describe('get', () => {
+    test('get object item', () => {
+      const replaceable = new Replaceable({a: 1, b: 2});
+      expect(replaceable.get('b')).toBe(2);
+    });
+
+    test('get array item', () => {
+      const replaceable = new Replaceable([1, 2, 3]);
+      expect(replaceable.get(1)).toBe(2);
+    });
+
+    test('get Map item', () => {
+      const replaceable = new Replaceable(
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      );
+      expect(replaceable.get('b')).toBe(2);
+    });
+  });
+
+  describe('set', () => {
+    test('set object item', () => {
+      const replaceable = new Replaceable({a: 1, b: 2});
+      replaceable.set('b', 3);
+      expect(replaceable.object).toEqual({a: 1, b: 3});
+    });
+
+    test('set array item', () => {
+      const replaceable = new Replaceable([1, 2, 3]);
+      replaceable.set(1, 3);
+      expect(replaceable.object).toEqual([1, 3, 3]);
+    });
+
+    test('set Map item', () => {
+      const replaceable = new Replaceable(
+        new Map([
+          ['a', 1],
+          ['b', 2],
+        ]),
+      );
+      replaceable.set('b', 3);
+      expect(replaceable.object).toEqual(
+        new Map([
+          ['a', 1],
+          ['b', 3],
+        ]),
+      );
+    });
+  });
+
+  describe('forEach', () => {
+    test('object forEach', () => {
+      const replaceable = new Replaceable({a: 1, b: 2});
+      const cb = jest.fn();
+      replaceable.forEach(cb);
+      expect(cb.mock.calls[0]).toEqual([1, 'a', {a: 1, b: 2}]);
+      expect(cb.mock.calls[1]).toEqual([2, 'b', {a: 1, b: 2}]);
+    });
+
+    test('array forEach', () => {
+      const replaceable = new Replaceable([1, 2, 3]);
+      const cb = jest.fn();
+      replaceable.forEach(cb);
+      expect(cb.mock.calls[0]).toEqual([1, 0, [1, 2, 3]]);
+      expect(cb.mock.calls[1]).toEqual([2, 1, [1, 2, 3]]);
+      expect(cb.mock.calls[2]).toEqual([3, 2, [1, 2, 3]]);
+    });
+
+    test('map forEach', () => {
+      const map = new Map([
+        ['a', 1],
+        ['b', 2],
+      ]);
+      const replaceable = new Replaceable(map);
+      const cb = jest.fn();
+      replaceable.forEach(cb);
+      expect(cb.mock.calls[0]).toEqual([1, 'a', map]);
+      expect(cb.mock.calls[1]).toEqual([2, 'b', map]);
+    });
+  });
+
+  describe('isReplaceable', () => {
+    test('should return true if two object types equal and support', () => {
+      expect(Replaceable.isReplaceable({a: 1}, {b: 2})).toBe(true);
+      expect(Replaceable.isReplaceable([], [1, 2, 3])).toBe(true);
+      expect(
+        Replaceable.isReplaceable(
+          new Map(),
+          new Map([
+            ['a', 1],
+            ['b', 2],
+          ]),
+        ),
+      ).toBe(true);
+    });
+
+    test('should return false if two object types not equal', () => {
+      expect(Replaceable.isReplaceable({a: 1}, [1, 2, 3])).toBe(false);
+    });
+
+    test('should return false if object types not support', () => {
+      expect(Replaceable.isReplaceable('foo', 'bar')).toBe(false);
+    });
+  });
+});