Add a test to ensure no hanging in ParallelCompiler

Author: José Valim

lib/elixir/test/elixir/kernel/cli_test.exs

@@ -5,7 +5,7 @@ import PathHelpers
 defmodule Kernel.CLI.InitTest do
   use ExUnit.Case, async: true
 
-  test :code_init do
+  test "handles code on initialization" do
     assert elixir('-e "IO.puts [?3]"') == '3\n'
 
     result = elixir('-e "IO.puts inspect(System.argv)" #{fixture_path("init_sample.exs")} -o 1 2 3')
@@ -16,7 +16,7 @@ end
 defmodule Kernel.CLI.OptionParsingTest do
   use ExUnit.Case, async: true
 
-  test :path do
+  test "properly parses paths" do
     root = fixture_path("../../..") |> to_char_list
     list = elixir('-pa "#{root}/*" -pz "#{root}/lib/*" -e "IO.inspect(:code.get_path, limit: :infinity)"')
     { path, _ } = Code.eval_string list, []
@@ -34,7 +34,7 @@ end
 defmodule Kernel.CLI.AtExitTest do
   use ExUnit.Case, async: true
 
-  test :at_exit do
+  test "invokes at_exit callbacks" do
     assert elixir(fixture_path("at_exit.exs") |> to_char_list) ==
       'goodbye cruel world with status 0\n'
   end
@@ -43,7 +43,7 @@ end
 defmodule Kernel.CLI.ErrorTest do
   use ExUnit.Case, async: true
 
-  test :code_error do
+  test "properly format errors" do
     assert :string.str('** (throw) 1', elixir('-e "throw 1"')) == 0
     assert :string.str('** (ErlangError) erlang error: 1', elixir('-e "error 1"')) == 0
 
@@ -52,32 +52,18 @@ defmodule Kernel.CLI.ErrorTest do
   end
 end
 
-defmodule Kernel.CLI.SyntaxErrorTest do
-  use ExUnit.Case, async: true
-
-  defp check_output(elixir_cmd, expected_msg) do
-    o = elixir(elixir_cmd)
-    assert :string.str(o, expected_msg) == 1, "Expected this output: `#{expected_msg}`\nbut got this output: `#{o}`"
-  end
-
-  test :syntax_code_error do
-    check_output('-e "[1,2"', '** (TokenMissingError) nofile:1: missing terminator: ]')
-    check_output('-e "case 1 end"', %C"** (SyntaxError) nofile:1: unexpected token: end")
-  end
-end
-
 defmodule Kernel.CLI.CompileTest do
   use ExUnit.Case, async: true
 
-  test :compile_code do
+  test "compiles code" do
     fixture = fixture_path "compile_sample.ex"
     assert elixirc('#{fixture} -o #{tmp_path}') == ''
     assert File.regular?(tmp_path "Elixir.CompileSample.beam")
   after
     File.rm(tmp_path("Elixir.CompileSample.beam"))
   end
 
-  test :compile_code_verbose do
+  test "compiles code with verbose mode" do
     fixture = fixture_path "compile_sample.ex"
     assert elixirc('#{fixture} -o #{tmp_path} --verbose') ==
       'Compiled #{fixture}\n'
@@ -86,16 +72,7 @@ defmodule Kernel.CLI.CompileTest do
     File.rm(tmp_path("Elixir.CompileSample.beam"))
   end
 
-  test :possible_deadlock do
-    output = elixirc('#{fixture_path("parallel_deadlock")} -o #{tmp_path}')
-    foo = '* #{fixture_path "parallel_deadlock/foo.ex"} is missing module Bar'
-    bar = '* #{fixture_path "parallel_deadlock/bar.ex"} is missing module Foo'
-    assert :string.str(output, foo) > 0, "expected foo.ex to miss module Bar"
-    assert :string.str(output, bar) > 0, "expected bar.ex to miss module Foo"
-    assert :string.str(output, 'elixir_compiler') == 0, "expected elixir_compiler to not be in output"
-  end
-
-  test :compile_missing_patterns do
+  test "fails on missing patterns" do
     fixture = fixture_path "compile_sample.ex"
     output = elixirc('#{fixture} non_existing.ex -o #{tmp_path}')
     assert :string.str(output, 'non_existing.ex') > 0, "expected non_existing.ex to be mentionned"
@@ -108,14 +85,36 @@ defmodule Kernel.CLI.ParallelCompilerTest do
   use ExUnit.Case
   import ExUnit.CaptureIO
 
-  test :files do
+  test "compiles files solving dependencies" do
     fixtures = [fixture_path("parallel_compiler/bar.ex"), fixture_path("parallel_compiler/foo.ex")]
     assert capture_io(fn ->
       assert [Bar, Foo] = Kernel.ParallelCompiler.files fixtures
     end) =~ "message_from_foo"
   end
 
-  test :warnings_as_errors do
+  test "does not hang on missing dependencies" do
+    fixtures = [fixture_path("parallel_compiler/bat.ex")]
+    assert capture_io(fn ->
+      assert_raise CompileError, fn ->
+        Kernel.ParallelCompiler.files fixtures
+      end
+    end) =~ "Compilation error"
+  end
+
+  test "handles possible deadlocks" do
+    fixtures = [fixture_path("parallel_deadlock/foo.ex"), fixture_path("parallel_deadlock/bar.ex")]
+
+    msg = capture_io(fn ->
+      assert_raise UndefinedFunctionError, fn ->
+        Kernel.ParallelCompiler.files fixtures
+      end
+    end)
+
+    assert msg =~ "* #{fixture_path "parallel_deadlock/foo.ex"} is missing module Bar"
+    assert msg =~ "* #{fixture_path "parallel_deadlock/bar.ex"} is missing module Foo"
+  end
+
+  test "warnings_as_errors" do
     warnings_as_errors = Code.compiler_options[:warnings_as_errors]
 
     try do