Add DynamicSupervisor.stop and streamline event manager code

Author: José Valim

lib/elixir/lib/dynamic_supervisor.ex

@@ -421,6 +421,22 @@ defmodule DynamicSupervisor do
     call(supervisor, :count_children) |> :maps.from_list()
   end
 
+  @doc """
+  Synchronously stops the given supervisor with the given `reason`.
+
+  It returns `:ok` if the supervisor terminates with the given
+  reason. If it terminates with another reason, the call exits.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report is logged.
+  """
+  @since "1.7.0"
+  @spec stop(Supervisor.supervisor(), reason :: term, timeout) :: :ok
+  def stop(supervisor, reason \\ :normal, timeout \\ :infinity) do
+    GenServer.stop(supervisor, reason, timeout)
+  end
+
   @doc """
   Receives a set of options that initializes a dynamic supervisor.
 

lib/elixir/test/elixir/dynamic_supervisor_test.exs

@@ -95,6 +95,9 @@ defmodule DynamicSupervisorTest do
       # And the initial call
       assert {:supervisor, DynamicSupervisorTest.Simple, 1} =
                :proc_lib.translate_initial_call(pid)
+
+      # And shuts down
+      assert DynamicSupervisor.stop(__MODULE__) == :ok
     end
 
     test "sets initial call to the same as a regular supervisor" do

lib/ex_unit/lib/ex_unit/event_manager.ex

@@ -17,11 +17,11 @@ defmodule ExUnit.EventManager do
   end
 
   def stop({sup, event}) do
-    for {_, pid, _, _} <- Supervisor.which_children(sup) do
+    for {_, pid, _, _} <- DynamicSupervisor.which_children(sup) do
       GenServer.stop(pid, :normal, @timeout)
     end
 
-    Supervisor.stop(sup)
+    DynamicSupervisor.stop(sup)
     :gen_event.stop(event)
   end
 

lib/ex_unit/lib/ex_unit/runner.ex

@@ -6,7 +6,9 @@ defmodule ExUnit.Runner do
   @rand_algorithm :exs1024
 
   def run(opts, load_us) do
-    {opts, config} = configure(opts)
+    {:ok, manager} = EM.start_link()
+    {:ok, stats} = EM.add_handler(manager, ExUnit.RunnerStats, opts)
+    {opts, config} = configure(manager, opts)
 
     :erlang.system_flag(:backtrace_depth, Keyword.fetch!(opts, :stacktrace_depth))
 
@@ -17,24 +19,20 @@ defmodule ExUnit.Runner do
       end)
 
     EM.suite_finished(config.manager, run_us, load_us)
-    result = ExUnit.RunnerStats.stats(config.stats)
+    result = ExUnit.RunnerStats.stats(stats)
     EM.stop(config.manager)
     result
   end
 
-  defp configure(opts) do
+  defp configure(manager, opts) do
     opts = normalize_opts(opts)
-
-    {:ok, manager} = EM.start_link()
-    {:ok, stats} = EM.add_handler(manager, ExUnit.RunnerStats, opts)
     Enum.each(opts[:formatters], &EM.add_handler(manager, &1, opts))
 
     config = %{
       capture_log: opts[:capture_log],
       exclude: opts[:exclude],
       include: opts[:include],
       manager: manager,
-      stats: stats,
       max_cases: opts[:max_cases],
       seed: opts[:seed],
       modules: :async,

lib/ex_unit/lib/ex_unit/runner_stats.ex

@@ -4,18 +4,12 @@ defmodule ExUnit.RunnerStats do
   use GenServer
   alias ExUnit.{Manifest, Test, TestModule}
 
-  @manifest ".ex_unit_results.elixir"
+  def stats(pid) do
+    GenServer.call(pid, :stats, :infinity)
+  end
 
   def init(opts) do
-    {manifest_file, old_manifest} =
-      case Keyword.fetch(opts, :manifest_path) do
-        :error ->
-          {nil, %{}}
-
-        {:ok, manifest_path} ->
-          manifest_file = Path.join(manifest_path, @manifest)
-          {manifest_file, Manifest.read(manifest_file)}
-      end
+    {manifest_file, old_manifest} = read_manifest(opts)
 
     state = %{
       total: 0,
@@ -30,8 +24,17 @@ defmodule ExUnit.RunnerStats do
     {:ok, state}
   end
 
-  def stats(pid) do
-    GenServer.call(pid, :stats, :infinity)
+  @manifest ".ex_unit_results.elixir"
+
+  defp read_manifest(opts) do
+    case Keyword.fetch(opts, :manifest_path) do
+      :error ->
+        {nil, %{}}
+
+      {:ok, manifest_path} ->
+        manifest_file = Path.join(manifest_path, @manifest)
+        {manifest_file, Manifest.read(manifest_file)}
+    end
   end
 
   def handle_call(:stats, _from, state) do