Properly format and indent test output

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -1841,8 +1841,7 @@ defmodule Kernel do
 
   * `:pretty` - if set to true enables pretty printing, defaults to false;
 
-  * `:width` - the width available for inspect to layout the data structure
-               representation. Defaults to the smaller of 80 or the terminal width;
+  * `:width` - defaults to the 80 characters;
 
   ## Examples
 

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -2,7 +2,7 @@ defexception ExUnit.AssertionError,
     left:    :ex_unit_no_meaningful_value,
     right:   :ex_unit_no_meaningful_value,
     message: :ex_unit_no_meaningful_value,
-    expr:    "missing failing expression" do
+    expr:    :ex_unit_no_meaningful_value do
 
   @doc """
   Indicates no meaningful value for a field.
@@ -62,7 +62,7 @@ defmodule ExUnit.Assertions do
       rhs:  15
   """
   defmacro assert({ :=, _, [left, right] } = assertion) do
-    code = Macro.to_string(assertion)
+    code = Macro.escape(assertion)
     { :case, meta, args } =
       quote do
         case right do
@@ -90,8 +90,8 @@ defmodule ExUnit.Assertions do
 
           unless value do
             raise ExUnit.AssertionError,
-              expr: unquote(Macro.to_string(assertion)),
-              message: "#{inspect value} is not truthy"
+              expr: unquote(Macro.escape(assertion)),
+              message: "Expected truthy, got #{inspect value}"
           end
 
           value
@@ -112,7 +112,7 @@ defmodule ExUnit.Assertions do
 
   """
   defmacro refute({ :=, _, [left, right] } = assertion) do
-    code = Macro.to_string(assertion)
+    code = Macro.escape(assertion)
     { :case, meta, args } =
       quote do
         case right do
@@ -140,8 +140,8 @@ defmodule ExUnit.Assertions do
 
           if value do
             raise ExUnit.AssertionError,
-              expr: unquote(Macro.to_string(assertion)),
-              message: "#{inspect value} should be false or nil"
+              expr: unquote(Macro.escape(assertion)),
+              message: "Expected false or nil, got #{inspect value}"
           end
 
           value
@@ -157,7 +157,7 @@ defmodule ExUnit.Assertions do
   @operator [:==, :<, :>, :<=, :>=, :===, :=~, :!==, :!=, :in]
 
   defp translate_assertion({ operator, _, [left, right] } = expr) when operator in @operator  do
-    expr = Macro.to_string(expr)
+    expr = Macro.escape(expr)
     quote do
       left  = unquote(left)
       right = unquote(right)
@@ -170,7 +170,7 @@ defmodule ExUnit.Assertions do
   end
 
   defp translate_assertion({ :!, [], [{ operator, _, [left, right] } = expr] }) when operator in @operator do
-    expr = Macro.to_string(expr)
+    expr = Macro.escape(expr)
     quote do
       left  = unquote(left)
       right = unquote(right)
@@ -197,7 +197,7 @@ defmodule ExUnit.Assertions do
 
   """
   def assert(value, message) when is_binary(message) do
-    assert(value, message: message, expr: ExUnit.AssertionError.no_value)
+    assert(value, message: message)
   end
 
   def assert(value, opts) when is_list(opts) do
@@ -219,8 +219,7 @@ defmodule ExUnit.Assertions do
 
   """
   def assert(value, left, right, message) when is_binary(message) do
-    assert(value, left: left, right: right,
-                  message: message, expr: ExUnit.AssertionError.no_value)
+    assert(value, left: left, right: right, message: message)
   end
 
   @doc """
@@ -307,7 +306,7 @@ defmodule ExUnit.Assertions do
     end
 
     msg = "Wrong message for #{inspect exception}. Expected #{inspect message}, got #{inspect error.message}"
-    assert is_match, message: msg, expr: ExUnit.AssertionError.no_value
+    assert is_match, message: msg
 
     error
   end
@@ -520,6 +519,6 @@ defmodule ExUnit.Assertions do
   @spec flunk :: no_return
   @spec flunk(String.t) :: no_return
   def flunk(message \\ "Flunked!") do
-    assert false, message: message, expr: ExUnit.AssertionError.no_value
+    assert false, message: message
   end
 end

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -3,16 +3,18 @@ defmodule ExUnit.CLIFormatter do
 
   use GenEvent.Behaviour
 
-  import ExUnit.Formatter, only: [format_time: 2, format_filters: 2, format_test_failure: 5, format_test_case_failure: 4]
+  import ExUnit.Formatter, only: [format_time: 2, format_filters: 2, format_test_failure: 6,
+                                  format_test_case_failure: 5]
 
   defrecord Config, tests_counter: 0, invalids_counter: 0, failures_counter: 0,
-                    skips_counter: 0, trace: false, seed: nil, color: true
+                    skips_counter: 0, trace: false, seed: nil, color: true,
+                    width: :infinity
 
   ## Callbacks
 
   def init(opts) do
     print_filters(Keyword.take(opts, [:include, :exclude]))
-    { :ok, Config.new(opts) }
+    { :ok, opts |> Config.new |> add_terminal_width }
   end
 
   def handle_event({ :suite_finished, run_us, load_us }, config = Config[]) do
@@ -136,12 +138,14 @@ defmodule ExUnit.CLIFormatter do
   end
 
   defp print_test_failure(ExUnit.Test[name: name, case: mod, state: { :failed, tuple }], config) do
-    formatted = format_test_failure(mod, name, tuple, config.failures_counter + 1, &formatter(&1, &2, config))
+    formatted = format_test_failure(mod, name, tuple, config.failures_counter + 1,
+                                    config.width, &formatter(&1, &2, config))
     print_any_failure formatted, config
   end
 
   defp print_test_case_failure(ExUnit.TestCase[name: name, state: { :failed, tuple }], config) do
-    formatted = format_test_case_failure(name, tuple, config.failures_counter + 1, &formatter(&1, &2, config))
+    formatted = format_test_case_failure(name, tuple, config.failures_counter + 1,
+                                         config.width, &formatter(&1, &2, config))
     print_any_failure formatted, config
   end
 
@@ -177,4 +181,13 @@ defmodule ExUnit.CLIFormatter do
   defp formatter(:error_info, msg, config),    do: colorize("red", msg, config)
   defp formatter(:location_info, msg, config), do: colorize("cyan", msg, config)
   defp formatter(_,  msg, _config),            do: msg
+
+  defp add_terminal_width(config) do
+    case :io.columns do
+      { :ok, width } ->
+        config.width(max(40, width))
+      _ ->
+        config
+    end
+  end
 end

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -32,8 +32,9 @@ defmodule ExUnit.Formatter do
 
   import Exception, only: [format_stacktrace_entry: 1]
 
-  # Width of error counter field
-  @prefix_width 5
+  @label_padding   "      "
+  @counter_padding "     "
+  @inspect_padding @counter_padding <> @label_padding
 
   @doc """
   Formats time taken running the test suite.
@@ -99,40 +100,42 @@ defmodule ExUnit.Formatter do
   @doc """
   Receives a test and formats its failure.
   """
-  def format_test_failure(test_case, test, { kind, reason, stack }, counter, terminal) do
-    test_info(with_counter(counter, "#{test} (#{inspect test_case})"), terminal)
-      <> format_kind_reason(kind, reason, terminal)
-      <> format_stacktrace(stack, test_case, test, terminal)
+  def format_test_failure(test_case, test, { kind, reason, stack }, counter, width, formatter) do
+    test_info(with_counter(counter, "#{test} (#{inspect test_case})"), formatter)
+      <> format_kind_reason(kind, reason, width, formatter)
+      <> format_stacktrace(stack, test_case, test, formatter)
   end
 
   @doc """
   Receives a test case and formats its failure.
   """
-  def format_test_case_failure(test_case, { kind, reason, stacktrace }, counter, terminal) do
-    test_case_info(with_counter(counter, "#{inspect test_case}: "), terminal)
-      <> format_kind_reason(kind, reason, terminal)
-      <> format_stacktrace(stacktrace, test_case, nil, terminal)
+  def format_test_case_failure(test_case, { kind, reason, stacktrace }, counter, width, formatter) do
+    test_case_info(with_counter(counter, "#{inspect test_case}: "), formatter)
+      <> format_kind_reason(kind, reason, width, formatter)
+      <> format_stacktrace(stacktrace, test_case, nil, formatter)
   end
 
-  defp format_kind_reason(:error, ExUnit.AssertionError[] = record, terminal) do
+  defp format_kind_reason(:error, ExUnit.AssertionError[] = record, width, formatter) do
+    width = if width == :infinity, do: width, else: width - byte_size(@inspect_padding)
+
     fields =
-      [note: if_value(record.message, &format_message(&1, terminal)),
-       code: record.expr,
-       lhs:  if_value(record.left,  &inspect/1),
-       rhs:  if_value(record.right, &inspect/1)]
+      [note: if_value(record.message, &format_message(&1, formatter)),
+       code: if_value(record.expr, &macro_multiline(&1, width)),
+       lhs:  if_value(record.left,  &inspect_multiline(&1, width)),
+       rhs:  if_value(record.right, &inspect_multiline(&1, width))]
 
     fields
     |> filter_interesting_fields
-    |> format_each_reason(terminal)
-    |> make_into_lines
+    |> format_each_reason(formatter)
+    |> make_into_lines(@counter_padding)
   end
 
-  defp format_kind_reason(:error, exception, terminal) do
-    error_info "** (#{inspect exception.__record__(:name)}) #{exception.message}", terminal
+  defp format_kind_reason(:error, exception, _width, formatter) do
+    error_info "** (#{inspect exception.__record__(:name)}) #{exception.message}", formatter
   end
 
-  defp format_kind_reason(kind, reason, terminal) do
-    error_info "** (#{kind}) #{inspect(reason)}", terminal
+  defp format_kind_reason(kind, reason, _width, formatter) do
+    error_info "** (#{kind}) #{inspect(reason)}", formatter
   end
 
   defp filter_interesting_fields(fields) do
@@ -141,15 +144,9 @@ defmodule ExUnit.Formatter do
     end)
   end
 
-  defp format_each_reason(reasons, terminal) do
-    label_length =
-      reasons
-      |> Enum.map(fn {label,_} -> String.length(atom_to_binary(label)) end)
-      |> Enum.max
-      |> Kernel.+(2)
-
+  defp format_each_reason(reasons, formatter) do
     Enum.map(reasons, fn {label, value} ->
-      format_label(label, label_length, terminal) <> value
+      format_label(label, formatter) <> value
     end)
   end
 
@@ -161,20 +158,30 @@ defmodule ExUnit.Formatter do
     end
   end
 
-  defp format_label(:note, _length, _terminal) do
+  defp format_label(:note, _formatter) do
     ""
   end
 
-  defp format_label(label, length, terminal) do
-    terminal.(:error_info, String.ljust("#{label}:", length))
+  defp format_label(label, formatter) do
+    formatter.(:error_info, String.ljust("#{label}:", byte_size(@label_padding)))
+  end
+
+  defp format_message(value, formatter) do
+    formatter.(:error_info, value)
+  end
+
+  defp macro_multiline(expr, _width) do
+    expr |> Macro.to_string
   end
 
-  defp format_message(value, terminal) do
-    terminal.(:error_info, value)
+  defp inspect_multiline(expr, width) do
+    expr
+    |> inspect(pretty: true, width: width)
+    |> String.replace("\n", "\n" <> @inspect_padding)
   end
 
-  defp make_into_lines(reasons) do
-    "     " <> Enum.join(reasons, "\n     ") <> "\n"
+  defp make_into_lines(reasons, padding) do
+    padding <> Enum.join(reasons, "\n" <> padding) <> "\n"
   end
 
   defp format_stacktrace([{ test_case, test, _, location }|_], test_case, test, color) do
@@ -195,17 +202,17 @@ defmodule ExUnit.Formatter do
   defp with_counter(counter, msg)                    do   "#{counter}) #{msg}" end
 
   defp test_case_info(msg, nil),      do: msg <> "failure on setup_all/teardown_all callback, tests invalidated\n"
-  defp test_case_info(msg, terminal), do: test_case_info(terminal.(:test_case_info, msg), nil)
+  defp test_case_info(msg, formatter), do: test_case_info(formatter.(:test_case_info, msg), nil)
 
   defp test_info(msg, nil),      do: msg <> "\n"
-  defp test_info(msg, terminal), do: test_info(terminal.(:test_info, msg), nil)
+  defp test_info(msg, formatter), do: test_info(formatter.(:test_info, msg), nil)
 
   defp error_info(msg, nil),      do: "     " <> msg <> "\n"
-  defp error_info(msg, terminal), do: error_info(terminal.(:error_info, msg), nil)
+  defp error_info(msg, formatter), do: error_info(formatter.(:error_info, msg), nil)
 
   defp location_info(msg, nil),      do: "     " <> msg <> "\n"
-  defp location_info(msg, terminal), do: location_info(terminal.(:location_info, msg), nil)
+  defp location_info(msg, formatter), do: location_info(formatter.(:location_info, msg), nil)
 
   defp stacktrace_info(msg, nil),      do: "       " <> msg <> "\n"
-  defp stacktrace_info(msg, terminal), do: stacktrace_info(terminal.(:stacktrace_info, msg), nil)
+  defp stacktrace_info(msg, formatter), do: stacktrace_info(formatter.(:stacktrace_info, msg), nil)
 end