Only spawn setup_all process if there is such callbacks

Author: josevalim

lib/ex_unit/lib/ex_unit.ex

@@ -124,22 +124,28 @@ defmodule ExUnit do
 
     It is received by formatters and contains the following fields:
 
-      * `:file`  - (since v1.11.0) the file of the test module
+      * `:file` - (since v1.11.0) the file of the test module
 
-      * `:name`  - the test module name
+      * `:name` - the test module name
+
+      * `:parameters` - (since v1.18.0) the test module parameters
+
+      * `:setup_all?` - (since v1.18.0) if the test module requies a setup all
 
       * `:state` - the test error state (see `t:ExUnit.state/0`)
 
-      * `:tests` - all tests in this module
+      * `:tags` - all tags in this module
 
-      * `:parameters` - the test module parameters
+      * `:tests` - all tests in this module
 
     """
-    defstruct [:file, :name, :state, tags: %{}, tests: [], parameters: %{}]
+    defstruct [:file, :name, :setup_all?, :state, parameters: %{}, tags: %{}, tests: []]
 
     @type t :: %__MODULE__{
             file: binary(),
             name: module,
+            parameters: map(),
+            setup_all?: boolean(),
             state: ExUnit.state(),
             tags: map,
             tests: [ExUnit.Test.t()]

lib/ex_unit/lib/ex_unit/callbacks.ex

@@ -174,13 +174,23 @@ defmodule ExUnit.Callbacks do
   end
 
   @doc false
-  defmacro __before_compile__(env) do
-    used_describes = Module.get_attribute(env.module, :ex_unit_used_describes)
+  def __callbacks__(module) do
+    setup = Module.get_attribute(module, :ex_unit_setup)
+    setup_all = Module.get_attribute(module, :ex_unit_setup_all)
+    used_describes = Module.get_attribute(module, :ex_unit_used_describes)
 
-    quote do
-      unquote(compile_setup(env, :setup, used_describes))
-      unquote(compile_setup(env, :setup_all, %{}))
-    end
+    code =
+      quote do
+        unquote(compile_setup(:setup, setup, used_describes))
+        unquote(compile_setup(:setup_all, setup_all, %{}))
+      end
+
+    {setup_all != [], code}
+  end
+
+  @doc false
+  defmacro __before_compile__(%{module: module}) do
+    __callbacks__(module)
   end
 
   @doc """
@@ -802,11 +812,8 @@ defmodule ExUnit.Callbacks do
     {name, body}
   end
 
-  defp compile_setup(env, kind, describes) do
-    calls =
-      env.module
-      |> Module.get_attribute(:"ex_unit_#{kind}")
-      |> compile_setup(kind)
+  defp compile_setup(kind, value, describes) do
+    calls = compile_setup(value, kind)
 
     describe_clauses =
       for {describe, callback} <- describes,

lib/ex_unit/lib/ex_unit/case.ex

@@ -353,7 +353,6 @@ defmodule ExUnit.Case do
 
       ExUnit.Callbacks.__register__(module)
       Module.put_attribute(module, :before_compile, ExUnit.Case)
-      Module.put_attribute(module, :before_compile, ExUnit.Callbacks)
     end
 
     past_opts = Module.get_attribute(module, :ex_unit_module, [])
@@ -564,11 +563,16 @@ defmodule ExUnit.Case do
       raise ArgumentError, ":parameterize must be a list of maps, got: #{inspect(parameterize)}"
     end
 
+    {setup_all?, callbacks} = ExUnit.Callbacks.__callbacks__(module)
+
     quote do
+      unquote(callbacks)
+
       def __ex_unit__ do
         %ExUnit.TestModule{
           file: __ENV__.file,
           name: __MODULE__,
+          setup_all?: unquote(setup_all?),
           tags: unquote(Macro.escape(tags)),
           tests: unquote(tests)
         }

lib/ex_unit/lib/ex_unit/runner.ex

@@ -301,69 +301,79 @@ defmodule ExUnit.Runner do
   end
 
   defp run_module_tests(config, test_module, async?, tests) do
-    {module_pid, module_ref} = run_setup_all(test_module, async?, self())
+    Process.put(@current_key, test_module)
+    %ExUnit.TestModule{name: module, tags: tags, parameters: params} = test_module
+    context = tags |> Map.merge(params) |> Map.merge(%{module: module, async: async?})
+
+    config
+    |> run_setup_all(test_module, context, fn context ->
+      if max_failures_reached?(config),
+        do: [],
+        else: run_tests(config, tests, test_module.parameters, context)
+    end)
+    |> case do
+      {{:ok, finished_tests}, test_module} ->
+        {test_module, [], finished_tests}
 
-    {test_module, invalid_tests, finished_tests} =
-      receive do
-        {^module_pid, :setup_all, {:ok, context}} ->
-          finished_tests =
-            if max_failures_reached?(config),
-              do: [],
-              else: run_tests(config, tests, test_module.parameters, context)
+      {:error, test_module} ->
+        {test_module, Enum.map(tests, &%{&1 | state: {:invalid, test_module}}), []}
+    end
+  end
 
-          :ok = exit_setup_all(module_pid, module_ref)
-          {test_module, [], finished_tests}
+  defp run_setup_all(
+         _config,
+         %ExUnit.TestModule{setup_all?: false} = test_module,
+         context,
+         callback
+       ) do
+    {{:ok, callback.(context)}, test_module}
+  end
 
-        {^module_pid, :setup_all, {:error, test_module}} ->
-          invalid_tests = mark_tests_invalid(tests, test_module)
-          :ok = exit_setup_all(module_pid, module_ref)
-          {test_module, invalid_tests, []}
+  defp run_setup_all(config, %ExUnit.TestModule{name: module} = test_module, context, callback) do
+    parent_pid = self()
 
-        {:DOWN, ^module_ref, :process, ^module_pid, error} ->
-          test_module = %{test_module | state: failed({:EXIT, module_pid}, error, [])}
-          invalid_tests = mark_tests_invalid(tests, test_module)
-          {test_module, invalid_tests, []}
-      end
+    {module_pid, module_ref} =
+      spawn_monitor(fn ->
+        ExUnit.OnExitHandler.register(self())
+
+        result =
+          try do
+            {:ok, module.__ex_unit__(:setup_all, context)}
+          catch
+            kind, error ->
+              failed = failed(kind, error, prune_stacktrace(__STACKTRACE__))
+              {:error, %{test_module | state: failed}}
+          end
 
-    timeout = get_timeout(config, %{})
-    {exec_on_exit(test_module, module_pid, timeout), invalid_tests, finished_tests}
-  end
+        send(parent_pid, {self(), :setup_all, result})
 
-  defp mark_tests_invalid(tests, test_module) do
-    Enum.map(tests, &%{&1 | state: {:invalid, test_module}})
-  end
+        # We keep the process alive so all of its resources
+        # stay alive until we run all tests in this case.
+        ref = Process.monitor(parent_pid)
 
-  defp run_setup_all(
-         %ExUnit.TestModule{name: module, tags: tags, parameters: params} = test_module,
-         async?,
-         parent_pid
-       ) do
-    Process.put(@current_key, test_module)
-
-    spawn_monitor(fn ->
-      ExUnit.OnExitHandler.register(self())
-      tags = tags |> Map.merge(params) |> Map.merge(%{module: module, async: async?})
-
-      result =
-        try do
-          {:ok, module.__ex_unit__(:setup_all, Map.merge(tags, params))}
-        catch
-          kind, error ->
-            failed = failed(kind, error, prune_stacktrace(__STACKTRACE__))
-            {:error, %{test_module | state: failed}}
+        receive do
+          {^parent_pid, :exit} -> :ok
+          {:DOWN, ^ref, _, _, _} -> :ok
         end
+      end)
 
-      send(parent_pid, {self(), :setup_all, result})
+    {ok_or_error, test_module} =
+      receive do
+        {^module_pid, :setup_all, {:ok, context}} ->
+          finished_tests = callback.(context)
+          :ok = exit_setup_all(module_pid, module_ref)
+          {{:ok, finished_tests}, test_module}
 
-      # We keep the process alive so all of its resources
-      # stay alive until we run all tests in this case.
-      ref = Process.monitor(parent_pid)
+        {^module_pid, :setup_all, {:error, test_module}} ->
+          :ok = exit_setup_all(module_pid, module_ref)
+          {:error, test_module}
 
-      receive do
-        {^parent_pid, :exit} -> :ok
-        {:DOWN, ^ref, _, _, _} -> :ok
+        {:DOWN, ^module_ref, :process, ^module_pid, error} ->
+          {:error, %{test_module | state: failed({:EXIT, module_pid}, error, [])}}
       end
-    end)
+
+    timeout = get_timeout(config, %{})
+    {ok_or_error, exec_on_exit(test_module, module_pid, timeout)}
   end
 
   defp exit_setup_all(pid, ref) do