Accept {module, function} tuples in ExUnit setup (#12378)

Author: v0idpwn

lib/ex_unit/lib/ex_unit/callbacks.ex

@@ -17,9 +17,10 @@ defmodule ExUnit.Callbacks do
   test is run. All `setup` callbacks are run before each test. No callback
   is run if the test case has no tests or all tests have been filtered out.
 
-  `setup` and `setup_all` callbacks can be defined by a block, by passing
-  an atom naming a one-arity function, or by passing a list of such
-  atoms. Both can opt to receive the current context by specifying it
+  `setup` and `setup_all` callbacks can be defined by either a block, an atom
+  naming a local function, a `{module, function}` tuple, or a list of atoms/tuples.
+
+  Both can opt to receive the current context by specifying it
   as parameter if defined by a block. Functions used to define a test
   setup must accept the context as single argument.
 
@@ -124,13 +125,13 @@ defmodule ExUnit.Callbacks do
 
   It is also common to define your setup as a series of functions,
   which are put together by calling `setup` or `setup_all` with a
-  list of atoms. Each of these functions receive the context and can
+  list of function names. Each of these functions receive the context and can
   return any of the values allowed in `setup` blocks:
 
       defmodule ExampleContextTest do
         use ExUnit.Case
 
-        setup [:step1, :step2, :step3]
+        setup [:step1, :step2, :step3, {OtherModule, :step4}]
 
         defp step1(_context), do: [step_one: true]
         defp step2(_context), do: {:ok, step_two: true} # return values with shape of {:ok, keyword() | map()} allowed
@@ -183,8 +184,8 @@ defmodule ExUnit.Callbacks do
   @doc """
   Defines a callback to be run before each test in a case.
 
-  Accepts a block or the name of a one-arity function in the form of an atom,
-  or a list of such atoms.
+  Accepts a block, an atom naming a local function, a `{module, function}` tuple,
+  or a list of atoms/tuples.
 
   Can return values to be merged into the context, to set up the state for
   tests. For more details, see the "Context" section shown above.
@@ -218,8 +219,8 @@ defmodule ExUnit.Callbacks do
   @doc """
   Defines a callback to be run before each test in a case.
 
-  Accepts a block or the name of a one-arity function in the form of an atom,
-  or a list of such atoms.
+  Accepts a block, an atom naming a local function, a `{module, function}` tuple,
+  or a list of atoms/tuples.
 
   Can return values to be merged into the `context`, to set up the state for
   tests. For more details, see the "Context" section shown above.
@@ -245,7 +246,12 @@ defmodule ExUnit.Callbacks do
   @doc false
   def __setup__(module, callbacks) do
     setup = Module.get_attribute(module, :ex_unit_setup)
-    Module.put_attribute(module, :ex_unit_setup, Enum.reverse(callbacks(callbacks), setup))
+
+    Module.put_attribute(
+      module,
+      :ex_unit_setup,
+      Enum.reverse(validate_callbacks!(callbacks), setup)
+    )
   end
 
   @doc false
@@ -265,8 +271,8 @@ defmodule ExUnit.Callbacks do
   @doc """
   Defines a callback to be run before all tests in a case.
 
-  Accepts a block or the name of a one-arity function in the form of an atom,
-  or a list of such atoms.
+  Accepts a block, an atom naming a local function, a {module, function} tuple,
+  or a list of atoms/tuples.
 
   Can return values to be merged into the `context`, to set up the state for
   tests. For more details, see the "Context" section shown above.
@@ -365,7 +371,7 @@ defmodule ExUnit.Callbacks do
     Module.put_attribute(
       module,
       :ex_unit_setup_all,
-      Enum.reverse(callbacks(callbacks), setup_all)
+      Enum.reverse(validate_callbacks!(callbacks), setup_all)
     )
   end
 
@@ -385,15 +391,21 @@ defmodule ExUnit.Callbacks do
     end
   end
 
-  defp callbacks(callbacks) do
+  defp validate_callbacks!(callbacks) do
     for k <- List.wrap(callbacks) do
-      if not is_atom(k) do
-        raise ArgumentError,
-              "setup/setup_all expect a callback name as an atom or " <>
-                "a list of callback names, got: #{inspect(k)}"
+      case k do
+        {mod, fun} when is_atom(mod) and is_atom(fun) ->
+          {mod, fun}
+
+        name when is_atom(name) ->
+          name
+
+        invalid ->
+          raise ArgumentError,
+                "setup/setup_all expect a callback as an atom, " <>
+                  "a {module, function} tuple or a list of callbacks, got: " <>
+                  inspect(invalid)
       end
-
-      k
     end
   end
 
@@ -801,9 +813,19 @@ defmodule ExUnit.Callbacks do
     end)
   end
 
-  defp compile_setup_call(callback) do
+  defp compile_setup_call(callback) when is_atom(callback) do
     quote do
       unquote(__MODULE__).__merge__(__MODULE__, var!(context), unquote(callback)(var!(context)))
     end
   end
+
+  defp compile_setup_call({module, callback}) do
+    quote do
+      unquote(__MODULE__).__merge__(
+        __MODULE__,
+        var!(context),
+        unquote(module).unquote(callback)(var!(context))
+      )
+    end
+  end
 end

lib/ex_unit/test/ex_unit/callbacks_test.exs

@@ -65,6 +65,27 @@ defmodule ExUnit.CallbacksTest do
     assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures"
   end
 
+  test "named callbacks support {module, function} tuples" do
+    defmodule NamedCallbacksTupleTest do
+      use ExUnit.Case
+
+      setup_all {__MODULE__, :setup_1}
+      setup [{__MODULE__, :setup_2}, {__MODULE__, :setup_3}]
+
+      test "callbacks", context do
+        assert context[:setup_1]
+        assert context[:setup_2]
+        assert context[:setup_3]
+      end
+
+      def setup_1(_), do: [setup_1: true]
+      def setup_2(_), do: [setup_2: true]
+      def setup_3(_), do: [setup_3: true]
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures"
+  end
+
   test "doesn't choke on setup errors" do
     defmodule SetupTest do
       use ExUnit.Case