test_launcher 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbd6981a7b53e9af503b959d87bd3dc21bc312a0
+  data.tar.gz: 1c2978d49096d3af9cc704c30d83eb1c554cff48
+SHA512:
+  metadata.gz: 30a4da05547da73f41746d1a839052493938964094700ea009a9ff37c3506a8d1e9ec348a4cbe6c62fba22ff4587e0bea2fc7b8e9714dff7b7f99468e2ce4a24
+  data.tar.gz: 6d3fb76d08ef634a12108f74643e86f58e88b601b493e07f7ce72b2ef029a1fcb6562b8ffc5c162af223aa6f693fb49ca7523d1261c951defd923ba821b9490d

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+notes.txt
+*.gem

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in test_launcher.gemspec
+gemspec
+
+gem "minitest"
+gem "mocha"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Pete Kinnecom
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# TestLauncher
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'test_launcher'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install test_launcher
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/test_launcher/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/test_launcher

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "thor"
+require "test_launcher/searchers/git_searcher"
+require "test_launcher/tests/minitest/finder"
+require "test_launcher/tests/minitest/consolidator"
+require "test_launcher/shell/runner"
+
+class CLI < Thor
+
+  desc "find", <<-DESC
+    Find tests and run them. By trying to match an individual test or the name of a test file(s).
+  DESC
+  option :all, type: :boolean, desc: %{Run all tests found!}, default: false
+
+  def find(input)
+    if input == '--help'
+      `test_launcher --help find`
+      exit
+    end
+
+    shell = TestLauncher::Shell::Runner.new(
+      log_path: '/tmp/test_launcher.log',
+      working_directory: '.',
+
+    )
+
+    searcher = TestLauncher::Searchers::GitSearcher.new(shell)
+    search_results = TestLauncher::Tests::Minitest::Finder.find(input, searcher)
+
+    test_wrapper = TestLauncher::Tests::Minitest::Consolidator.consolidate(search_results, shell, options[:all])
+
+    shell.exec test_wrapper.to_command
+  end
+
+  default_task :find
+end
+
+CLI.start(ARGV)

data/bin/test_runner

@@ -0,0 +1 @@
+puts "`test_runner` no longer exists. Please use `test_launcher` instead (update any aliases you may have)"

data/lib/test_launcher.rb

@@ -0,0 +1,4 @@
+require "test_launcher/version"
+
+module TestLauncher
+end

data/lib/test_launcher/searchers/git_searcher.rb

@@ -0,0 +1,38 @@
+module TestLauncher
+  module Searchers
+    class GitSearcher < Struct.new(:shell)
+
+      def find_files(pattern)
+        shell.run("git ls-files '*#{pattern}*'")
+      end
+
+      def grep(regex, file_pattern: '*')
+        results = shell.run("git grep --untracked '#{regex}' -- '#{file_pattern}'")
+        results.map do |result|
+          interpret_grep_result(result)
+        end
+      end
+
+      private
+
+      def interpret_grep_result(grep_result)
+        splits = grep_result.split(/:/)
+        file = splits.shift.strip
+        # we rejoin on ':' because our
+        # code may have colons inside of it.
+        #
+        # example:
+        # path/to/file: run_method(a: A, b: B)
+        #
+        # so shift the first one out, then
+        # rejoin the rest
+        line = splits.join(':').strip
+
+        {
+          :file => file,
+          :line => line,
+        }
+      end
+    end
+  end
+end

data/lib/test_launcher/shell/color.rb

@@ -0,0 +1,26 @@
+module TestLauncher
+  module Shell
+    module Color
+      CODES = {
+        red: 31,
+        green: 32,
+        yellow: 33,
+        pink: 35,
+      }.freeze
+
+      CODES.each do |color, code|
+        self.send(:define_method, color) do |string|
+          colorize(string, code)
+        end
+      end
+
+      private
+
+      # colorization
+      def colorize(string, color_code)
+        "\e[#{color_code}m#{string}\e[0m"
+      end
+
+    end
+  end
+end

data/lib/test_launcher/shell/runner.rb

@@ -0,0 +1,66 @@
+require "test_launcher/shell/color"
+require "test_launcher/utils/path"
+
+module TestLauncher
+  module Shell
+    class Runner
+      include Color
+
+      CommandFailureError = Class.new(StandardError)
+
+      attr_accessor :working_directory, :log_path, :queue
+      private :working_directory, :log_path, :queue
+
+      def initialize(log_path:, working_directory:)
+        @working_directory = working_directory
+        @log_path = log_path
+
+        %x{echo "" > #{log_path}}
+        Dir.chdir(%x[ git rev-parse --show-toplevel ].chomp)
+      end
+
+      def run(cmd, dir: working_directory, &block)
+        command = "cd #{Utils::Path.relative_join(dir)} && #{cmd}"
+        handle_output_for(command)
+
+        shell_out(command).split("\n")
+      end
+
+      def exec(cmd)
+        notify cmd
+        Kernel.exec cmd
+      end
+
+      def warn(msg)
+        log msg.to_s
+        print "#{red(msg.to_s)}\n"
+      end
+
+      def notify(msg)
+        log msg.to_s
+        print "#{yellow(msg.to_s)}\n"
+      end
+
+      def confirm?(question)
+        warn "#{question} [Yn]"
+        answer = STDIN.gets.strip.downcase
+        return answer != 'n'
+      end
+
+      private
+
+      def log(msg)
+        %x{echo "#{msg.to_s}" >> #{log_path}}
+      end
+
+      def handle_output_for(cmd)
+        log(cmd)
+      end
+
+      def shell_out(command)
+        %x{ set -o pipefail && #{command} 2>> #{log_path} | tee -a #{log_path} }.chomp
+      end
+
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/consolidator.rb

@@ -0,0 +1,85 @@
+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
+
+        def self.consolidate(*args)
+          new(*args).consolidate
+        end
+
+        def consolidate
+          if search_results.empty?
+            shell.warn "Could not find any tests."
+            exit
+          end
+
+          if methods_found? && one_result?
+            shell.notify "Found #{methods_count_phrase} in #{file_count_phrase}."
+            Wrappers::SingleTest.new(search_results.first)
+          elsif methods_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?
+            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)
+          elsif files_found? && same_file?
+            shell.notify "Found #{file_count_phrase}."
+            Wrappers::SingleFile.new(search_results.first[:file])
+          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])
+          else
+            shell.notify "Found #{file_count_phrase}."
+            Wrappers::MultipleFiles.wrap(search_results.map {|r| r[:file] }, shell)
+          end
+        end
+
+        def same_file?
+           file_count == 1
+        end
+
+        def one_result?
+          same_file? && search_results.first[:line]
+        end
+
+        def methods_found?
+          !! search_results.first[:line]
+        end
+
+        def files_found?
+          ! methods_found?
+        end
+
+        def run_last_edited?
+          ! run_all
+        end
+
+        def last_edited
+          search_results.sort_by {|r| File.mtime(r[:file])}.last
+        end
+
+        def file_count
+          search_results.group_by {|f| f[:file]}.size
+        end
+
+        def methods_count_phrase
+          pluralize(search_results.size, "test method")
+        end
+
+        def file_count_phrase
+          pluralize(file_count, "file")
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/finder.rb

@@ -0,0 +1,50 @@
+require "test_launcher/searchers/git_searcher"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      class Finder < Struct.new(:query, :searcher)
+
+        def self.find(query, searcher)
+          new(query, searcher).find
+        end
+
+        def find
+          return tests_found_by_absolute_path if query.match(/^\//)
+
+          return tests_found_by_name unless tests_found_by_name.empty?
+
+          return tests_found_by_file_name unless tests_found_by_file_name.empty?
+
+          return tests_found_by_full_regex unless tests_found_by_full_regex.empty?
+
+          []
+        end
+
+        private
+
+        def tests_found_by_absolute_path
+          relative_file_path = query.sub(Dir.pwd, '').sub(/^\//, '')
+          [ {file: relative_file_path} ]
+        end
+
+        def tests_found_by_name
+          @tests_found_by_name ||= full_regex_search("^\s*def .*#{query}.*")
+        end
+
+        def tests_found_by_file_name
+          @tests_found_by_file_name ||= searcher.find_files(query).select { |f| f.match(/_test\.rb/) }.map {|f| {file: f} }
+        end
+
+        def tests_found_by_full_regex
+          # we ignore the matched line since we don't know what to do with it
+          @tests_found_by_full_regex ||= full_regex_search(query).map {|t| {file: t[:file]} }
+        end
+
+        def full_regex_search(regex)
+          searcher.grep(regex, file_pattern: '*_test.rb')
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/wrappers/multiple_files.rb

@@ -0,0 +1,23 @@
+require "test_launcher/tests/minitest/wrappers/single_root"
+require "test_launcher/tests/minitest/wrappers/multiple_roots"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      module Wrappers
+        module MultipleFiles
+
+          def self.wrap(files, shell)
+            wrapper = MultipleRoots.new(files, shell)
+
+            if wrapper.roots.size > 1
+              wrapper
+            else
+              wrapper.roots.first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/wrappers/multiple_roots.rb

@@ -0,0 +1,23 @@
+require "test_launcher/utils/path"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      module Wrappers
+        class MultipleRoots
+
+          attr_reader :roots, :shell
+
+          def initialize(files, shell)
+            @shell = shell
+            @roots = files.map {|f| SingleFile.new(f)}.group_by {|f| f.app_root}.map {|root, _files| SingleRoot.new(_files, shell)}
+          end
+
+          def to_command
+            roots.map(&:to_command).join("; cd -;\n\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/wrappers/single_file.rb

@@ -0,0 +1,29 @@
+require "test_launcher/utils/path"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      module Wrappers
+        class SingleFile < Struct.new(:file)
+
+          def to_command
+            %{cd #{File.join(app_root)} && ruby -I test #{File.join(relative_test_path)}}
+          end
+
+          def app_root
+            exploded_path = Utils::Path.split(file)
+
+            path = exploded_path[0...exploded_path.rindex("test")]
+            File.join(path)
+          end
+
+          def relative_test_path
+            exploded_path = Utils::Path.split(file)
+            path = exploded_path[exploded_path.rindex("test")..-1]
+            File.join(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/wrappers/single_root.rb

@@ -0,0 +1,27 @@
+require "test_launcher/utils/path"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      module Wrappers
+        class SingleRoot
+
+          attr_reader :files, :shell
+
+          def initialize(files, shell)
+            @shell = shell
+            @files = files.map {|f| f.is_a?(SingleFile) ? f : SingleFile.new(f)}
+          end
+
+          def to_command
+            %{cd #{app_root} && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + "/" + file) }' #{files.map(&:relative_test_path).join(" ")}}
+          end
+
+          def app_root
+            files.first.app_root
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/tests/minitest/wrappers/single_test.rb

@@ -0,0 +1,37 @@
+require "test_launcher/utils/path"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      module Wrappers
+        class SingleTest
+
+          attr_reader :file, :name
+          private :file, :name
+
+          def initialize(file:, line:)
+            @file = file
+            @name = line[/\s*def\s+(.*)/, 1]
+          end
+
+          def to_command
+            %{cd #{app_root} && ruby -I test #{relative_test_path} --name=/#{name}/}
+          end
+
+          def app_root
+            exploded_path = Utils::Path.split(file)
+
+            path = exploded_path[0...exploded_path.rindex("test")]
+            File.join(path)
+          end
+
+          def relative_test_path
+            exploded_path = Utils::Path.split(file)
+            path = exploded_path[exploded_path.rindex("test")..-1]
+            File.join(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/utils/path.rb

@@ -0,0 +1,32 @@
+require "pathname"
+
+module TestLauncher
+  module Utils
+    module Path
+
+      def self.split(filename)
+        self.prepend_pwd(Pathname.new(filename).each_filename.to_a)
+      end
+
+      def self.path_for(filename)
+        self.split(File.split(file)[0])
+      end
+
+      def self.join(*array)
+        File.join(*array)
+      end
+
+      def self.prepend_pwd(dirs)
+        if dirs[0] == "."
+          dirs
+        else
+          ["."] + dirs
+        end
+      end
+
+      def self.relative_join(array)
+        join(prepend_pwd(array))
+      end
+    end
+  end
+end

data/lib/test_launcher/utils/pluralize.rb

@@ -0,0 +1,14 @@
+module TestLauncher
+  module Utils
+    module Pluralize
+      def pluralize(count, singular)
+        phrase = "#{count} #{singular}"
+        if count == 1
+          phrase
+        else
+          "#{phrase}s"
+        end
+      end
+    end
+  end
+end

data/lib/test_launcher/version.rb

@@ -0,0 +1,3 @@
+module TestLauncher
+  VERSION = "0.0.3"
+end

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift(File.join(File.split(File.dirname(__FILE__))[0], 'lib'))
+require "minitest/autorun"
+require "mocha/mini_test"
+
+class TestCase < Minitest::Test
+  class DummyShell
+
+    def method_missing(method, *args)
+      instance_variable_set(:"@#{method}", [args])
+
+      self.class.send(:define_method, method) do |*a|
+        if ! instance_variable_get(:"@#{method}")
+          instance_variable_set(:"@#{method}", [a])
+        end
+      end
+    end
+
+    def recall(method)
+      instance_variable_get(:"@#{method}")
+    end
+  end
+
+  def assert_notified(string)
+    unless dummy_shell.recall(:notify).flatten.include?(string)
+      flunk <<-FLUNK
+      could not find: "#{string}"
+      shell.notify called with:
+      #{dummy_shell.recall(:notify)}
+      FLUNK
+    end
+  end
+
+  def assert_paragraphs_equal(expected, actual)
+    expecteds = expected.split("\n").map {|l| l.to_s.strip}
+    actuals = actual.split("\n").map {|l| l.to_s.strip}
+
+    assert_equal expecteds, actuals
+  end
+
+  private
+
+  def dummy_shell
+    @dummy_shell ||= DummyShell.new
+  end
+end

data/test/test_launcher/searchers/git_searcher_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+require "test_launcher/searchers/git_searcher"
+
+module TestLauncher
+  module Searchers
+    class MockShell
+      def run(cmd)
+        if cmd == "git ls-files '*file_pattern*'"
+          [
+            "file/path/one.rb",
+            "another_file/path/two.rb",
+          ]
+        elsif cmd == "git grep --untracked 'regex' -- 'file_pattern'"
+          [
+            "file/path/one.rb: some_lines(of_code)",
+            "another_file/path/two.rb:   Class::Thing::Stuff.new",
+          ]
+        else
+          raise ArgumentError.new("unmocked command")
+        end
+      end
+    end
+
+    class GitSearcherTest < TestCase
+
+      def test_find_files
+        searcher = GitSearcher.new(MockShell.new)
+
+        assert_equal ["file/path/one.rb", "another_file/path/two.rb"], searcher.find_files("file_pattern")
+      end
+
+      def test_grep
+        searcher = GitSearcher.new(MockShell.new)
+
+        expected = [
+          {
+            file: "file/path/one.rb",
+            line: "some_lines(of_code)",
+          },
+          {
+            file: "another_file/path/two.rb",
+            line: "Class::Thing::Stuff.new",
+          }
+        ]
+
+        assert_equal expected, searcher.grep("regex", file_pattern: "file_pattern")
+      end
+    end
+  end
+end

data/test/test_launcher/tests/minitest/consolidator_integration_test.rb

@@ -0,0 +1,191 @@
+require "test_helper"
+require "test_launcher/tests/minitest/consolidator"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      class ConsolidatorIntegrationTest < TestCase
+
+        def test_single_test_method__no_sub_dir
+          search_results = [
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb --name=/test_launcher/", consolidator.consolidate.to_command
+          assert_notified "Found 1 test method in 1 file."
+        end
+
+        def test_single_test_method__with_sub_dir
+          search_results = [
+            {
+              file: "engines/lawnmower/test/dir/file_test.rb",
+              line: "def test_launcher",
+            }
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+          assert_equal "cd ./engines/lawnmower && ruby -I test test/dir/file_test.rb --name=/test_launcher/", consolidator.consolidate.to_command
+          assert_notified "Found 1 test method in 1 file."
+        end
+
+        def test_multiple_test_methods_in_same_file
+          search_results = [
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher",
+            },
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher_again",
+            },
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher_some_more",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb --name=/test_launcher/", consolidator.consolidate.to_command
+          assert_notified "Found 3 test methods in 1 file."
+        end
+
+        def test_multiple_test_methods_in_different_files__last_edited
+          search_results = [
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher",
+            },
+            {
+              file: "test/other_dir/different_test.rb",
+              line: "def test_launcher",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+
+          File.expects(:mtime).with("test/dir/file_test.rb").returns(Time.new(2014, 01, 01))
+          File.expects(:mtime).with("test/other_dir/different_test.rb").returns(Time.new(2013, 01, 01))
+
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb --name=/test_launcher/", consolidator.consolidate.to_command
+          assert_notified "Found 2 test methods in 2 files."
+        end
+
+        def test_multiple_test_methods_in_different_files__run_all__same_root
+          search_results = [
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_launcher",
+            },
+            {
+              file: "test/other_dir/different_test.rb",
+              line: "def test_launcher",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, true)
+
+          assert_equal %{cd . && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + "/" + file) }' test/dir/file_test.rb test/other_dir/different_test.rb}, consolidator.consolidate.to_command
+          assert_notified "Found 2 files."
+        end
+
+        def test_multiple_test_methods_in_different_files__run_all__different_roots
+          search_results = [
+            {
+              file: "engine1/test/dir/file_test.rb",
+              line: "def test_launcher",
+            },
+            {
+              file: "engine2/root2/test/other_dir/different_test.rb",
+              line: "def test_launcher",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, true)
+          expected = <<-SHELL
+          cd ./engine1 && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + \"/\" + file) }' test/dir/file_test.rb; cd -;
+
+          cd ./engine2/root2 && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + \"/\" + file) }' test/other_dir/different_test.rb
+          SHELL
+
+          assert_paragraphs_equal expected, consolidator.consolidate.to_command
+          assert_notified "Found 2 files."
+        end
+
+        def test_one_file_found
+          search_results = [
+            {
+              file: "engine1/test/dir/file_test.rb",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, true)
+
+          assert_equal "cd ./engine1 && ruby -I test test/dir/file_test.rb", consolidator.consolidate.to_command
+          assert_notified "Found 1 file."
+        end
+
+        def test_multiple_files__last_edited
+          search_results = [
+            {
+              file: "test/dir/file_test.rb",
+            },
+            {
+              file: "test/other_dir/different_test.rb",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+
+          File.expects(:mtime).with("test/dir/file_test.rb").returns(Time.new(2014, 01, 01))
+          File.expects(:mtime).with("test/other_dir/different_test.rb").returns(Time.new(2013, 01, 01))
+
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb", consolidator.consolidate.to_command
+          assert_notified "Found 2 files."
+        end
+
+        def test_multiple_files__run_all__same_root
+          search_results = [
+            {
+              file: "engine1/test/dir/file_test.rb",
+            },
+            {
+              file: "engine1/test/other_dir/different_test.rb",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, true)
+          expected = %{cd ./engine1 && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + \"/\" + file) }' test/dir/file_test.rb test/other_dir/different_test.rb}
+
+          assert_equal expected, consolidator.consolidate.to_command
+          assert_notified "Found 2 files."
+        end
+
+        def test_multiple_files__run_all__different_roots
+          search_results = [
+            {
+              file: "engine1/test/dir/file_test.rb",
+            },
+            {
+              file: "engine2/root2/test/other_dir/different_test.rb",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, true)
+          expected = <<-SHELL
+          cd ./engine1 && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + \"/\" + file) }' test/dir/file_test.rb; cd -;
+
+          cd ./engine2/root2 && ruby -I test -e 'ARGV.each { |file| require(Dir.pwd + \"/\" + file) }' test/other_dir/different_test.rb
+          SHELL
+
+          assert_paragraphs_equal expected, consolidator.consolidate.to_command
+          assert_notified "Found 2 files."
+        end
+      end
+    end
+  end
+end

data/test/test_launcher/tests/minitest/finder_test.rb

@@ -0,0 +1,71 @@
+require "test_helper"
+require "test_launcher/tests/minitest/finder"
+
+module TestLauncher
+  module Tests
+    module Minitest
+      class FinderTest < TestCase
+
+        def test_find__absolute_path
+          Dir.expects(:pwd).returns("/absolute/path/root")
+          results = Finder.find("/absolute/path/root/test/dir/file_test.rb", "searcher_stub")
+          assert_equal [{file: "test/dir/file_test.rb"}], results
+        end
+
+        def test_find__found_by_name
+          expected = [{file: "test/file.rb", line: "def test_name"}]
+          searcher_mock = mock do
+            stubs(:grep).with("^\s*def .*test_name.*", file_pattern: "*_test.rb").returns(expected)
+          end
+
+          assert_equal expected, Finder.find("test_name", searcher_mock)
+        end
+
+        def test_find__found_by_file_name
+          searcher_mock = mock do
+            stubs(:grep).returns([])
+            stubs(:find_files).with("file_query").returns([
+               "dir/test/non_test_file_query.rb",
+               "dir/thing/file_query_test.rb",
+               "other_dir/other_thing/other_file_query_test.rb",
+            ])
+          end
+
+          expected = [
+              { file: "dir/thing/file_query_test.rb" },
+              { file: "other_dir/other_thing/other_file_query_test.rb" },
+            ]
+
+          assert_equal expected, Finder.find("file_query", searcher_mock)
+        end
+
+        def test_find__found_by_full_regex
+          searcher_mock = mock do
+            stubs(:grep).returns([])
+            stubs(:find_files).returns([])
+
+            stubs(:grep).with("full_regex_search", file_pattern: "*_test.rb").returns([
+              { file: "path/to/file_test.rb", line: "random_match"},
+              { file: "path/to/other_file_test.rb", line: "random_match_2"}
+            ])
+          end
+
+          expected = [
+              {file: "path/to/file_test.rb"},
+              {file: "path/to/other_file_test.rb"}
+            ]
+          assert_equal expected, Finder.find("full_regex_search", searcher_mock)
+        end
+
+        def test_find__nothing_found
+          searcher_mock = mock do
+            stubs(:grep).returns([])
+            stubs(:find_files).returns([])
+          end
+
+          assert_equal [], Finder.find("query", searcher_mock)
+        end
+      end
+    end
+  end
+end

data/test_launcher.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'test_launcher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "test_launcher"
+  spec.version       = TestLauncher::VERSION
+  spec.authors       = ["Pete Kinnecom"]
+  spec.email         = ["pete.kinnecom@appfolio.com"]
+  spec.summary       = %q{Easily run tests}
+  spec.description   = %q{no really}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: test_launcher
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Pete Kinnecom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: no really
+email:
+- pete.kinnecom@appfolio.com
+executables:
+- test_launcher
+- test_runner
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/test_launcher
+- bin/test_runner
+- lib/test_launcher.rb
+- lib/test_launcher/searchers/git_searcher.rb
+- lib/test_launcher/shell/color.rb
+- lib/test_launcher/shell/runner.rb
+- lib/test_launcher/tests/minitest/consolidator.rb
+- lib/test_launcher/tests/minitest/finder.rb
+- lib/test_launcher/tests/minitest/wrappers/multiple_files.rb
+- lib/test_launcher/tests/minitest/wrappers/multiple_roots.rb
+- lib/test_launcher/tests/minitest/wrappers/single_file.rb
+- lib/test_launcher/tests/minitest/wrappers/single_root.rb
+- lib/test_launcher/tests/minitest/wrappers/single_test.rb
+- lib/test_launcher/utils/path.rb
+- lib/test_launcher/utils/pluralize.rb
+- lib/test_launcher/version.rb
+- test/test_helper.rb
+- test/test_launcher/searchers/git_searcher_test.rb
+- test/test_launcher/tests/minitest/consolidator_integration_test.rb
+- test/test_launcher/tests/minitest/finder_test.rb
+- test_launcher.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Easily run tests
+test_files:
+- test/test_helper.rb
+- test/test_launcher/searchers/git_searcher_test.rb
+- test/test_launcher/tests/minitest/consolidator_integration_test.rb
+- test/test_launcher/tests/minitest/finder_test.rb
+has_rdoc: