Do not show variables on error reports due to verbosity

Author: José Valim

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -8,8 +8,7 @@ defmodule ExUnit.AssertionError do
   defexception left: @no_value,
                right: @no_value,
                message: @no_value,
-               expr: @no_value,
-               binding: @no_value
+               expr: @no_value
 
   @doc """
   Indicates no meaningful value for a field.
@@ -105,7 +104,6 @@ defmodule ExUnit.Assertions do
     left = Macro.expand(left, __CALLER__)
     vars = collect_vars_from_pattern(left)
     pins = collect_pins_from_pattern(left, __CALLER__.vars)
-    rhs_binding = collect_vars_used_in_expression(right, __CALLER__.vars)
 
     # If the match works, we need to check if the value
     # is not nil nor false. We need to rewrite the if
@@ -116,7 +114,6 @@ defmodule ExUnit.Assertions do
           x when x in [nil, false] ->
             raise ExUnit.AssertionError,
               expr: expr,
-              binding: unquote(rhs_binding),
               message: "Expected truthy, got #{inspect right}"
           _ ->
             :ok
@@ -133,7 +130,6 @@ defmodule ExUnit.Assertions do
             raise ExUnit.AssertionError,
               right: right,
               expr: expr,
-              binding: unquote(rhs_binding),
               message: "match (=) failed" <>
                        ExUnit.Assertions.__pins__(unquote(pins))
         end
@@ -151,14 +147,12 @@ defmodule ExUnit.Assertions do
     code   = escape_quoted(:assert, assertion)
     match? = {:match?, meta, [left, Macro.var(:right, __MODULE__)]}
     pins   = collect_pins_from_pattern(left, __CALLER__.vars)
-    rhs_binding = collect_vars_used_in_expression(right, __CALLER__.vars)
 
     quote do
       right = unquote(right)
       assert unquote(match?),
         right: right,
         expr: unquote(code),
-        binding: unquote(rhs_binding),
         message: "match (match?) failed" <>
                  ExUnit.Assertions.__pins__(unquote(pins))
     end
@@ -167,15 +161,12 @@ defmodule ExUnit.Assertions do
   defmacro assert(assertion) do
     case translate_assertion(:assert, assertion, __CALLER__) do
       nil ->
-        binding = collect_vars_used_in_expression(assertion, __CALLER__.vars)
-
         quote do
           value = unquote(assertion)
 
           unless value do
             raise ExUnit.AssertionError,
               expr: unquote(escape_quoted(:assert, assertion)),
-              binding: unquote(binding),
               message: "Expected truthy, got #{inspect value}"
           end
 
@@ -212,14 +203,12 @@ defmodule ExUnit.Assertions do
     code   = escape_quoted(:refute, assertion)
     match? = {:match?, meta, [left, Macro.var(:right, __MODULE__)]}
     pins   = collect_pins_from_pattern(left, __CALLER__.vars)
-    rhs_binding = collect_vars_used_in_expression(right, __CALLER__.vars)
 
     quote do
       right = unquote(right)
       refute unquote(match?),
         right: right,
         expr: unquote(code),
-        binding: unquote(rhs_binding),
         message: "match (match?) succeeded, but should have failed" <>
                  ExUnit.Assertions.__pins__(unquote(pins))
     end
@@ -228,15 +217,12 @@ defmodule ExUnit.Assertions do
   defmacro refute(assertion) do
     case translate_assertion(:refute, assertion, __CALLER__) do
       nil ->
-        binding = collect_vars_used_in_expression(assertion, __CALLER__.vars)
-
         quote do
           value = unquote(assertion)
 
           if value do
             raise ExUnit.AssertionError,
               expr: unquote(escape_quoted(:refute, assertion)),
-              binding: unquote(binding),
               message: "Expected false or nil, got #{inspect value}"
           end
 
@@ -277,26 +263,19 @@ defmodule ExUnit.Assertions do
   defp translate_assertion(kind, {_, _, [left, right]} = expr, call, message, true, caller) do
     expr = escape_quoted(kind, expr)
 
-    # We collect the binding for LHS/RHS separately because we want top-level
-    # variables to not show up in the binding, but if we pass "expr" we're sure
-    # there won't be any top-level variables.
-    binding = Enum.uniq(collect_vars_used_in_expression(left, caller.vars) ++ collect_vars_used_in_expression(right, caller.vars))
-
     quote do
       left = unquote(left)
       right = unquote(right)
       if ExUnit.Assertions.__equal__?(left, right) do
         assert false,
           left: left,
           expr: unquote(expr),
-          binding: unquote(binding),
           message: unquote(message <> ", both sides are exactly equal")
       else
         assert unquote(call),
           left: left,
           right: right,
           expr: unquote(expr),
-          binding: unquote(binding),
           message: unquote(message)
       end
     end
@@ -305,19 +284,13 @@ defmodule ExUnit.Assertions do
   defp translate_assertion(kind, {_, _, [left, right]} = expr, call, message, false, caller) do
     expr = escape_quoted(kind, expr)
 
-    # We collect the binding for LHS/RHS separately because we want top-level
-    # variables to not show up in the binding, but if we pass "expr" we're sure
-    # there won't be any top-level variables.
-    binding = Enum.uniq(collect_vars_used_in_expression(left, caller.vars) ++ collect_vars_used_in_expression(right, caller.vars))
-
     quote do
       left = unquote(left)
       right = unquote(right)
       assert unquote(call),
         left: left,
         right: right,
         expr: unquote(expr),
-        binding: unquote(binding),
         message: unquote(message)
     end
   end

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -126,15 +126,13 @@ defmodule ExUnit.Formatter do
     padding_size = label_padding_size + byte_size(@counter_padding)
     inspect = &inspect_multiline(&1, padding_size, width)
     {left, right} = format_sides(struct, formatter, inspect)
-    binding = if(struct.binding == [], do: ExUnit.AssertionError.no_value(), else: struct.binding)
 
     [
       note: if_value(struct.message, &format_message(&1, formatter)),
       code: if_value(struct.expr, &code_multiline(&1, padding_size)),
       code: unless_value(struct.expr, fn -> get_code(test, stack) || @no_value end),
       left: left,
-      right: right,
-      variables: if_value(binding, &format_binding(&1, width)),
+      right: right
     ]
     |> format_meta(formatter, label_padding_size)
     |> make_into_lines(counter_padding)
@@ -263,18 +261,6 @@ defmodule ExUnit.Formatter do
     code_multiline(Macro.to_string(expr), padding_size)
   end
 
-  defp format_binding(binding, width) do
-    padding = @counter_padding <> "  "
-    padding_size = byte_size(padding)
-
-    result =
-      Enum.map_join(binding, "\n" <> padding, fn {var, value} ->
-        "#{var} = #{inspect_multiline(value, padding_size, width)}"
-      end)
-
-    "\n" <> padding <> result
-  end
-
   defp inspect_multiline(expr, padding_size, width) do
     padding = String.duplicate(" ", padding_size)
     width = if width == :infinity, do: width, else: width - padding_size

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -74,53 +74,6 @@ defmodule ExUnit.AssertionsTest do
     end
   end
 
-  test "assert shows binding in the asserted expression" do
-    # No binding is shown because the RHS is only a top-level variable
-    # and thus it's already printed as the RHS of the match.
-    try do
-      int1 = 1
-      int2 = 2
-      assert ^int1 = int2
-    rescue
-      error in [ExUnit.AssertionError] ->
-        [] = error.binding
-    end
-
-    try do
-      int1 = 1
-      int2 = 2
-      assert ^int1 = int2 * 2
-    rescue
-      error in [ExUnit.AssertionError] ->
-        [int2: 2] = error.binding
-    end
-
-    try do
-      int1 = 1
-      int2 = 2
-      assert int1 * 10 == int2
-    rescue
-      error in [ExUnit.AssertionError] ->
-        [int1: 1] = error.binding
-    end
-  end
-
-  test "assert shows only binding in the asserted expression when assertion fails" do
-    try do
-      bin1 = <<1, 2, 3>>
-      bin2 = <<1, 2, 4>>
-
-      # Let's have a variable that we don't use in the assertion in the __ENV__.
-      bin3 = bin1 <> bin2
-      _ = bin3
-
-      assert String.starts_with?(bin1, bin2)
-    rescue
-      error in [ExUnit.AssertionError] ->
-        [bin1: <<1, 2, 3>>, bin2: <<1, 2, 4>>] = error.binding
-    end
-  end
-
   test "refute when value is false" do
     false = refute false
   end

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -143,23 +143,6 @@ defmodule ExUnit.FormatterTest do
     """
   end
 
-  test "formats binding when there is some" do
-    many_ids = Enum.to_list(1..30)
-    no_ids = []
-    failure = [{:error, catch_assertion(assert Enum.take(many_ids, 3) == no_ids), []}]
-    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         Assertion with == failed
-         code:  assert Enum.take(many_ids, 3) == no_ids
-         left:  [1, 2, 3]
-         right: []
-         variables:
-           many_ids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-            21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
-    """
-  end
-
   test "formats multiple assertions" do
     failure = [{:error, catch_assertion(assert ExUnit.FormatterTest.falsy), []},
                {:error, catch_assertion(assert 1 == 2), []}]