fix(expect): include diff when expect.toMatchObject throws (#6525)

Author: WWRS

expect/_build_message.ts

@@ -18,9 +18,9 @@ function isString(value: unknown): value is string {
 export function buildEqualErrorMessage<T>(
   actual: T,
   expected: T,
-  options: EqualErrorMessageOptions,
+  options: EqualErrorMessageOptions = {},
 ): string {
-  const { formatter = format, msg } = options ?? {};
+  const { formatter = format, msg } = options;
   const msgPrefix = msg ? `${msg}: ` : "";
   const actualString = formatter(actual);
   const expectedString = formatter(expected);
@@ -40,11 +40,11 @@ export function buildEqualErrorMessage<T>(
 export function buildNotEqualErrorMessage<T>(
   actual: T,
   expected: T,
-  options: EqualErrorMessageOptions,
+  options: EqualErrorMessageOptions = {},
 ): string {
-  const { msg } = options ?? {};
-  const actualString = String(actual);
-  const expectedString = String(expected);
+  const { formatter = format, msg } = options;
+  const actualString = formatter(actual);
+  const expectedString = formatter(expected);
 
   const msgPrefix = msg ? `${msg}: ` : "";
   return `${msgPrefix}Expected actual: ${actualString} not to be: ${expectedString}.`;

expect/_matchers.ts

@@ -21,6 +21,10 @@ import {
   iterableEquality,
   subsetEquality,
 } from "./_utils.ts";
+import {
+  buildEqualErrorMessage,
+  buildNotEqualErrorMessage,
+} from "./_build_message.ts";
 
 export function toBe(context: MatcherContext, expect: unknown): MatchResult {
   if (context.isNot) {
@@ -565,7 +569,7 @@ export function toMatchObject(
     );
   }
 
-  const pass = equal(context.value, expected, {
+  const pass = equal(received, expected, {
     strictCheck: false,
     customTesters: [
       ...context.customTesters,
@@ -575,20 +579,15 @@ export function toMatchObject(
   });
 
   const triggerError = () => {
-    const actualString = format(context.value);
-    const expectedString = format(expected);
-
     if (context.isNot) {
-      const defaultMessage =
-        `Expected ${actualString} to NOT match ${expectedString}`;
+      const defaultMessage = buildNotEqualErrorMessage(received, expected);
       throw new AssertionError(
         context.customMessage
           ? `${context.customMessage}: ${defaultMessage}`
           : defaultMessage,
       );
     } else {
-      const defaultMessage =
-        `Expected ${actualString} to match ${expectedString}`;
+      const defaultMessage = buildEqualErrorMessage(received, expected);
       throw new AssertionError(
         context.customMessage
           ? `${context.customMessage}: ${defaultMessage}`

expect/_to_match_object_test.ts

@@ -65,7 +65,7 @@ Deno.test("expect().toMatchObject() with array", () => {
   ]);
 });
 
-Deno.test("expect(),toMatchObject() with asyAsymmetric matcher", () => {
+Deno.test("expect().toMatchObject() with asymmetric matcher", () => {
   expect({ position: { x: 0, y: 0 } }).toMatchObject({
     position: {
       x: expect.any(Number),
@@ -119,15 +119,112 @@ Deno.test("expect().toMatchObject() throws the correct error messages", () => {
   {
     const e = assertThrows(
       () => expect({ a: 1 }).toMatchObject({ a: 2 }),
-      Error,
+      AssertionError,
     );
-    assertNotMatch(e.message, /NOT/);
+    assertNotMatch(e.message, /not to be/);
   }
   {
     const e = assertThrows(
       () => expect({ a: 1 }).not.toMatchObject({ a: 1 }),
-      Error,
+      AssertionError,
     );
-    assertMatch(e.message, /NOT/);
+    assertMatch(e.message, /not to be/);
   }
 });
+
+Deno.test("expect().toMatchObject() displays a diff", async (t) => {
+  await t.step("with expect.any", () => {
+    assertThrows(
+      () =>
+        expect({ a: "a" })
+          .toMatchObject({ a: expect.any(Number) }),
+      AssertionError,
+      `    {
++     a: Any {
++       inverse: false,
++       value: [Function: Number],
++     },
+-     a: "a",
+    }`,
+    );
+  });
+
+  await t.step("with nested properties", () => {
+    const x = {
+      command: "error",
+      payload: {
+        message: "NodeNotFound",
+      },
+      protocol: "graph",
+    };
+
+    const y = {
+      protocol: "graph",
+      command: "addgroup",
+      payload: {
+        graph: "foo",
+        metadata: {
+          description: "foo",
+        },
+        name: "somegroup",
+        nodes: [
+          "somenode",
+          "someothernode",
+        ],
+      },
+    };
+
+    assertThrows(
+      () => expect(x).toMatchObject(y),
+      AssertionError,
+      `    {
++     command: "addgroup",
+-     command: "error",
+      payload: {
++       graph: "foo",
++       metadata: {
++         description: "foo",
++       },
++       name: "somegroup",
++       nodes: [
++         "somenode",
++         "someothernode",
++       ],
+-       message: "NodeNotFound",
+      },
+      protocol: "graph",
+    }`,
+    );
+
+    assertThrows(
+      () => expect({ foo: [] }).toMatchObject({ foo: ["bar"] }),
+      AssertionError,
+      `    {
++     foo: [
++       "bar",
++     ],
+-     foo: [],
+    }`,
+    );
+  });
+
+  await t.step(
+    "with `__proto__`",
+    () => {
+      const objectA = { ["__proto__"]: { polluted: true } };
+      const objectB = { ["__proto__"]: { polluted: true } };
+      const objectC = { ["__proto__"]: { polluted: false } };
+      expect(objectA).toMatchObject(objectB);
+      assertThrows(
+        () => expect(objectA).toMatchObject(objectC),
+        AssertionError,
+        `    {
+      ['__proto__']: {
+-       polluted: true,
++       polluted: false,
+      },
+    }`,
+      );
+    },
+  );
+});

internal/format_test.ts

@@ -27,7 +27,7 @@ Deno.test("format() overrides default behaviours of Deno.inspect", async (t) =>
   // Wraps objects into multiple lines even when they are small. Prints trailing
   // commas.
   await t.step(
-    "fromat() always wraps objects into multiple lines and prints trailing commas",
+    "format() always wraps objects into multiple lines and prints trailing commas",
     () =>
       assertEquals(
         stripAnsiCode(format({ a: 1, b: 2 })),
@@ -38,6 +38,12 @@ Deno.test("format() overrides default behaviours of Deno.inspect", async (t) =>
       ),
   );
 
+  await t.step("format() sorts properties", () =>
+    assertEquals(
+      format({ b: 2, a: 1 }),
+      format({ a: 1, b: 2 }),
+    ));
+
   await t.step("format() wraps Object with getters", () =>
     assertEquals(
       format(Object.defineProperty({}, "a", {