test_run 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a15a71d527a5bfc218b66b112fa17c190206b667
-  data.tar.gz: ae00269c6b9506995cb3c62106e0e2eea9a9513e
+  metadata.gz: 0dfb581e79ad2ee6189a16d9142b5b2f9599bea8
+  data.tar.gz: b7aefde679ecea6e53ccdf15ce30c997cb4c4b1b
 SHA512:
-  metadata.gz: 2550c215d5d98b04d1f1333acc3c79ebba130beaf92db8caa8eee08a5e94aa39105915eeb799bfddca7d9e6c4c56c8ad2faade2d85221cc3218bc9c3effaf3a9
-  data.tar.gz: 4758c47037e7588ec9dcbfbb55d863217f7bc15179fa29661e5130dbc053cc3e202af640bf5ad1f06109fa6dd36a511680956ab72c8fffd9489e1787d4beed88
+  metadata.gz: 7e9ab26f96fb3849ae28d3cbcd96ce085102f9587d3d75ca5761eba1748fa6530172ea726b0e61df341d36af3dfdf8e9622955fc5d02db6b97eb016c811fafb5
+  data.tar.gz: 1e8d2bbed3a5a87708364b7123e35a50dc7979425a21d0fc7d5552492ee829b91b43e34d25c4a20856ae40af5afbb496b34f68447d07d03e1be0cefaaf7f4a80

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 notes.txt
+*.gem

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in test_run.gemspec
 gemspec
+
+gem "minitest"
+gem "mocha"

data/bin/test_runner

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require "thor"
+require "test_run/searchers/git_searcher"
 require "test_run/tests/minitest/finder"
 require "test_run/tests/minitest/consolidator"
 require "test_run/shell/runner"
@@ -10,10 +11,11 @@ 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'
-      puts "use 'test_runner --help find' to see the help"
+      `test_runner --help find`
       exit
     end
 
@@ -23,13 +25,12 @@ class CLI < Thor
 
     )
 
-   find_results = TestRun::Tests::Minitest::Finder.find(input, shell, options)
+    searcher = TestRun::Searchers::GitSearcher.new(shell)
+    search_results = TestRun::Tests::Minitest::Finder.find(input, searcher)
 
-   test_wrapper = TestRun::Tests::Minitest::Consolidator.consolidate(find_results, shell)
+    test_wrapper = TestRun::Tests::Minitest::Consolidator.consolidate(search_results, shell, options[:all])
 
-   if test_wrapper.should_run?
-     shell.exec test_wrapper.to_command
-   end
+    shell.exec test_wrapper.to_command
   end
 
   default_task :find

data/lib/test_run.rb

@@ -1,5 +1,4 @@
 require "test_run/version"
 
 module TestRun
-  # Your code goes here...
 end

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

@@ -3,39 +3,82 @@ require "test_run/utils/path"
 require "test_run/tests/minitest/wrappers/single_test"
 require "test_run/tests/minitest/wrappers/single_file"
 require "test_run/tests/minitest/wrappers/multiple_files"
+require "test_run/utils/pluralize"
 
 module TestRun
   module Tests
     module Minitest
-      class Consolidator < Struct.new(:find_results, :shell)
+      class Consolidator < Struct.new(:search_results, :shell, :run_all)
+        include Utils::Pluralize
 
         def self.consolidate(*args)
           new(*args).consolidate
         end
 
         def consolidate
-          if find_results.empty?
-            puts "no results"
+          if search_results.empty?
+            shell.warn "Could not find any tests."
             exit
           end
 
-          if one_result?
-            Wrappers::SingleTest.new(find_results.first)
-          elsif one_test_file?
-            Wrappers::SingleFile.new(find_results.first[:file])
+          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
-            Wrappers::MultipleFiles.wrap(find_results.map {|r| r[:file] }, shell)
+            shell.notify "Found #{file_count_phrase}."
+            Wrappers::MultipleFiles.wrap(search_results.map {|r| r[:file] }, shell)
           end
         end
 
-        def one_test_file?
-          find_results.group_by {|f| f[:file]}.size == 1
+        def same_file?
+           file_count == 1
         end
 
         def one_result?
-          one_test_file? && find_results.first[:line]
+          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

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

@@ -3,11 +3,10 @@ require "test_run/searchers/git_searcher"
 module TestRun
   module Tests
     module Minitest
-      class Finder < Struct.new(:query, :shell, :searcher, :options)
+      class Finder < Struct.new(:query, :searcher)
 
-        def self.find(query, shell, options)
-          searcher = Searchers::GitSearcher.new(shell)
-          new(query, shell, searcher, options).find
+        def self.find(query, searcher)
+          new(query, searcher).find
         end
 
         def find
@@ -25,7 +24,8 @@ module TestRun
         private
 
         def tests_found_by_absolute_path
-          [ {file: query} ]
+          relative_file_path = query.sub(Dir.pwd, '').sub(/^\//, '')
+          [ {file: relative_file_path} ]
         end
 
         def tests_found_by_name

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

@@ -14,13 +14,8 @@ module TestRun
           end
 
           def to_command
-            roots.map(&:to_command).join("; cd -; \n\n")
+            roots.map(&:to_command).join("; cd -;\n\n")
           end
-
-          def should_run?
-            shell.confirm?("Found #{roots.inject(0) {|sum, root| sum + root.files.size }} test files in #{roots.size} apps/engines.  Run them all?")
-          end
-
         end
       end
     end

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

@@ -22,10 +22,6 @@ module TestRun
             path = exploded_path[exploded_path.rindex("test")..-1]
             File.join(path)
           end
-
-          def should_run?
-            true
-          end
         end
       end
     end

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

@@ -13,11 +13,6 @@ module TestRun
             @files = files.map {|f| f.is_a?(SingleFile) ? f : SingleFile.new(f)}
           end
 
-          def should_run?
-            # keep working here!
-            true
-          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
@@ -25,7 +20,6 @@ module TestRun
           def app_root
             files.first.app_root
           end
-
         end
       end
     end

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

@@ -30,11 +30,6 @@ module TestRun
             path = exploded_path[exploded_path.rindex("test")..-1]
             File.join(path)
           end
-
-          def should_run?
-            true
-          end
-
         end
       end
     end

data/lib/test_run/utils/pluralize.rb

@@ -0,0 +1,14 @@
+module TestRun
+  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_run/version.rb

@@ -1,3 +1,3 @@
 module TestRun
-  VERSION = "0.0.2"
+  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_run/searchers/git_searcher_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+require "test_run/searchers/git_searcher"
+
+module TestRun
+  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_run/tests/minitest/consolidator_integration_test.rb

@@ -0,0 +1,191 @@
+require "test_helper"
+require "test_run/tests/minitest/consolidator"
+
+module TestRun
+  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_run",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb --name=/test_run/", 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_run",
+            }
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+          assert_equal "cd ./engines/lawnmower && ruby -I test test/dir/file_test.rb --name=/test_run/", 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_run",
+            },
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_run_again",
+            },
+            {
+              file: "test/dir/file_test.rb",
+              line: "def test_run_some_more",
+            },
+          ]
+
+          consolidator = Consolidator.new(search_results, dummy_shell, false)
+
+          assert_equal "cd . && ruby -I test test/dir/file_test.rb --name=/test_run/", 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_run",
+            },
+            {
+              file: "test/other_dir/different_test.rb",
+              line: "def test_run",
+            },
+          ]
+
+          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_run/", 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_run",
+            },
+            {
+              file: "test/other_dir/different_test.rb",
+              line: "def test_run",
+            },
+          ]
+
+          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_run",
+            },
+            {
+              file: "engine2/root2/test/other_dir/different_test.rb",
+              line: "def test_run",
+            },
+          ]
+
+          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_run/tests/minitest/finder_test.rb

@@ -0,0 +1,71 @@
+require "test_helper"
+require "test_run/tests/minitest/finder"
+
+module TestRun
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_run
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pete Kinnecom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,7 +64,12 @@ files:
 - lib/test_run/tests/minitest/wrappers/single_root.rb
 - lib/test_run/tests/minitest/wrappers/single_test.rb
 - lib/test_run/utils/path.rb
+- lib/test_run/utils/pluralize.rb
 - lib/test_run/version.rb
+- test/test_helper.rb
+- test/test_run/searchers/git_searcher_test.rb
+- test/test_run/tests/minitest/consolidator_integration_test.rb
+- test/test_run/tests/minitest/finder_test.rb
 - test_run-0.0.1.gem
 - test_run.gemspec
 homepage: ''
@@ -91,4 +96,8 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Easily run tests
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/test_run/searchers/git_searcher_test.rb
+- test/test_run/tests/minitest/consolidator_integration_test.rb
+- test/test_run/tests/minitest/finder_test.rb