Ensure sync tests are executed

Author: josevalim

lib/ex_unit/lib/ex_unit/runner.ex

@@ -125,7 +125,7 @@ defmodule ExUnit.Runner do
 
         # Run all sync modules directly
         for pair <- sync_modules do
-          running = spawn_modules(config, [pair], false, %{})
+          running = spawn_modules(config, [[pair]], false, %{})
           running != %{} and wait_until_available(config, running)
         end
 
@@ -161,23 +161,18 @@ defmodule ExUnit.Runner do
     running
   end
 
-  defp spawn_modules(
-         config,
-         [{_group, group_modules} | modules],
-         async?,
-         running
-       ) do
+  defp spawn_modules(config, [[_ | _] = modules | groups], async?, running) do
     if max_failures_reached?(config) do
       running
     else
       {pid, ref} =
         spawn_monitor(fn ->
-          Enum.each(group_modules, fn {module, params} ->
+          Enum.each(modules, fn {module, params} ->
             run_module(config, module, async?, params)
           end)
         end)
 
-      spawn_modules(config, modules, async?, Map.put(running, ref, pid))
+      spawn_modules(config, groups, async?, Map.put(running, ref, pid))
     end
   end
 

lib/ex_unit/lib/ex_unit/server.ex

@@ -23,7 +23,7 @@ defmodule ExUnit.Server do
         [{name, %{}}]
       end
 
-    case GenServer.call(@name, {:add, {async?, group}, modules}, @timeout) do
+    case GenServer.call(@name, {:add, async?, group, modules}, @timeout) do
       :ok ->
         :ok
 
@@ -82,7 +82,7 @@ defmodule ExUnit.Server do
   # Called by the runner when --repeat-until-failure is used.
   def handle_call({:restore_modules, async_modules, sync_modules}, _from, state) do
     {async_modules, async_groups} =
-      Enum.reduce(async_modules, {[], []}, fn
+      Enum.map_reduce(async_modules, %{}, fn
         {nil, [module]}, {modules, groups} ->
           {[{:module, module} | modules], groups}
 
@@ -130,28 +130,28 @@ defmodule ExUnit.Server do
     {:reply, diff, take_modules(%{state | loaded: :done})}
   end
 
-  def handle_call({:add, {false = _async, _group}, names}, _from, %{loaded: loaded} = state)
+  def handle_call({:add, false = _async, _group, names}, _from, %{loaded: loaded} = state)
       when is_integer(loaded) do
     state =
       update_in(state.sync_modules, &Enum.reduce(names, &1, fn name, q -> :queue.in(name, q) end))
 
     {:reply, :ok, state}
   end
 
-  def handle_call({:add, {true = _async, nil = _group}, names}, _from, %{loaded: loaded} = state)
+  def handle_call({:add, true = _async, nil = _group, names}, _from, %{loaded: loaded} = state)
       when is_integer(loaded) do
     state =
       update_in(
         state.async_modules,
         &Enum.reduce(names, &1, fn name, q -> :queue.in({:module, name}, q) end)
       )
 
-    {:reply, :ok, state}
+    {:reply, :ok, take_modules(state)}
   end
 
-  def handle_call({:add, {true = _async, group}, names}, _from, %{loaded: loaded} = state)
+  def handle_call({:add, true = _async, group, names}, _from, %{loaded: loaded} = state)
       when is_integer(loaded) do
-    state =
+    {async_groups, async_modules} =
       case state.async_groups do
         %{^group => entries} = async_groups ->
           {%{async_groups | group => names ++ entries}, state.async_modules}
@@ -160,11 +160,13 @@ defmodule ExUnit.Server do
           {Map.put(async_groups, group, names), :queue.in({:group, group}, state.async_modules)}
       end
 
-    {:reply, :ok, state}
+    {:reply, :ok,
+     take_modules(%{state | async_groups: async_groups, async_modules: async_modules})}
   end
 
-  def handle_call({:add, {_async?, _group}, _names}, _from, state),
-    do: {:reply, :already_running, state}
+  def handle_call({:add, _async?, _group, _names}, _from, state) do
+    {:reply, :already_running, state}
+  end
 
   defp take_modules(%{waiting: nil} = state) do
     state
@@ -185,16 +187,16 @@ defmodule ExUnit.Server do
         {async_modules, remaining_modules} = take_until(count, state.async_modules)
 
         {async_modules, remaining_groups} =
-          Enum.reduce(async_modules, {[], state.async_groups}, fn
-            {:module, module}, {collected_modules, async_groups} ->
-              {[{nil, [module]} | collected_modules], async_groups}
+          Enum.map_reduce(async_modules, state.async_groups, fn
+            {:module, module}, async_groups ->
+              {[module], async_groups}
 
-            {:group, group}, {collected_modules, async_groups} ->
+            {:group, group}, async_groups ->
               {group_modules, async_groups} = Map.pop!(async_groups, group)
-              {[{group, Enum.reverse(group_modules)} | collected_modules], async_groups}
+              {Enum.reverse(group_modules), async_groups}
           end)
 
-        GenServer.reply(from, Enum.reverse(async_modules))
+        GenServer.reply(from, async_modules)
 
         %{
           state

lib/ex_unit/test/ex_unit_test.exs

@@ -1218,7 +1218,7 @@ defmodule ExUnitTest do
     assert third =~ "ThirdTestFIFO"
   end
 
-  test "async test groups are run in compile order (FIFO)" do
+  test "groups are run in compile order (FIFO)" do
     defmodule RedOneFIFO do
       use ExUnit.Case, async: true, group: :red
 
@@ -1266,7 +1266,7 @@ defmodule ExUnitTest do
     assert fourth =~ "BlueTwoFIFO"
   end
 
-  test "can filter async tests" do
+  test "filters async tests" do
     defmodule FirstTestAsyncTrue do
       use ExUnit.Case, async: true
 
@@ -1295,11 +1295,10 @@ defmodule ExUnitTest do
              run_with_filter([include: [async: true], exclude: [:test]], [])
 
     assert {%{failures: 0, skipped: 0, total: 3, excluded: 2}, _} =
-             run_with_filter([include: [async: false], exclude: [:test]], [
-               FirstTestAsyncTrue,
-               SecondTestAsyncTrue,
-               FirstTestAsyncFalse
-             ])
+             run_with_filter(
+               [include: [async: false], exclude: [:test]],
+               [FirstTestAsyncTrue, SecondTestAsyncTrue, FirstTestAsyncFalse]
+             )
   end
 
   ##  Helpers
@@ -1316,8 +1315,7 @@ defmodule ExUnitTest do
       |> Keyword.merge(filters)
       |> Keyword.merge(colors: [enabled: false])
 
-    output = capture_io(fn -> Process.put(:capture_result, ExUnit.Runner.run(opts, nil)) end)
-    {Process.get(:capture_result) |> elem(0), output}
+    with_io(fn -> ExUnit.Runner.run(opts, nil) |> elem(0) end)
   end
 
   defp next_message_in_mailbox() do