test_run 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bec50a9c524cc40a441ef84656924dde66c64180
-  data.tar.gz: e169e16a035000ab3d166b321154aa0a48cf4b45
+  metadata.gz: a15a71d527a5bfc218b66b112fa17c190206b667
+  data.tar.gz: ae00269c6b9506995cb3c62106e0e2eea9a9513e
 SHA512:
-  metadata.gz: ad89e33583acd9308650adda78584da91bcf2eb6d4d757afe549694627772f9e382b7f8a1dacb45e4b97db1f13bc6b299e8820692f693279005fd415df6019f2
-  data.tar.gz: 8ff9dcd11e12cd9d18ce096deeaa64c479d3224ace21cb659dd6974400be0a77dad6250a2661c359773eee64aed2044d6733fb11321e30ad92ce057fe5c6530a
+  metadata.gz: 2550c215d5d98b04d1f1333acc3c79ebba130beaf92db8caa8eee08a5e94aa39105915eeb799bfddca7d9e6c4c56c8ad2faade2d85221cc3218bc9c3effaf3a9
+  data.tar.gz: 4758c47037e7588ec9dcbfbb55d863217f7bc15179fa29661e5130dbc053cc3e202af640bf5ad1f06109fa6dd36a511680956ab72c8fffd9489e1787d4beed88

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+notes.txt

data/bin/test_runner

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "thor"
+require "test_run/tests/minitest/finder"
+require "test_run/tests/minitest/consolidator"
+require "test_run/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
+
+  def find(input)
+    if input == '--help'
+      puts "use 'test_runner --help find' to see the help"
+      exit
+    end
+
+    shell = TestRun::Shell::Runner.new(
+      log_path: '/tmp/test_run.log',
+      working_directory: '.',
+
+    )
+
+   find_results = TestRun::Tests::Minitest::Finder.find(input, shell, options)
+
+   test_wrapper = TestRun::Tests::Minitest::Consolidator.consolidate(find_results, shell)
+
+   if test_wrapper.should_run?
+     shell.exec test_wrapper.to_command
+   end
+  end
+
+  default_task :find
+end
+
+CLI.start(ARGV)

data/lib/test_run/searchers/git_searcher.rb

@@ -0,0 +1,38 @@
+module TestRun
+  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_run/shell/color.rb

@@ -0,0 +1,26 @@
+module TestRun
+  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_run/shell/runner.rb

@@ -0,0 +1,66 @@
+require "test_run/shell/color"
+require "test_run/utils/path"
+
+module TestRun
+  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_run/tests/minitest/consolidator.rb

@@ -0,0 +1,42 @@
+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"
+
+module TestRun
+  module Tests
+    module Minitest
+      class Consolidator < Struct.new(:find_results, :shell)
+
+        def self.consolidate(*args)
+          new(*args).consolidate
+        end
+
+        def consolidate
+          if find_results.empty?
+            puts "no results"
+            exit
+          end
+
+          if one_result?
+            Wrappers::SingleTest.new(find_results.first)
+          elsif one_test_file?
+            Wrappers::SingleFile.new(find_results.first[:file])
+          else
+            Wrappers::MultipleFiles.wrap(find_results.map {|r| r[:file] }, shell)
+          end
+        end
+
+        def one_test_file?
+          find_results.group_by {|f| f[:file]}.size == 1
+        end
+
+        def one_result?
+          one_test_file? && find_results.first[:line]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require "test_run/searchers/git_searcher"
+
+module TestRun
+  module Tests
+    module Minitest
+      class Finder < Struct.new(:query, :shell, :searcher, :options)
+
+        def self.find(query, shell, options)
+          searcher = Searchers::GitSearcher.new(shell)
+          new(query, shell, searcher, options).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
+          [ {file: query} ]
+        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_run/tests/minitest/wrappers/multiple_files.rb

@@ -0,0 +1,23 @@
+require "test_run/tests/minitest/wrappers/single_root"
+require "test_run/tests/minitest/wrappers/multiple_roots"
+
+module TestRun
+  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_run/tests/minitest/wrappers/multiple_roots.rb

@@ -0,0 +1,28 @@
+require "test_run/utils/path"
+
+module TestRun
+  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
+
+          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
+  end
+end

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

@@ -0,0 +1,33 @@
+require "test_run/utils/path"
+
+module TestRun
+  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
+
+          def should_run?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "test_run/utils/path"
+
+module TestRun
+  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 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
+
+          def app_root
+            files.first.app_root
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require "test_run/utils/path"
+
+module TestRun
+  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
+
+          def should_run?
+            true
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/test_run/utils/path.rb

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

@@ -1,3 +1,3 @@
 module TestRun
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test_run.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = TestRun::VERSION
   spec.authors       = ["Pete Kinnecom"]
   spec.email         = ["pete.kinnecom@appfolio.com"]
-  spec.summary       = %q{Write a short summary. Required.}
-  spec.description   = %q{Write a longer description. Optional.}
+  spec.summary       = %q{Easily run tests}
+  spec.description   = %q{no really}
   spec.homepage      = ""
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_run
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pete Kinnecom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2015-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,10 +38,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Write a longer description. Optional.
+description: no really
 email:
 - pete.kinnecom@appfolio.com
-executables: []
+executables:
+- test_runner
 extensions: []
 extra_rdoc_files: []
 files:
@@ -50,8 +51,21 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/test_runner
 - lib/test_run.rb
+- lib/test_run/searchers/git_searcher.rb
+- lib/test_run/shell/color.rb
+- lib/test_run/shell/runner.rb
+- lib/test_run/tests/minitest/consolidator.rb
+- lib/test_run/tests/minitest/finder.rb
+- lib/test_run/tests/minitest/wrappers/multiple_files.rb
+- lib/test_run/tests/minitest/wrappers/multiple_roots.rb
+- lib/test_run/tests/minitest/wrappers/single_file.rb
+- 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/version.rb
+- test_run-0.0.1.gem
 - test_run.gemspec
 homepage: ''
 licenses:
@@ -73,8 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Write a short summary. Required.
+summary: Easily run tests
 test_files: []