Do not run async groups on load

Author: josevalim

lib/ex_unit/lib/ex_unit/server.ex

@@ -143,25 +143,16 @@ defmodule ExUnit.Server do
     state =
       update_in(
         state.async_modules,
-        &Enum.reduce(names, &1, fn name, q -> :queue.in({:module, name}, q) end)
+        &Enum.reduce(names, &1, fn name, q -> :queue.in(name, q) end)
       )
 
     {:reply, :ok, take_modules(state)}
   end
 
   def handle_call({:add, true = _async, group, names}, _from, %{loaded: loaded} = state)
       when is_integer(loaded) do
-    {async_groups, async_modules} =
-      case state.async_groups do
-        %{^group => entries} = async_groups ->
-          {%{async_groups | group => names ++ entries}, state.async_modules}
-
-        %{} = async_groups ->
-          {Map.put(async_groups, group, names), :queue.in({:group, group}, state.async_modules)}
-      end
-
-    {:reply, :ok,
-     take_modules(%{state | async_groups: async_groups, async_modules: async_modules})}
+    async_groups = Map.update(state.async_groups, group, names, &(names ++ &1))
+    {:reply, :ok, take_modules(%{state | async_groups: async_groups})}
   end
 
   def handle_call({:add, _async?, _group, _names}, _from, state) do
@@ -174,49 +165,44 @@ defmodule ExUnit.Server do
 
   defp take_modules(%{waiting: {from, count}} = state) do
     has_async_modules? = not :queue.is_empty(state.async_modules)
+    has_async_groups? = map_size(state.async_groups) != 0
 
     cond do
-      not has_async_modules? and state.loaded == :done ->
+      not has_async_modules? and not has_async_groups? and state.loaded == :done ->
         GenServer.reply(from, nil)
         %{state | waiting: nil}
 
-      not has_async_modules? ->
-        state
-
-      true ->
-        {async_modules, remaining_modules} = take_until(count, state.async_modules)
+      has_async_modules? ->
+        {reply, remaining_modules} = take_until(count, state.async_modules)
+        GenServer.reply(from, reply)
+        %{state | async_modules: remaining_modules, waiting: nil}
 
-        {async_modules, remaining_groups} =
-          Enum.map_reduce(async_modules, state.async_groups, fn
-            {:module, module}, async_groups ->
-              {[module], async_groups}
+      has_async_groups? ->
+        groups = Enum.take(state.async_groups, count)
 
-            {:group, group}, async_groups ->
-              {group_modules, async_groups} = Map.pop!(async_groups, group)
-              {Enum.reverse(group_modules), async_groups}
+        {reply, remaining_groups} =
+          Enum.map_reduce(groups, state.async_groups, fn {group, entries}, async_groups ->
+            {entries, Map.delete(async_groups, group)}
           end)
 
-        GenServer.reply(from, async_modules)
+        GenServer.reply(from, reply)
+        %{state | async_groups: remaining_groups, waiting: nil}
 
-        %{
-          state
-          | async_groups: remaining_groups,
-            async_modules: remaining_modules,
-            waiting: nil
-        }
+      true ->
+        state
     end
   end
 
-  # :queue.split fails if the provided count is larger than the queue size;
-  # as we also want to return the values as a list later, we directly
-  # return {list, queue} instead of {queue, queue}
+  # :queue.split fails if the provided count is larger than the queue size.
+  # We also want to return the values as a list of lists, so we directly
+  # return {list, queue} instead of {queue, queue}.
   defp take_until(n, queue), do: take_until(n, queue, [])
 
   defp take_until(0, queue, acc), do: {Enum.reverse(acc), queue}
 
   defp take_until(n, queue, acc) do
     case :queue.out(queue) do
-      {{:value, item}, queue} -> take_until(n - 1, queue, [item | acc])
+      {{:value, item}, queue} -> take_until(n - 1, queue, [[item] | acc])
       {:empty, queue} -> {Enum.reverse(acc), queue}
     end
   end