Abort diffing on binary patterns, closes #15191

Author: josevalim

lib/ex_unit/lib/ex_unit/diff.ex

@@ -38,6 +38,8 @@ defmodule ExUnit.Diff do
   """
   def compute(left, right, context) do
     diff(left, right, context_to_env(context))
+  catch
+    :undiffable -> nil
   end
 
   defp context_to_env({:match, pins}),
@@ -113,6 +115,18 @@ defmodule ExUnit.Diff do
     diff_string_concat(left, right, env)
   end
 
+  defp diff_quoted({:<<>>, _, parts} = left, right, _expanded, env) do
+    if Enum.all?(parts, &is_binary/1) do
+      equivalent? = IO.iodata_to_binary(parts) == right
+      diff_left = update_diff_meta(left, not equivalent?)
+      diff_right = escape(right) |> update_diff_meta(not equivalent?)
+      diff = %__MODULE__{equivalent?: equivalent?, left: diff_left, right: diff_right}
+      {diff, env}
+    else
+      throw(:undiffable)
+    end
+  end
+
   defp diff_quoted({:when, _, [_, _]} = left, right, _expanded, env) do
     diff_guard(left, right, env)
   end

lib/ex_unit/test/ex_unit/diff_test.exs

@@ -1132,22 +1132,6 @@ defmodule ExUnit.DiffTest do
     )
   end
 
-  test "concat binaries with specifiers" do
-    input = "foobar"
-
-    refute_diff(
-      <<trap::binary-size(3)>> <> "baz" = input,
-      "-<<trap::binary-size(3)>> <> \"baz\"-",
-      "+\"foobar\"+"
-    )
-
-    refute_diff(
-      "hello " <> <<_::binary-size(6)>> = "hello world",
-      "\"hello \" <> -<<_::binary-size(6)>>-",
-      "\"hello +world+\""
-    )
-  end
-
   test "underscore" do
     assert_diff(_ = :a, [])
     assert_diff({_, _} = {:a, :b}, [])
@@ -1361,12 +1345,4 @@ defmodule ExUnit.DiffTest do
       "#Function<\n  #{uniq}/0 in ExUnit.DiffTest.closure/1\n  [+2+]\n>"
     )
   end
-
-  test "not supported" do
-    refute_diff(
-      <<147, 1, 2, 31>> = <<193, 1, 31>>,
-      "-<<147, 1, 2, 31>>-",
-      "+<<193, 1, 31>>+"
-    )
-  end
 end

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -35,6 +35,8 @@ defmodule ExUnit.FormatterTest do
   defp formatter(_key, value), do: value
 
   defp diff_formatter(:diff_enabled?, _default), do: true
+  defp diff_formatter(:diff_insert, value), do: Inspect.Algebra.concat(["+", value, "+"])
+  defp diff_formatter(:diff_delete, value), do: Inspect.Algebra.concat(["-", value, "-"])
   defp diff_formatter(_key, value), do: value
 
   defp kw_to_string(kw), do: for({k, v} <- kw, do: {k, IO.iodata_to_binary(v)})
@@ -328,12 +330,15 @@ defmodule ExUnit.FormatterTest do
 
     assert format_assertion_diff(assertion_error, 0, :infinity, &diff_formatter/2)
            |> kw_to_string() ==
-             [{:left, "{3, 2, 1}"}, {:right, "{1, 2, 3}"}]
+             [{:left, "{-3-, 2, -1-}"}, {:right, "{+1+, 2, +3+}"}]
   end
 
   nfc_hello = String.normalize("héllo", :nfc)
   nfd_hello = String.normalize("héllo", :nfd)
 
+  nfc_left_hello = String.normalize("h-é-llo", :nfc)
+  nfd_right_hello = String.normalize("h+é+llo", :nfd)
+
   test "formats assertions with hints" do
     assertion_error = catch_assertion(assert unquote(nfc_hello) == unquote(nfd_hello))
     failure = [{:error, assertion_error, []}]
@@ -343,19 +348,16 @@ defmodule ExUnit.FormatterTest do
                 test/ex_unit/formatter_test.exs:1
                 Assertion with == failed
                 code:  assert "#{unquote(nfc_hello)}" == "#{unquote(nfd_hello)}"
-                left:  "#{unquote(nfc_hello)}"
-                right: "#{unquote(nfd_hello)}"
+                left:  "#{unquote(nfc_left_hello)}"
+                right: "#{unquote(nfd_right_hello)}"
                 hint:  you are comparing strings that have the same visual representation but are made of different Unicode codepoints
            """
 
-    assert format_test_failure(test(), failure, 1, 80, &diff_formatter/2) ==
-             format_test_failure(test(), failure, 1, 80, &formatter/2)
-
     assert format_assertion_diff(assertion_error, 0, :infinity, &diff_formatter/2)
            |> kw_to_string() ==
              [
-               left: inspect(unquote(nfc_hello)),
-               right: inspect(unquote(nfd_hello)),
+               left: inspect(unquote(nfc_left_hello)),
+               right: inspect(unquote(nfd_right_hello)),
                hint:
                  "you are comparing strings that have the same visual representation but are made of different Unicode codepoints"
              ]
@@ -377,8 +379,8 @@ defmodule ExUnit.FormatterTest do
                 The following variables were pinned:
                   expected_module = ExUnit.TestModule
                 code:  assert %^expected_module{} = nil
-                left:  %^expected_module{}
-                right: nil
+                left:  -%^expected_module{}-
+                right: +nil+
            """
   end
 
@@ -548,8 +550,19 @@ defmodule ExUnit.FormatterTest do
     assert format_test_all_failure(test_module(), failure, 1, :infinity, &diff_formatter/2) =~ """
            match (=) failed
                 code:  assert :foo = %{bar: [1 | 2]}
-                left:  :foo
-                right: %{bar: [1 | 2]}
+                left:  -:foo-
+                right: +%{bar: [1 | 2]}+
+           """
+  end
+
+  test "formats assertions with binary matching without diffing" do
+    failure = [{:error, catch_assertion(assert %{foo: <<_>>, bar: 2} = %{foo: "!", bar: 3}), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, :infinity, &diff_formatter/2) =~ """
+           match (=) failed
+                code:  assert %{foo: <<_>>, bar: 2} = %{foo: "!", bar: 3}
+                left:  %{foo: <<_>>, bar: 2}
+                right: %{foo: "!", bar: 3}
            """
   end