Allow test names longer than 255 characters

Author: josevalim

lib/ex_unit/lib/ex_unit.ex

@@ -143,16 +143,28 @@ defmodule ExUnit do
 
     It is received by formatters and contains the following fields:
 
-      * `:name` - the test name
+      * `:name` - the test name. This is the function name in the test module,
+        which is truncated and hashed when above 250 characters
       * `:module` - the test module
+      * `:description` - the test description (the name without truncation)
       * `:state` - the finished test state (see `t:ExUnit.state/0`)
       * `:time` - the duration in microseconds of the test's runtime
       * `:tags` - the test tags
       * `:logs` - the captured logs
       * `:parameters` - the test parameters
 
     """
-    defstruct [:name, :case, :module, :state, time: 0, tags: %{}, logs: "", parameters: %{}]
+    defstruct [
+      :name,
+      :description,
+      :case,
+      :module,
+      :state,
+      time: 0,
+      tags: %{},
+      logs: "",
+      parameters: %{}
+    ]
 
     # TODO: Remove the `:case` field on v2.0
     @type t :: %__MODULE__{
@@ -163,7 +175,8 @@ defmodule ExUnit do
             time: non_neg_integer,
             tags: map,
             logs: String.t(),
-            parameters: map
+            parameters: map,
+            description: String.t()
           }
   end
 

lib/ex_unit/lib/ex_unit/case.ex

@@ -695,17 +695,18 @@ defmodule ExUnit.Case do
     moduletag = Module.get_attribute(mod, :moduletag)
     tag = Module.delete_attribute(mod, :tag)
 
-    {name, describe, describe_line, describetag} =
+    {description, describe, describe_line, describetag} =
       case Module.get_attribute(mod, :ex_unit_describe) do
         {line, describe, _counter} ->
-          test_name = validate_test_name("#{test_type} #{describe} #{name}")
-          {test_name, describe, line, Module.get_attribute(mod, :describetag)}
+          {"#{test_type} #{describe} #{name}", describe, line,
+           Module.get_attribute(mod, :describetag)}
 
         nil ->
-          test_name = validate_test_name("#{test_type} #{name}")
-          {test_name, nil, nil, []}
+          {"#{test_type} #{name}", nil, nil, []}
       end
 
+    name = build_test_name(description)
+
     if Module.defines?(mod, {name, 1}) do
       raise ArgumentError, ~s("#{name}" is already defined in #{inspect(mod)})
     end
@@ -723,7 +724,7 @@ defmodule ExUnit.Case do
         test_type: test_type
       })
 
-    test = %ExUnit.Test{name: name, case: mod, tags: tags, module: mod}
+    test = %ExUnit.Test{name: name, description: description, case: mod, tags: tags, module: mod}
     Module.put_attribute(mod, :ex_unit_tests, test)
 
     for attribute <- Module.get_attribute(mod, :ex_unit_registered_test_attributes) do
@@ -733,15 +734,8 @@ defmodule ExUnit.Case do
     name
   end
 
-  @doc """
-  Registers a test with the given environment.
-
-  This function is deprecated in favor of `register_test/6` which performs
-  better under tight loops by avoiding `__ENV__`.
-  """
   # TODO: Remove me Elixir v2.0
   @deprecated "Use register_test/6 instead"
-  @doc since: "1.3.0"
   def register_test(%{module: mod, file: file, line: line}, test_type, name, tags) do
     register_test(mod, file, line, test_type, name, tags)
   end
@@ -925,7 +919,12 @@ defmodule ExUnit.Case do
     tags
   end
 
-  defp validate_test_name(name) do
+  defp build_test_name(name) when byte_size(name) > 255 do
+    hash = :erlang.md5(name) |> binary_slice(0, 3) |> Base.encode64()
+    build_test_name(String.byte_slice(name, 0, 246) <> "... " <> hash)
+  end
+
+  defp build_test_name(name) do
     try do
       String.to_atom(name)
     rescue

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -240,7 +240,7 @@ defmodule ExUnit.CLIFormatter do
   end
 
   defp trace_test_started(test) do
-    String.replace("  * #{test.name}", "\n", " ")
+    String.replace("  * #{test.description}", "\n", " ")
   end
 
   defp trace_test_result(test) do
@@ -256,7 +256,7 @@ defmodule ExUnit.CLIFormatter do
   end
 
   defp trace_aborted(%ExUnit.Test{} = test) do
-    "* #{test.name} [#{trace_test_file_line(test)}]"
+    "* #{test.description} [#{trace_test_file_line(test)}]"
   end
 
   defp trace_aborted(%ExUnit.TestModule{name: name, file: file}) do

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -259,7 +259,7 @@ defmodule ExUnit.Formatter do
 
       iex> failure = {:error, catch_error(raise "oops"), _stacktrace = []}
       iex> formatter_cb = fn _key, value -> value end
-      iex> test = %ExUnit.Test{name: :"it works", module: MyTest, tags: %{file: "file.ex", line: 7}}
+      iex> test = %ExUnit.Test{name: :"it works", description: "it works", module: MyTest, tags: %{file: "file.ex", line: 7}}
       iex> format_test_failure(test, [failure], 1, 80, formatter_cb)
       "  1) it works (MyTest)\n     file.ex:7\n     ** (RuntimeError) oops\n"
 
@@ -273,9 +273,15 @@ defmodule ExUnit.Formatter do
         ) :: String.t()
         when failure: {atom, term, Exception.stacktrace()}
   def format_test_failure(test, failures, counter, width, formatter) do
-    %ExUnit.Test{name: name, module: module, tags: tags, parameters: parameters} = test
-
-    test_info(with_counter(counter, "#{name} (#{inspect(module)})"), formatter) <>
+    %ExUnit.Test{
+      name: name,
+      description: description,
+      module: module,
+      tags: tags,
+      parameters: parameters
+    } = test
+
+    test_info(with_counter(counter, "#{description} (#{inspect(module)})"), formatter) <>
       test_parameters(parameters, formatter) <>
       test_location(with_location(tags), formatter) <>
       Enum.map_join(Enum.with_index(failures), "", fn {{kind, reason, stack}, index} ->

lib/ex_unit/test/ex_unit/case_test.exs

@@ -127,30 +127,6 @@ defmodule ExUnit.CaseTest do
     end
   end
 
-  test "raises when name is longer than 255 characters" do
-    assert_raise SystemLimitError,
-                 ~r/must be shorter than 255 characters, got: "test a{256}"/,
-                 fn ->
-                   defmodule LongNameTest do
-                     use ExUnit.Case
-
-                     test String.duplicate("a", 256)
-                   end
-                 end
-
-    assert_raise SystemLimitError,
-                 ~r/must be shorter than 255 characters, got: "test a{100} a{156}"/,
-                 fn ->
-                   defmodule LongDescribeNameTest do
-                     use ExUnit.Case
-
-                     describe String.duplicate("a", 100) do
-                       test String.duplicate("a", 156)
-                     end
-                   end
-                 end
-  end
-
   test "warns when using @tag outside of describe" do
     stderr =
       ExUnit.CaptureIO.capture_io(:stderr, fn ->

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -25,7 +25,23 @@ defmodule ExUnit.FormatterTest do
   end
 
   defp test do
-    %ExUnit.Test{name: :world, module: Hello, tags: %{file: __ENV__.file, line: 1}}
+    %ExUnit.Test{
+      name: :world,
+      description: "world",
+      module: Hello,
+      tags: %{file: __ENV__.file, line: 1}
+    }
+  end
+
+  defp long_test do
+    long_name = "test " <> String.duplicate("a", 300)
+
+    %ExUnit.Test{
+      name: String.to_atom("truncated"),
+      description: long_name,
+      module: Hello,
+      tags: %{file: __ENV__.file, line: 1}
+    }
   end
 
   def falsy() do
@@ -622,4 +638,22 @@ defmodule ExUnit.FormatterTest do
                 ** (ExUnit.FormatterTest.BadMessage) #{message}
            """
   end
+
+  test "formats long test name using full description" do
+    failure = [{:error, catch_error(raise "oops"), []}]
+    long = long_test()
+
+    result = format_test_failure(long, failure, 1, 80, &formatter/2)
+    assert result =~ "test #{String.duplicate("a", 300)} (Hello)"
+  end
+
+  test "formats long test name with assertions using full description" do
+    assertion_error = catch_assertion(assert 1 == 2)
+    failure = [{:error, assertion_error, []}]
+    long = long_test()
+
+    result = format_test_failure(long, failure, 1, 80, &formatter/2)
+    assert result =~ "test #{String.duplicate("a", 300)} (Hello)"
+    assert result =~ "Assertion with == failed"
+  end
 end