test_launcher 1.5.0 → 1.5.1

data/test/test_launcher/minitest_integration_test.rb

@@ -1,83 +1,74 @@
 require "test_helper"
-require "test_launcher/request"
+require "test_helpers/integration_helper"
 
 module TestLauncher
   class MinitestIntegrationTest < TestCase
+    include IntegrationHelper
+
     def test__single_method
-      launch("file_name_1__method_name_1")
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} --name=/file_name_1__method_name_1/", Shell::Runner.recall_exec
+      launch("file_name_1__method_name_1", framework: "minitest")
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} --name=file_name_1__method_name_1", shell_mock.recall_exec
     end
 
     def test__multiple_methods__same_file
-      launch("file_name_1")
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} --name=/file_name_1/", Shell::Runner.recall_exec
+      launch("file_name_1", framework: "minitest")
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} --name=/file_name_1/", shell_mock.recall_exec
     end
 
     def test__multiple_methods__different_files
-      launch("multiple_files__same_method")
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")} --name=/multiple_files__same_method/", Shell::Runner.recall_exec
+      launch("multiple_files__same_method", framework: "minitest")
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")} --name=multiple_files__same_method", shell_mock.recall_exec
     end
 
     def test__single_file
-      launch("class_1_test")
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", Shell::Runner.recall_exec
+      launch("class_1_test", framework: "minitest")
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", shell_mock.recall_exec
     end
 
     def test__uses_spring
-      launch("different_roo""t_test") # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest/test/different_root")} && bundle exec spring testunit #{system_path("test/test_launcher/fixtures/minitest/test/different_root/test/different_root_test.rb")}", Shell::Runner.recall_exec
+      launch("different_roo""t_test", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest/test/different_root")} && bundle exec spring testunit #{system_path("test/test_launcher/fixtures/minitest/test/different_root/test/different_root_test.rb")}", shell_mock.recall_exec
     end
 
     def test__multiple_files__found
-      launch("Root1""Dum""myTest""Class") # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", Shell::Runner.recall_exec
+      launch("Root1""Dum""myTest""Class", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", shell_mock.recall_exec
     end
 
     def test__multiple_files__found__all
-      launch("Root1""DummyTest""Class", run_all: true) # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", Shell::Runner.recall_exec
+      launch("Root1""DummyTest""Class", run_all: true, framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", shell_mock.recall_exec
     end
 
     def test__multiple_file_paths
-      launch("class_1_tes""t.rb class_2_test.rb") # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", Shell::Runner.recall_exec
+      launch("class_1_tes""t.rb class_2_test.rb", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}", shell_mock.recall_exec
     end
 
     def test__multiple_files__different_roots__all
-      launch("DummyTest""Class", run_all: true) # don't trigger the find in *this* file
+      launch("DummyTest""Class", run_all: true, framework: "minitest") # don't trigger the find in *this* file
       expected = "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} #{system_path("test/test_launcher/fixtures/minitest/test/class_2_test.rb")}; cd -;\n\ncd #{system_path("test/test_launcher/fixtures/minitest/test/different_root")} && bundle exec spring testunit #{system_path("test/test_launcher/fixtures/minitest/test/different_root/test/different_root_test.rb")}"
-      assert_equal expected, Shell::Runner.recall_exec
+      assert_equal expected, shell_mock.recall_exec
     end
 
     def test__regex
-      launch("Root1""DummyTest""Class1""Test") # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", Shell::Runner.recall_exec
+      launch("Root1""DummyTest""Class1""Test", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", shell_mock.recall_exec
     end
 
     def test__regex__does_not_test_helper__methods
-      launch("helper_meth""od") # don't trigger the find in *this* file
-      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", Shell::Runner.recall_exec
+      launch("helper_meth""od", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test -e 'ARGV.each {|f| require(f)}' #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")}", shell_mock.recall_exec
     end
 
-    def test__not_found
-      launch("not_found""thing")
-      assert_equal nil, Shell::Runner.recall_exec
+    def test__specified_name
+      launch("class_1_test.rb", name: "file_name_1__method_name_1", framework: "minitest") # don't trigger the find in *this* file
+      assert_equal "cd #{system_path("test/test_launcher/fixtures/minitest")} && bundle exec ruby -I test #{system_path("test/test_launcher/fixtures/minitest/test/class_1_test.rb")} --name=file_name_1__method_name_1", shell_mock.recall_exec
     end
 
-    private
-
-    def system_path(relative_dir)
-      File.join(Dir.pwd, relative_dir)
-    end
-
-    def launch(query, run_all: false)
-      request = Request.new(
-        query: query,
-        run_all: run_all,
-        framework: "minitest"
-      )
-
-      TestLauncher.launch(request)
+    def test__not_found
+      launch("not_found""thing", framework: "minitest")
+      assert_equal nil, shell_mock.recall_exec
     end
 
   end

data/test/test_launcher/queries/example_name_query_test.rb

@@ -0,0 +1,217 @@
+require "test_helper"
+require "test_helpers/mocks"
+require "test_launcher/queries"
+require "test_launcher/frameworks/minitest"
+
+module TestLauncher
+  module Queries
+    class ExampleNameQueryTest < TestCase
+      include DefaultMocks
+
+      def raw_searcher
+        @raw_searcher ||= MemorySearcher.new do |searcher|
+          searcher.mock_file do |f|
+            f.path "file_1_test.rb"
+            f.mtime Time.now - 3000
+            f.contents <<-RB
+              class SingleTest
+                def test__one_example
+                  matches_single
+                end
+
+                def test__same_file_1
+                end
+
+                def test__same_file_2
+                end
+
+                def test__different_files
+                end
+              end
+            RB
+          end
+
+          searcher.mock_file do |f|
+            f.path "file_2_test.rb"
+            f.mtime Time.now
+            f.contents <<-RB
+              class MultipleMatches1Test
+                def test__different_files
+                end
+              end
+            RB
+          end
+
+          searcher.mock_file do |f|
+            f.path "multiple_matches_2_test.rb"
+            f.mtime Time.now
+            f.contents <<-RB
+              class MultipleMatches2Test
+                def test__1
+                  multiple_matches_2
+                end
+
+                def test__2
+                  multiple_matches_2
+                end
+              end
+            RB
+          end
+        end
+      end
+
+      def searcher
+        @searcher ||= Frameworks::Minitest::Searcher.new(raw_searcher)
+      end
+
+      def runner
+        @runner ||= MockRunner.new do |m|
+
+          m.impl :single_example do |test_case|
+            "single_example #{test_case.file} #{test_case.example}"
+          end
+
+          m.impl :multiple_examples_same_file do |test_cases|
+            "multiple_examples_same_file #{test_cases.first.file} #{test_cases.first.example}"
+          end
+
+          m.impl :multiple_files do |test_cases|
+            "multiple_files #{test_cases.map(&:file).join(" ")}"
+          end
+        end
+      end
+
+      def test_command__example_not_found__returns_nil
+        request = MockRequest.new(
+          search_string: "not_found",
+          searcher: searcher
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        assert_equal nil, command
+      end
+
+      def test_command__one_example_found
+        request = MockRequest.new(
+          search_string: "one_example",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        assert_equal "single_example file_1_test.rb one_example", command
+      end
+
+      def test_command__one_example_found__notifies
+        request = MockRequest.new(
+          search_string: "one_example",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        messages = [
+          ["Found 1 example in 1 file."],
+        ]
+        assert_equal messages, default_shell.recall(:notify)
+      end
+
+      def test_command__multiple_examples__one_file
+        request = MockRequest.new(
+          search_string: "same_file",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        assert_equal "multiple_examples_same_file file_1_test.rb same_file", command
+      end
+
+      def test_command__multiple_examples__one_file__notifies
+        request = MockRequest.new(
+          search_string: "same_file",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        messages = [
+          ["Found 2 examples in 1 file."],
+        ]
+        assert_equal messages, default_shell.recall(:notify)
+      end
+
+      def test_command__multiple_examples__multiple_files__no_all
+        request = MockRequest.new(
+          search_string: "different_files",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: false
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        assert_equal "single_example file_2_test.rb different_files", command
+      end
+
+      def test_command__multiple_examples__multiple_files__no_all__notifies
+        request = MockRequest.new(
+          search_string: "different_files",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: false
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        messages = [
+          ["Found 2 examples in 2 files."],
+          ["Running most recently edited. Run with '--all' to run all the tests."],
+        ]
+        assert_equal messages, default_shell.recall(:notify)
+      end
+
+      def test_command__multiple_examples__multiple_files__all
+        request = MockRequest.new(
+          search_string: "different_files",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: true
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        assert_equal "multiple_files file_1_test.rb file_2_test.rb", command
+      end
+
+      def test_command__multiple_examples__multiple_files__all__notifies
+        request = MockRequest.new(
+          search_string: "different_files",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: true
+        )
+
+        command = ExampleNameQuery.new(request, default_command_finder).command
+
+        messages = [
+          ["Found 2 examples in 2 files."],
+        ]
+        assert_equal messages, default_shell.recall(:notify)
+      end
+    end
+  end
+end

data/test/test_launcher/queries/full_regex_query_test.rb

@@ -0,0 +1,153 @@
+require "test_helper"
+require "test_helpers/mocks"
+require "test_launcher/queries"
+require "test_launcher/frameworks/minitest"
+
+module TestLauncher
+  module Queries
+    class FullRegexQueryTest < TestCase
+      include DefaultMocks
+
+      def raw_searcher
+        @raw_searcher ||= MemorySearcher.new do |searcher|
+          searcher.mock_file do |f|
+            f.path "single_test.rb"
+            f.contents <<-RB
+              class SingleTest
+                def test__1
+                  matches_single
+                end
+              end
+            RB
+          end
+
+          searcher.mock_file do |f|
+            f.path "multiple_matches_1_test.rb"
+            f.mtime Time.now - 3000
+            f.contents <<-RB
+              class MultipleMatches1Test
+                def test__1
+                  multiple_matches_1
+                end
+
+                def test__2
+                  multiple_matches_1
+                end
+              end
+            RB
+          end
+
+          searcher.mock_file do |f|
+            f.path "multiple_matches_2_test.rb"
+            f.mtime Time.now
+            f.contents <<-RB
+              class MultipleMatches2Test
+                def test__1
+                  multiple_matches_2
+                end
+
+                def test__2
+                  multiple_matches_2
+                end
+              end
+            RB
+          end
+        end
+      end
+
+      def searcher
+        @searcher ||= Frameworks::Minitest::Searcher.new(raw_searcher)
+      end
+
+      def runner
+        @runner ||= MockRunner.new do |m|
+          m.impl :single_file do |test_case|
+            case test_case.file
+            when "single_test.rb"
+              "single_file single_test.rb"
+            when "multiple_matches_1_test.rb"
+              "single_file multiple_matches_1_test.rb"
+            when "multiple_matches_2_test.rb"
+              "single_file multiple_matches_2_test.rb"
+            else
+              raise "unmocked single_file: #{test_case.file}"
+            end
+          end
+
+          m.impl :multiple_files do |test_cases|
+            case test_cases.map(&:file)
+            when ["multiple_matches_1_test.rb", "multiple_matches_2_test.rb"]
+              "multiple_files multiple_matches_1_test.rb multiple_matches_2_test.rb"
+            else
+              raise "unmocked multiple_files: #{test_cases}"
+            end
+          end
+        end
+      end
+
+      def test_command__regex_not_found
+        request = MockRequest.new(
+          search_string: "not_found",
+          searcher: searcher
+        )
+
+        command = FullRegexQuery.new(request, default_command_finder).command
+        assert_equal nil, command
+      end
+
+      def test_command__single_match
+        request = MockRequest.new(
+          search_string: "single",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = FullRegexQuery.new(request, default_command_finder).command
+
+        assert_equal "single_file single_test.rb", command
+      end
+
+      def test_command__multiple_matches_same_file
+        request = MockRequest.new(
+          search_string: "multiple_matches_1",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell
+        )
+
+        command = FullRegexQuery.new(request, default_command_finder).command
+
+        assert_equal "single_file multiple_matches_1_test.rb", command
+      end
+
+      def test_command__multiple_matches_different_files__no_all
+        request = MockRequest.new(
+          search_string: "multiple_matches",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: false
+        )
+
+        command = FullRegexQuery.new(request, default_command_finder).command
+
+        assert_equal "single_file multiple_matches_2_test.rb", command
+      end
+
+      def test_command__multiple_matches_different_files__all
+        request = MockRequest.new(
+          search_string: "multiple_matches",
+          searcher: searcher,
+          runner: runner,
+          shell: default_shell,
+          run_all?: true
+        )
+
+        command = FullRegexQuery.new(request, default_command_finder).command
+
+        assert_equal "multiple_files multiple_matches_1_test.rb multiple_matches_2_test.rb", command
+      end
+    end
+  end
+end

data/test/test_launcher/queries/generic_query_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+require "test_helpers/mocks"
+require "test_launcher/queries"
+
+module TestLauncher
+  module Queries
+    class GenericQueryTest < TestCase
+      include DefaultMocks
+
+      def test__specified_name
+        command_finder = Mock.new(Queries::CommandFinder, specified_name: :specified_name)
+
+        assert_equal :specified_name, GenericQuery.new(MockRequest.new(example_name: "name_present"), command_finder).command
+      end
+
+      def test__example_name
+        command_finder = Mock.new(Queries::CommandFinder, full_search: :full_search)
+
+        assert_equal :full_search, GenericQuery.new(MockRequest.new(example_name: nil), command_finder).command
+      end
+    end
+  end
+end

data/test/test_launcher/queries/line_number_query_test.rb

@@ -0,0 +1,107 @@
+require "test_helper"
+require "test_helpers/mocks"
+require "test_launcher/queries"
+
+module TestLauncher
+  module Queries
+    class LineNumberQueryTest < TestCase
+      include DefaultMocks
+
+      def searcher
+        @searcher ||= MockSearcher.new do |m|
+          m.impl :by_line do |file, line_number|
+            case [file, line_number]
+            when ["not_found", 1]
+              nil
+            when ["found", 17]
+              {file: "found", example_name: "test_example", line_number: 14}
+            when ["found", 1]
+              {file: "found"}
+            when ["found", 9999]
+              raise "invalid line number"
+            when ["multiple", 1]
+              raise "multiple files matched with line query"
+            else
+              raise "unmocked search_string: #{file}, #{line_number}"
+            end
+          end
+        end
+      end
+
+      def create_mock_request(**attrs)
+        MockRequest.new(**attrs) do |m|
+          m.impl(:test_case) do |file:, example: nil, request:, line_number: nil|
+            case [file, example]
+            when ["found", nil]
+              whole_file_test_case
+            when ["found", "test_example"]
+              example_name_test_case
+            else
+              raise "unmocked file: #{file}"
+            end
+          end
+        end
+      end
+
+      def whole_file_test_case
+        @whole_file_test_case ||= MockTestCase.new(file: "found")
+      end
+
+      def example_name_test_case
+        @example_name_test_case ||= MockTestCase.new(file: "found", example_name: "test_example")
+      end
+
+      def test_command__file_not_found
+        request = create_mock_request(
+          search_string: "not_found:1",
+          searcher: searcher
+        )
+
+        command = LineNumberQuery.new(request, default_command_finder).command
+        assert_equal nil, command
+      end
+
+      def test_command__search_string_does_not_have_colon
+        request = create_mock_request(
+          search_string: "not_found",
+          searcher: searcher
+        )
+
+        command = LineNumberQuery.new(request, default_command_finder).command
+
+        assert_equal nil, command
+      end
+
+      def test_command__file_found__line_number_not_in_example
+        request = create_mock_request(
+          search_string: "found:1",
+          searcher: searcher,
+          runner: default_runner,
+          shell: default_shell
+        )
+
+        command = LineNumberQuery.new(request, default_command_finder).command
+
+        assert_equal [[whole_file_test_case]], default_runner.recall(:single_file)
+
+        assert_equal "single_file_return", command
+      end
+
+
+      def test_command__file_found__line_number_inside_example
+        request = create_mock_request(
+          search_string: "found:17",
+          searcher: searcher,
+          runner: default_runner,
+          shell: default_shell
+        )
+
+        command = LineNumberQuery.new(request, default_command_finder).command
+
+        assert_equal [[example_name_test_case]], default_runner.recall(:single_example)
+
+        assert_equal "single_example_return", command
+      end
+    end
+  end
+end