test_launcher 0.1.0 → 1.0.0

data/lib/test_launcher/frameworks/implementation/collection.rb

@@ -0,0 +1,27 @@
+require "delegate"
+
+module TestLauncher
+  module Frameworks
+    module Implementation
+      class Collection < SimpleDelegator
+        alias :results :__getobj__
+
+        def file_count
+          results.group_by(&:file).size
+        end
+
+        def one_example?
+          examples_found? && results.size == 1
+        end
+
+        def examples_found?
+          results.any?(&:is_example?)
+        end
+
+        def last_edited
+          results.sort_by(&:mtime).last
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/{tests/minitest → frameworks/implementation}/consolidator.rb

@@ -1,15 +1,7 @@
-require "test_launcher/utils/path"
-
-require "test_launcher/tests/minitest/wrappers/single_test"
-require "test_launcher/tests/minitest/wrappers/single_file"
-require "test_launcher/tests/minitest/wrappers/multiple_files"
-require "test_launcher/utils/pluralize"
-
 module TestLauncher
-  module Tests
-    module Minitest
-      class Consolidator < Struct.new(:search_results, :shell, :run_all)
-        include Utils::Pluralize
+  module Frameworks
+    module Implementation
+      class Consolidator < Struct.new(:search_results, :shell, :runner, :run_all)
 
         def self.consolidate(*args)
           new(*args).consolidate
@@ -17,47 +9,44 @@ module TestLauncher
 
         def consolidate
           if search_results.empty?
-            shell.warn "Could not find any tests."
-            exit
-          end
-
-          if methods_found? && one_result?
+            nil
+          elsif one_example?
             shell.notify "Found #{methods_count_phrase} in #{file_count_phrase}."
-            Wrappers::SingleTest.new(search_results.first)
-          elsif methods_found? && same_file?
+            runner.single_example(search_results.first)
+          elsif examples_found? && same_file?
             shell.notify "Multiple test methods match in 1 file."
-            Wrappers::SingleFile.new(search_results.first[:file])
-          elsif methods_found? && run_last_edited?
+            runner.single_example(search_results.first)
+          elsif examples_found? && run_last_edited?
             shell.notify "Found #{methods_count_phrase} in #{file_count_phrase}."
             shell.notify "Running most recently edited. Run with '--all' to run all the tests."
-            Wrappers::SingleTest.new(last_edited)
+            runner.single_example(last_edited)
           elsif files_found? && same_file?
             shell.notify "Found #{file_count_phrase}."
-            Wrappers::SingleFile.new(search_results.first[:file])
+            runner.single_file(search_results.first)
           elsif files_found? && run_last_edited?
             shell.notify "Found #{file_count_phrase}."
             shell.notify "Running most recently edited. Run with '--all' to run all the tests."
-            Wrappers::SingleFile.new(last_edited[:file])
+            runner.single_file(last_edited)
           else
             shell.notify "Found #{file_count_phrase}."
-            Wrappers::MultipleFiles.wrap(search_results.map {|r| r[:file] }, shell)
+            runner.multiple_files(search_results.uniq {|sr| sr.file})
           end
         end
 
         def same_file?
-           file_count == 1
+          file_count == 1
         end
 
-        def one_result?
-          same_file? && search_results.first[:line]
+        def one_example?
+          search_results.one_example?
         end
 
-        def methods_found?
-          !! search_results.first[:line]
+        def examples_found?
+          search_results.examples_found?
         end
 
         def files_found?
-          ! methods_found?
+          ! examples_found?
         end
 
         def run_last_edited?
@@ -65,11 +54,11 @@ module TestLauncher
         end
 
         def last_edited
-          search_results.sort_by {|r| File.mtime(r[:file])}.last
+          search_results.last_edited
         end
 
         def file_count
-          search_results.group_by {|f| f[:file]}.size
+          search_results.file_count
         end
 
         def methods_count_phrase
@@ -79,6 +68,15 @@ module TestLauncher
         def file_count_phrase
           pluralize(file_count, "file")
         end
+
+        def pluralize(count, singular)
+          phrase = "#{count} #{singular}"
+          if count == 1
+            phrase
+          else
+            "#{phrase}s"
+          end
+        end
       end
     end
   end

data/lib/test_launcher/frameworks/implementation/locator.rb

@@ -0,0 +1,74 @@
+require "test_launcher/frameworks/implementation/test_case"
+require "test_launcher/frameworks/implementation/collection"
+
+module TestLauncher
+  module Frameworks
+    module Implementation
+      class Locator < Struct.new(:query, :searcher)
+        private :query, :searcher
+
+        def prioritized_results
+          Collection.new(_prioritized_results)
+        end
+
+        def _prioritized_results
+          return files_found_by_absolute_path unless files_found_by_absolute_path.empty?
+
+          return examples_found_by_name unless examples_found_by_name.empty?
+
+          return files_found_by_file_name unless files_found_by_file_name.empty?
+
+          return files_found_by_full_regex unless files_found_by_full_regex.empty?
+
+          []
+        end
+
+        private
+
+        def files_found_by_absolute_path
+          return [] unless query.match(/^\//)
+
+          relative_file_path = query.sub(Dir.pwd, '').sub(/^\//, '')
+          [ build_result(file: relative_file_path) ]
+        end
+
+        def examples_found_by_name
+          @examples_found_by_name ||= full_regex_search(regex_pattern).map {|r| build_result(file: r[:file], query: query)}
+        end
+
+        def files_found_by_file_name
+          @files_found_by_file_name ||= searcher.find_files(query).select { |f| f.match(file_name_regex) }.map {|f| build_result(file: f) }
+        end
+
+        def files_found_by_full_regex
+          # we ignore the matched line since we don't know what to do with it
+          @files_found_by_full_regex ||= full_regex_search(query).map {|r| build_result(file: r[:file]) }
+        end
+
+        def full_regex_search(regex)
+          searcher.grep(regex, file_pattern: file_name_pattern)
+        end
+
+        def build_result(file:, query: nil)
+          test_case_class.from_search(file: file, query: query)
+        end
+
+        def file_name_regex
+          raise NotImplementedError
+        end
+
+        def file_name_pattern
+          raise NotImplementedError
+        end
+
+        def regex_pattern
+          raise NotImplementedError
+        end
+
+        def test_case_class
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/frameworks/implementation/test_case.rb

@@ -0,0 +1,65 @@
+require "pathname"
+
+module TestLauncher
+  module Frameworks
+    module Implementation
+      class TestCase
+        attr_reader :file, :example
+
+        def self.from_search(file:, query: nil)
+          new(file: file, example: query)
+        end
+
+        def initialize(file:, example: nil)
+          @file = file
+          @example = example
+        end
+
+        def is_example?
+          !example.nil?
+        end
+
+        def mtime
+          @mtime ||= File.mtime(file)
+        end
+
+        def app_root
+          path = exploded_path[0...exploded_path.rindex(test_root_folder_name)]
+          File.join("/", path)
+        end
+
+        def test_root
+          File.join(app_root, test_root_folder_name)
+        end
+
+        def relative_test_path
+          path = exploded_path[exploded_path.rindex(test_root_folder_name)..-1]
+          File.join(path)
+        end
+
+        def spring_enabled?
+          return false if ENV['DISABLE_SPRING']
+
+          [
+            "bin/spring",
+            "bin/testunit"
+          ].any? {|f|
+            File.exist?(File.join(app_root, f))
+          }
+        end
+
+        def runner
+          raise NotImplementedError
+        end
+
+        def test_root_folder_name
+          raise NotImplementedError
+        end
+
+        def exploded_path
+          Pathname.new(file).each_filename.to_a
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/frameworks/minitest.rb

@@ -0,0 +1,67 @@
+require "test_launcher/frameworks/base"
+
+module TestLauncher
+  module Frameworks
+    module Minitest
+
+      def self.active?
+        ! Dir.glob("**/test/**/*_test.rb").empty?
+      end
+
+      class Runner < Base::Runner
+        def single_example(test_case, exact_match: false)
+
+          name =
+            if exact_match
+              "--name=#{test_case.example}"
+            else
+              "--name=/#{test_case.example}/"
+            end
+
+          %{cd #{test_case.app_root} && #{test_case.runner} #{test_case.relative_test_path} #{name}}
+        end
+
+        def one_or_more_files(test_cases)
+          %{cd #{test_cases.first.app_root} && #{test_cases.first.runner} #{test_cases.map(&:relative_test_path).join(" ")}}
+        end
+      end
+
+      class Locator < Base::Locator
+        private
+
+        def file_name_regex
+          /.*_test\.rb/
+        end
+
+        def file_name_pattern
+          "*_test.rb"
+        end
+
+        def regex_pattern
+          "^\s*def test_.*#{query.sub(/^test_/, "")}.*"
+        end
+
+        def test_case_class
+          TestCase
+        end
+      end
+
+      class TestCase < Base::TestCase
+
+        def runner
+          if spring_enabled?
+            "bundle exec spring testunit"
+          elsif is_example?
+            "bundle exec ruby -I test"
+          else
+            "bundle exec ruby -I test -e 'ARGV.each {|f| require(File.join(Dir.pwd, f))}'"
+          end
+        end
+
+        def test_root_folder_name
+          "test"
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/frameworks/rspec.rb

@@ -0,0 +1,50 @@
+require "shellwords"
+
+require "test_launcher/frameworks/base"
+
+module TestLauncher
+  module Frameworks
+    module RSpec
+
+      def self.active?
+        ! Dir.glob("**/*_spec.rb").empty?
+      end
+
+      class Runner < Base::Runner
+        def single_example(test_case)
+          %{cd #{test_case.app_root} && rspec #{test_case.relative_test_path} --example #{Shellwords.escape(test_case.example)}}
+        end
+
+        def one_or_more_files(test_cases)
+          %{cd #{test_cases.first.app_root} && rspec #{test_cases.map(&:relative_test_path).join(" ")}}
+        end
+      end
+
+      class Locator < Base::Locator
+        private
+
+        def file_name_regex
+          /.*_spec\.rb/
+        end
+
+        def file_name_pattern
+          '*_spec.rb'
+        end
+
+        def regex_pattern
+          "^\s*(it|context|(RSpec.)?describe) .*#{query}.* do.*"
+        end
+
+        def test_case_class
+          TestCase
+        end
+      end
+
+      class TestCase < Base::TestCase
+        def test_root_folder_name
+          "spec"
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/rubymine.rb

@@ -0,0 +1,26 @@
+require "test_launcher/rubymine/launcher"
+require "test_launcher/shell/runner"
+
+# To allow us to simply specify our run configuration as:
+#
+#  -r test_launcher/rubymine
+#
+# we need to put the currently executing script in with the args.
+#
+# Consider the following examples:
+#
+#   ruby -r test_launcher/rubymine /path/to/test.rb
+#
+# vs
+#
+#   ruby -r test_launcher/rubymine spring testunit /path/to/test.rb
+#
+# In one case, our test to run is $0 and in another case it's an ARGV.
+# So we throw them in the same bucket and let the launcher figure it
+# out.  It doesn't matter since we will `exec` a new command anyway.
+
+
+TestLauncher::Rubymine::Launcher.new(
+  args: [$0].concat(ARGV),
+  shell: TestLauncher::Shell::Runner.new(log_path: "/dev/null")
+).launch

data/lib/test_launcher/rubymine/launcher.rb

@@ -0,0 +1,55 @@
+require "test_launcher/frameworks/minitest"
+require "test_launcher/shell/runner"
+
+module TestLauncher
+  module Rubymine
+    class Launcher
+      def initialize(args:, shell:)
+        @args = args
+        @shell = shell
+      end
+
+      def launch
+        if args.any? {|a| a.match("ruby-debug-ide")}
+          shell.puts "test_launcher: hijacking and debugging"
+
+          debug_command = "cd #{test_case.app_root} && ruby -I test #{args.join(" ")}"
+          shell.puts debug_command
+          shell.exec debug_command
+        else
+          shell.puts "test_launcher: hijacking and running:"
+          shell.puts command
+
+          shell.exec command
+        end
+      end
+
+      private
+
+      def command
+        if test_case.is_example?
+          Frameworks::Minitest::Runner.new.single_example(test_case, exact_match: true)
+        else
+          Frameworks::Minitest::Runner.new.single_file(test_case)
+        end
+      end
+
+      def test_case
+        @test_case ||=
+          if args[-1].match('--name=')
+            Frameworks::Minitest::TestCase.new(file: args[-2], example: args[-1][/--name=(.*)/, 1])
+          else
+            Frameworks::Minitest::TestCase.new(file: args[-1])
+          end
+      end
+
+      def args
+        @args
+      end
+
+      def shell
+        @shell
+      end
+    end
+  end
+end