Ensure async property is preserved when not given

Author: josevalim

lib/ex_unit/lib/ex_unit.ex

@@ -405,14 +405,10 @@ defmodule ExUnit do
   @spec run([module()]) :: suite_result()
   def run(additional_modules \\ []) do
     for module <- additional_modules do
-      module_attributes = module.__info__(:attributes)
-
-      case Keyword.get(module_attributes, :ex_unit_module) do
-        [config] ->
-          ExUnit.Server.add_module(module, config)
-
-        _ ->
-          raise(ArgumentError, "#{inspect(module)} is not a ExUnit.Case module")
+      if Code.ensure_loaded?(module) and function_exported?(module, :__ex_unit__, 1) do
+        ExUnit.Server.add_module(module, module.__ex_unit__(:config))
+      else
+        raise(ArgumentError, "#{inspect(module)} is not a ExUnit.Case module")
       end
     end
 

lib/ex_unit/lib/ex_unit/callbacks.ex

@@ -166,22 +166,21 @@ defmodule ExUnit.Callbacks do
   """
 
   @doc false
-  defmacro __using__(_) do
-    quote do
-      @ex_unit_describe nil
-      @ex_unit_setup []
-      @ex_unit_setup_all []
-      @ex_unit_used_describes %{}
-
-      @before_compile unquote(__MODULE__)
-      import unquote(__MODULE__)
-    end
+  def __register__(module) do
+    Module.put_attribute(module, :ex_unit_describe, nil)
+    Module.put_attribute(module, :ex_unit_setup, [])
+    Module.put_attribute(module, :ex_unit_setup_all, [])
+    Module.put_attribute(module, :ex_unit_used_describes, %{})
   end
 
   @doc false
   defmacro __before_compile__(env) do
     used_describes = Module.get_attribute(env.module, :ex_unit_used_describes)
-    [compile_setup(env, :setup, used_describes), compile_setup(env, :setup_all, %{})]
+
+    quote do
+      unquote(compile_setup(env, :setup, used_describes))
+      unquote(compile_setup(env, :setup_all, %{}))
+    end
   end
 
   @doc """

lib/ex_unit/lib/ex_unit/case.ex

@@ -299,9 +299,7 @@ defmodule ExUnit.Case do
   @doc false
   defmacro __using__(opts) do
     quote do
-      if !ExUnit.Case.__register__(__MODULE__, unquote(opts)) do
-        use ExUnit.Callbacks
-      end
+      ExUnit.Case.__register__(__MODULE__, unquote(opts))
 
       import ExUnit.Callbacks
       import ExUnit.Assertions
@@ -319,20 +317,13 @@ defmodule ExUnit.Case do
     end
 
     {register?, opts} = Keyword.pop(opts, :register, true)
-    {async?, opts} = Keyword.pop(opts, :async, false)
-    {parameterize, opts} = Keyword.pop(opts, :parameterize, nil)
-
-    if not (parameterize == nil or (is_list(parameterize) and Enum.all?(parameterize, &is_map/1))) do
-      raise ArgumentError, ":parameterize must be a list of maps, got: #{inspect(parameterize)}"
-    end
+    {next_opts, opts} = Keyword.split(opts, [:async, :parameterize])
 
     if opts != [] do
       IO.warn("unknown options given to ExUnit.Case: #{inspect(opts)}")
     end
 
-    registered? = Module.has_attribute?(module, :ex_unit_tests)
-
-    if not registered? do
+    if not Module.has_attribute?(module, :ex_unit_tests) do
       tag_check = Enum.any?([:moduletag, :describetag, :tag], &Module.has_attribute?(module, &1))
 
       if tag_check do
@@ -351,19 +342,18 @@ defmodule ExUnit.Case do
 
       Enum.each(accumulate_attributes, &Module.register_attribute(module, &1, accumulate: true))
 
-      persisted_attributes = [:ex_unit_module]
-
-      Enum.each(persisted_attributes, &Module.register_attribute(module, &1, persist: true))
-
       if register? do
         Module.put_attribute(module, :after_compile, ExUnit.Case)
       end
 
+      ExUnit.Callbacks.__register__(module)
       Module.put_attribute(module, :before_compile, ExUnit.Case)
+      Module.put_attribute(module, :before_compile, ExUnit.Callbacks)
     end
 
-    Module.put_attribute(module, :ex_unit_module, {async?, parameterize})
-    registered?
+    past_opts = Module.get_attribute(module, :ex_unit_module, [])
+    Module.put_attribute(module, :ex_unit_module, Keyword.merge(past_opts, next_opts))
+    :ok
   end
 
   @doc """
@@ -560,6 +550,14 @@ defmodule ExUnit.Case do
       |> validate_tags()
       |> Map.new()
 
+    opts = Module.get_attribute(module, :ex_unit_module, [])
+    async? = Keyword.get(opts, :async, false)
+    parameterize = Keyword.get(opts, :parameterize, nil)
+
+    if not (parameterize == nil or (is_list(parameterize) and Enum.all?(parameterize, &is_map/1))) do
+      raise ArgumentError, ":parameterize must be a list of maps, got: #{inspect(parameterize)}"
+    end
+
     quote do
       def __ex_unit__ do
         %ExUnit.TestModule{
@@ -569,15 +567,18 @@ defmodule ExUnit.Case do
           tests: unquote(tests)
         }
       end
+
+      def __ex_unit__(:config) do
+        {unquote(async?), unquote(Macro.escape(parameterize))}
+      end
     end
   end
 
   @doc false
   def __after_compile__(%{module: module}, _) do
     cond do
       Process.whereis(ExUnit.Server) ->
-        config = Module.get_attribute(module, :ex_unit_module)
-        ExUnit.Server.add_module(module, config)
+        ExUnit.Server.add_module(module, module.__ex_unit__(:config))
 
       Code.can_await_module_compilation?() ->
         :ok

lib/ex_unit/lib/ex_unit/case_template.ex

@@ -64,7 +64,9 @@ defmodule ExUnit.CaseTemplate do
   @doc false
   defmacro __using__(_) do
     quote do
-      use ExUnit.Callbacks
+      ExUnit.Callbacks.__register__(__MODULE__)
+      @before_compile ExUnit.Callbacks
+      import ExUnit.Callbacks
 
       import ExUnit.Assertions
       import unquote(__MODULE__)

lib/ex_unit/test/ex_unit/case_test.exs

@@ -167,7 +167,7 @@ defmodule ExUnit.DoubleCaseTestAsyncFirst do
   use ExUnit.Case
 
   test "async must be true", context do
-    refute context.async
+    assert context.async
   end
 end
 

lib/ex_unit/test/ex_unit_test.exs

@@ -1141,8 +1141,7 @@ defmodule ExUnitTest do
 
   defp run_with_filter(filters, cases) do
     Enum.each(cases, fn mod ->
-      [config] = mod.__info__(:attributes) |> Keyword.fetch!(:ex_unit_module)
-      ExUnit.Server.add_module(mod, config)
+      ExUnit.Server.add_module(mod, mod.__ex_unit__(:config))
     end)
 
     ExUnit.Server.modules_loaded(false)