Preserve files with no line filter on mix test

Before this patch, if you invoked:

    mix test test/foo_test.exs:13 test/bar_test.exs

We would include a location filter only for foo_test.exs
and no tests in bar_test.exs would run. We now ensure
that the full location of files with line filters are
included as tags, as long as any file is included.

Closes #14445.

Author: josevalim

lib/ex_unit/lib/ex_unit/filters.ex

@@ -33,33 +33,32 @@ defmodule ExUnit.Filters do
   """
   @spec parse_paths([String.t()]) :: {[String.t()], ex_unit_opts}
   def parse_paths(file_paths) do
-    {parsed_paths, locations} =
-      Enum.map_reduce(file_paths, [], fn file_path, locations ->
-        case extract_line_numbers(file_path) do
-          {path, []} -> {path, locations}
-          {path, lines} -> {path, [{:location, {path, lines}} | locations]}
-        end
+    {parsed_paths, {lines?, locations}} =
+      Enum.map_reduce(file_paths, {false, []}, fn file_path, {lines?, locations} ->
+        {path, location} = extract_location(file_path)
+        {path, {lines? or is_tuple(location), [{:location, location} | locations]}}
       end)
 
     ex_unit_opts =
-      if locations == [], do: [], else: [exclude: [:test], include: Enum.reverse(locations)]
+      if lines?, do: [exclude: [:test], include: Enum.reverse(locations)], else: []
 
     {parsed_paths, ex_unit_opts}
   end
 
-  defp extract_line_numbers(file_path) do
+  defp extract_location(file_path) do
     case Path.relative_to_cwd(file_path) |> String.split(":") do
       [path] ->
-        {path, []}
+        {path, path}
 
       [path | parts] ->
         {path_parts, line_numbers} = Enum.split_while(parts, &(to_line_number(&1) == nil))
         path = Enum.join([path | path_parts], ":") |> Path.split() |> Path.join()
         lines = for n <- line_numbers, valid_number = validate_line_number(n), do: valid_number
 
         case lines do
-          [line] -> {path, line}
-          lines -> {path, lines}
+          [] -> {path, path}
+          [line] -> {path, {path, line}}
+          lines -> {path, {path, lines}}
         end
     end
   end
@@ -145,8 +144,12 @@ defmodule ExUnit.Filters do
     end)
   end
 
-  defp parse_kv(:line, line) when is_binary(line), do: {:line, String.to_integer(line)}
-  defp parse_kv(:location, loc) when is_binary(loc), do: {:location, extract_line_numbers(loc)}
+  defp parse_kv(:line, line) when is_binary(line),
+    do: {:line, String.to_integer(line)}
+
+  defp parse_kv(:location, loc) when is_binary(loc),
+    do: {:location, extract_location(loc) |> elem(1)}
+
   defp parse_kv(key, value), do: {key, value}
 
   @doc """
@@ -240,7 +243,12 @@ defmodule ExUnit.Filters do
     end
   end
 
-  defp has_tag({:location, {path, lines}}, %{line: _, describe_line: _} = tags, collection) do
+  defp has_tag({:location, path}, %{file: file}, _collection) when is_binary(path) do
+    String.ends_with?(file, path)
+  end
+
+  defp has_tag({:location, {path, lines}}, %{line: _, describe_line: _} = tags, collection)
+       when is_binary(path) do
     String.ends_with?(tags.file, path) and
       lines |> List.wrap() |> Enum.any?(&has_tag({:line, &1}, tags, collection))
   end

lib/ex_unit/test/ex_unit/filters_test.exs

@@ -188,11 +188,48 @@ defmodule ExUnit.FiltersTest do
              {:excluded, "due to line filter"}
   end
 
+  test "evaluating filter uses special rules for location" do
+    tests = [
+      %ExUnit.Test{tags: %{line: 3, describe_line: 2}},
+      %ExUnit.Test{tags: %{line: 5, describe_line: nil}}
+    ]
+
+    assert ExUnit.Filters.eval(
+             [location: "foo_test.exs"],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == :ok
+
+    assert ExUnit.Filters.eval(
+             [location: "bar_test.exs"],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == {:excluded, "due to line filter"}
+
+    assert ExUnit.Filters.eval(
+             [location: {"foo_test.exs", 3}],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == :ok
+
+    assert ExUnit.Filters.eval(
+             [location: {"bar_test.exs", 3}],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == {:excluded, "due to line filter"}
+  end
+
   test "parsing filters" do
     assert ExUnit.Filters.parse(["run"]) == [:run]
     assert ExUnit.Filters.parse(["run:true"]) == [run: "true"]
     assert ExUnit.Filters.parse(["run:test"]) == [run: "test"]
     assert ExUnit.Filters.parse(["line:9"]) == [line: 9]
+    assert ExUnit.Filters.parse(["location:foo.exs"]) == [location: "foo.exs"]
+    assert ExUnit.Filters.parse(["location:foo.exs:invalid"]) == [location: "foo.exs:invalid"]
     assert ExUnit.Filters.parse(["location:foo.exs:9"]) == [location: {"foo.exs", 9}]
     assert ExUnit.Filters.parse(["location:foo.exs:9:11"]) == [location: {"foo.exs", [9, 11]}]
   end
@@ -248,11 +285,14 @@ defmodule ExUnit.FiltersTest do
       fixed_path = path |> Path.split() |> Path.join()
       fixed_other_path = other_path |> Path.split() |> Path.join()
 
+      assert ExUnit.Filters.parse_paths([path, other_path]) ==
+               {[fixed_path, fixed_other_path], []}
+
       assert ExUnit.Filters.parse_paths([path, "#{other_path}:456:789"]) ==
                {[fixed_path, fixed_other_path],
                 [
                   exclude: [:test],
-                  include: [location: {fixed_other_path, [456, 789]}]
+                  include: [location: fixed_path, location: {fixed_other_path, [456, 789]}]
                 ]}
 
       assert ExUnit.Filters.parse_paths(["#{path}:123", "#{other_path}:456"]) ==