refactor 'assertEquals' (denoland/std#560)

* merge 'testing/pretty.ts' into 'testing/asserts.ts'
* throw AssertionError in assertEquals
* update misc tests use AssertionError
Original: denoland/std@ff2d7f2

bundle/test.ts

@@ -4,10 +4,10 @@ import { test } from "../testing/mod.ts";
 import {
   assert,
   AssertionError,
+  assertEquals,
   assertStrictEq,
   assertThrowsAsync
 } from "../testing/asserts.ts";
-import { assertEquals } from "../testing/pretty.ts";
 import { evaluate, instantiate, load, ModuleMetaData } from "./utils.ts";
 
 /* eslint-disable @typescript-eslint/no-namespace */

testing/asserts.ts

@@ -1,5 +1,9 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { assertEquals as prettyAssertEqual } from "./pretty.ts";
+import { red, green, white, gray, bold } from "../colors/mod.ts";
+import diff, { DiffType, DiffResult } from "./diff.ts";
+import { format } from "./format.ts";
+
+const CAN_NOT_DISPLAY = "[Cannot display]";
 
 interface Constructor {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -13,6 +17,56 @@ export class AssertionError extends Error {
   }
 }
 
+function createStr(v: unknown): string {
+  try {
+    return format(v);
+  } catch (e) {
+    return red(CAN_NOT_DISPLAY);
+  }
+}
+
+function createColor(diffType: DiffType): (s: string) => string {
+  switch (diffType) {
+    case DiffType.added:
+      return (s: string): string => green(bold(s));
+    case DiffType.removed:
+      return (s: string): string => red(bold(s));
+    default:
+      return white;
+  }
+}
+
+function createSign(diffType: DiffType): string {
+  switch (diffType) {
+    case DiffType.added:
+      return "+   ";
+    case DiffType.removed:
+      return "-   ";
+    default:
+      return "    ";
+  }
+}
+
+function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>): string[] {
+  const messages: string[] = [];
+  messages.push("");
+  messages.push("");
+  messages.push(
+    `    ${gray(bold("[Diff]"))} ${red(bold("Left"))} / ${green(bold("Right"))}`
+  );
+  messages.push("");
+  messages.push("");
+  diffResult.forEach(
+    (result: DiffResult<string>): void => {
+      const c = createColor(result.type);
+      messages.push(c(`${createSign(result.type)}${result.value}`));
+    }
+  );
+  messages.push("");
+
+  return messages;
+}
+
 export function equal(c: unknown, d: unknown): boolean {
   const seen = new Map();
   return (function compare(a: unknown, b: unknown): boolean {
@@ -77,7 +131,25 @@ export function assertEquals(
   expected: unknown,
   msg?: string
 ): void {
-  prettyAssertEqual(actual, expected, msg);
+  if (equal(actual, expected)) {
+    return;
+  }
+  let message = "";
+  const actualString = createStr(actual);
+  const expectedString = createStr(expected);
+  try {
+    const diffResult = diff(
+      actualString.split("\n"),
+      expectedString.split("\n")
+    );
+    message = buildMessage(diffResult).join("\n");
+  } catch (e) {
+    message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`;
+  }
+  if (msg) {
+    message = msg;
+  }
+  throw new AssertionError(message);
 }
 
 /**

testing/asserts_test.ts

@@ -15,6 +15,7 @@ import {
   unreachable
 } from "./asserts.ts";
 import { test } from "./mod.ts";
+import { red, green, white, gray, bold } from "../colors/mod.ts";
 
 test(function testingEqual(): void {
   assert(equal("world", "world"));
@@ -163,3 +164,90 @@ test(function testingAssertFail(): void {
     "Failed assertion: foo"
   );
 });
+
+const createHeader = (): string[] => [
+  "",
+  "",
+  `    ${gray(bold("[Diff]"))} ${red(bold("Left"))} / ${green(bold("Right"))}`,
+  "",
+  ""
+];
+
+const added: (s: string) => string = (s: string): string => green(bold(s));
+const removed: (s: string) => string = (s: string): string => red(bold(s));
+
+test({
+  name: "pass case",
+  fn(): void {
+    assertEquals({ a: 10 }, { a: 10 });
+    assertEquals(true, true);
+    assertEquals(10, 10);
+    assertEquals("abc", "abc");
+    assertEquals({ a: 10, b: { c: "1" } }, { a: 10, b: { c: "1" } });
+  }
+});
+
+test({
+  name: "failed with number",
+  fn(): void {
+    assertThrows(
+      (): void => assertEquals(1, 2),
+      AssertionError,
+      [...createHeader(), removed(`-   1`), added(`+   2`), ""].join("\n")
+    );
+  }
+});
+
+test({
+  name: "failed with number vs string",
+  fn(): void {
+    assertThrows(
+      (): void => assertEquals(1, "1"),
+      AssertionError,
+      [...createHeader(), removed(`-   1`), added(`+   "1"`)].join("\n")
+    );
+  }
+});
+
+test({
+  name: "failed with array",
+  fn(): void {
+    assertThrows(
+      (): void => assertEquals([1, "2", 3], ["1", "2", 3]),
+      AssertionError,
+      [
+        ...createHeader(),
+        white("    Array ["),
+        removed(`-     1,`),
+        added(`+     "1",`),
+        white('      "2",'),
+        white("      3,"),
+        white("    ]"),
+        ""
+      ].join("\n")
+    );
+  }
+});
+
+test({
+  name: "failed with object",
+  fn(): void {
+    assertThrows(
+      (): void => assertEquals({ a: 1, b: "2", c: 3 }, { a: 1, b: 2, c: [3] }),
+      AssertionError,
+      [
+        ...createHeader(),
+        white("    Object {"),
+        white(`      "a": 1,`),
+        added(`+     "b": 2,`),
+        added(`+     "c": Array [`),
+        added(`+       3,`),
+        added(`+     ],`),
+        removed(`-     "b": "2",`),
+        removed(`-     "c": 3,`),
+        white("    }"),
+        ""
+      ].join("\n")
+    );
+  }
+});

testing/test.ts

@@ -9,7 +9,6 @@ import {
 } from "./asserts.ts";
 import "./format_test.ts";
 import "./diff_test.ts";
-import "./pretty_test.ts";
 import "./asserts_test.ts";
 import "./bench_test.ts";