Finish dry run implementation

Author: Nezteb

lib/ex_unit/lib/ex_unit/cli_formatter.ex

@@ -18,6 +18,7 @@ defmodule ExUnit.CLIFormatter do
     IO.puts("")
 
     config = %{
+      dry_run: opts[:dry_run],
       trace: opts[:trace],
       colors: colors(opts),
       width: get_terminal_width(),
@@ -154,7 +155,16 @@ defmodule ExUnit.CLIFormatter do
     {:noreply, config}
   end
 
-  def handle_cast({:module_finished, %ExUnit.TestModule{state: nil}}, config) do
+  def handle_cast({:module_finished, %ExUnit.TestModule{state: nil} = module}, config) do
+    if config.dry_run do
+      IO.puts("Test dry run:")
+      file_path = Path.relative_to_cwd(module.file)
+
+      Enum.each(module.tests, fn test ->
+        IO.puts("#{file_path}:#{test.tags.line}")
+      end)
+    end
+
     {:noreply, config}
   end
 
@@ -356,7 +366,11 @@ defmodule ExUnit.CLIFormatter do
       )
       |> if_true(
         config.excluded_counter > 0,
-        &(&1 <> " (#{config.excluded_counter} excluded)")
+        &(&1 <> ", (#{config.excluded_counter} excluded)")
+      )
+      |> if_true(
+        config.dry_run == true,
+        &(&1 <> " (dry run)")
       )
 
     cond do

lib/ex_unit/lib/ex_unit/runner.ex

@@ -44,27 +44,12 @@ defmodule ExUnit.Runner do
     config = configure(opts, manager, self(), stats_pid)
     :erlang.system_flag(:backtrace_depth, Keyword.fetch!(opts, :stacktrace_depth))
 
-    modules_to_restore =
-      if Keyword.fetch!(opts, :repeat_until_failure) > 0, do: {[], []}, else: nil
-
-    modules_to_restore =
-      if not opts[:dry_run] do
-        do_run(config, modules_to_restore, opts, load_us)
-      else
-        nil
-      end
-
-    stats = ExUnit.RunnerStats.stats(stats_pid)
-    EM.stop(config.manager)
-    after_suite_callbacks = Application.fetch_env!(:ex_unit, :after_suite)
-    Enum.each(after_suite_callbacks, fn callback -> callback.(stats) end)
-    {stats, modules_to_restore}
-  end
-
-  defp do_run(config, modules_to_restore, opts, load_us) do
     start_time = System.monotonic_time()
     EM.suite_started(config.manager, opts)
 
+    modules_to_restore =
+      if Keyword.fetch!(opts, :repeat_until_failure) > 0, do: {[], []}, else: nil
+
     {async_stop_time, modules_to_restore} = async_loop(config, %{}, false, modules_to_restore)
     stop_time = System.monotonic_time()
 
@@ -80,7 +65,11 @@ defmodule ExUnit.Runner do
     times_us = %{async: async_us, load: load_us, run: run_us}
     EM.suite_finished(config.manager, times_us)
 
-    modules_to_restore
+    stats = ExUnit.RunnerStats.stats(stats_pid)
+    EM.stop(config.manager)
+    after_suite_callbacks = Application.fetch_env!(:ex_unit, :after_suite)
+    Enum.each(after_suite_callbacks, fn callback -> callback.(stats) end)
+    {stats, modules_to_restore}
   end
 
   defp configure(opts, manager, runner_pid, stats_pid) do
@@ -318,6 +307,10 @@ defmodule ExUnit.Runner do
     {test_module, [], []}
   end
 
+  defp run_module_tests(%{dry_run: true}, test_module, _async?, tests) do
+    {test_module, [], tests}
+  end
+
   defp run_module_tests(config, test_module, async?, tests) do
     Process.put(@current_key, test_module)
     %ExUnit.TestModule{name: module, tags: tags, parameters: params} = test_module

lib/mix/test/mix/tasks/test_test.exs

@@ -770,38 +770,35 @@ defmodule Mix.Tasks.TestTest do
     end
   end
 
-  # TODO: Get to pass after deciding on implementation
-  @tag :skip
   describe "--dry-run" do
-    test "prints which tests would run without executing them" do
+    test "works with --stale" do
       in_fixture("test_stale", fn ->
-        File.write!("test/dry_run_test.exs", """
+        File.write!("test/dry_run_test_stale.exs", """
         defmodule DryRunTest do
           use ExUnit.Case
 
-          test "passing test" do
+          test "new test" do
             assert true
           end
-
-          test "failing test" do
-            assert false
-          end
         end
         """)
 
-        assert {output, 0} = mix_code(["test", "--dry-run", "--stale"])
-        assert output =~ "DRY RUN"
-        assert output =~ "test/dry_run_test.exs"
-        refute output =~ "Finished in"
+        output = mix(["test", "--dry-run", "--stale"])
+
+        assert output =~ "Test dry run:"
+        assert output =~ "test/dry_run_test_stale.exs:4"
+        assert output =~ "0 tests, 0 failures (dry run)"
       end)
     end
 
-    test "prints message when no tests would run" do
-      in_fixture("test_stale", fn ->
-        assert {output, 0} = mix_code(["test", "--dry-run", "non_existent_test.exs"])
-        assert output =~ "DRY RUN"
-        assert output =~ "No tests would run"
-        refute output =~ "Finished in"
+    test "works with --failed" do
+      in_fixture("test_failed", fn ->
+        _initial_run = mix(["test"])
+        output = mix(["test", "--dry-run", "--failed"])
+
+        assert output =~ "Test dry run:"
+        assert output =~ "test/passing_and_failing_test_failed.exs:5"
+        assert output =~ "0 tests, 0 failures (dry run)"
       end)
     end
   end