parallel_tests-fine_grain_test 0.2.0

data/lib/parallel_tests/fine_grain_test/minitest.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require_relative 'minitest/extension'
+
+Minitest.singleton_class.prepend ::ParallelTests::FineGrainTest::Minitest::Extension

data/lib/parallel_tests/fine_grain_test/minitest/extension.rb

@@ -0,0 +1,27 @@
+require_relative 'suite'
+
+module ParallelTests
+  module FineGrainTest
+    module Minitest
+      module Runnable
+        def run_one_method(klass, method_name, _)
+          ::Minitest.fine_grain_suite.add(klass, method_name)
+        end
+      end
+
+      module Extension
+        attr_reader :fine_grain_suite
+
+        def __run(reporter, options)
+          ::Minitest::Runnable.singleton_class.prepend Runnable
+
+          @fine_grain_suite = Suite.new
+          super(reporter, options)
+          @fine_grain_suite.run(reporter, options)
+        ensure
+          @fine_grain_suite = nil
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/minitest/suite.rb

@@ -0,0 +1,35 @@
+require 'parallel_tests/fine_grain_test/test_case'
+require 'parallel_tests/fine_grain_test/file_queue'
+require 'parallel_tests/fine_grain_test/runtime_logger'
+
+module ParallelTests
+  module FineGrainTest
+    module Minitest
+      class Suite
+        def initialize(file_queue = FileQueue.new, runtime_logger = RuntimeLogger.new)
+          @test_cases = []
+          @file_queue = file_queue
+          @runtime_logger = runtime_logger
+        end
+
+        def add(klass, method_name)
+          @test_cases << TestCase.new(klass, method_name)
+        end
+
+        def run(reporter, _)
+          @file_queue.enq_all(@test_cases) do |tcs|
+            runtimes = @runtime_logger.runtimes
+            @runtime_logger.reset
+            tcs.sort_by { |test_case| runtimes[test_case] || 0 }.reverse
+          end
+
+          until (test_case = @file_queue.deq).nil?
+            @runtime_logger.log_runtime(test_case) do
+              reporter.record ::Minitest.run_one_method(test_case.suite, test_case.name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/railtie.rb

@@ -0,0 +1,8 @@
+# rake tasks for Rails 3+
+module ParallelTests
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require 'parallel_tests/fine_grain_test/tasks'
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/runner.rb

@@ -0,0 +1,27 @@
+require 'parallel_tests/test/runner'
+require 'parallel_tests/fine_grain_test/file_queue'
+
+module ParallelTests
+  module FineGrainTest
+    class Runner < ParallelTests::Test::Runner
+      class << self
+        def run_tests(_, process_number, num_processes, options)
+          require_list = @@tests.map { |file| file.sub(" ", "\\ ") }.join(" ")
+          test_helper = File.expand_path("../test_helper", __FILE__)
+          cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| " \
+                "require %{./\#{f}}; require %{#{test_helper}}; " \
+                "}' -- #{options[:test_options]}"
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def tests_in_groups(tests, num_groups, options={})
+          ParallelTests::FineGrainTest::FileQueue.new.reset
+
+          results = super
+          @@tests = results.flatten
+          results
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/runtime_logger.rb

@@ -0,0 +1,81 @@
+require 'fileutils'
+require 'parallel_tests/fine_grain_test/test_case'
+
+module ParallelTests
+  module FineGrainTest
+    class RuntimeLogger
+      class << self
+        def now
+          if Time.respond_to?(:now_without_mock_time) # Timecop
+            Time.now_without_mock_time
+          else
+            Time.now
+          end
+        end
+
+        def delta
+          before = now.to_f
+          yield
+          now.to_f - before
+        end
+      end
+
+      def initialize(file_name = ENV['FINE_GRAIN_TEST_RUNTIME_LOGGER'])
+        @file_name = file_name
+      end
+
+      def reset
+        lock do |f|
+          f.pos = 0
+          f.truncate(0)
+        end
+      end
+
+      def runtimes
+        times = {}
+        lock do |f|
+          lines = f.read.split(/\n/)
+          lines.each do |line|
+            time, test_case = line.split(/ /, 2)
+            next unless time and test_case
+
+            time = time.to_f
+            test_case = TestCase.decode(test_case)
+            times[test_case] = time
+          end
+        end
+        times
+      end
+
+      def log_runtime(test_case)
+        result = nil
+        time = self.class.delta { result = yield }
+        log(test_case, time)
+        result
+      end
+
+      private
+
+      def log(test_case, time)
+        lock do |f|
+          f.seek(0, :END)
+          f.puts [ time, TestCase.encode(test_case) ].join(' ')
+        end
+      end
+
+      def lock
+        return unless @file_name
+
+        FileUtils.mkdir_p(File.dirname(@file_name))
+        File.open(@file_name, File::RDWR|File::CREAT) do |f|
+          begin
+            f.flock File::LOCK_EX
+            yield(f)
+          ensure
+            f.flock File::LOCK_UN
+          end
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/tasks.rb

@@ -0,0 +1,21 @@
+require 'rake'
+
+namespace :parallel do
+  desc "run test in parallel (fine grain parallelism) with parallel:fine_grain_test[num_cpus]"
+  task :fine_grain_test, [:count, :pattern, :options] do |t, args|
+    require 'parallel_tests/tasks'
+    ParallelTests::Tasks.check_for_pending_migrations
+
+    $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    require 'parallel_tests/fine_grain_test'
+
+    count, pattern, options = ParallelTests::Tasks.parse_args(args)
+    executable = File.join(File.dirname(__FILE__), '../../../bin/parallel_fine_grain_test')
+
+    command = "#{Shellwords.escape executable} test --type fine_grain_test " \
+      "-n #{count} --pattern '#{pattern}' --verbose " \
+      "--test-options '#{options}'"
+    abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+  end
+end
+

data/lib/parallel_tests/fine_grain_test/test_case.rb

@@ -0,0 +1,20 @@
+
+module ParallelTests
+  module FineGrainTest
+    class TestCase < Struct.new(:suite, :name)
+      def self.encode(test_case)
+        [ test_case.suite.name, test_case.name.gsub("\\", "\\\\\\").gsub("\n", "\\n") ].join(' ')
+      end
+
+      def self.decode(string)
+        suite, name = string.split(/ /, 2)
+        name = name.gsub("\\n", "\n").gsub("\\\\", "\\")
+        new(Object.module_eval("::#{suite}", __FILE__, __LINE__), name)
+      end
+
+      def ==(other)
+        other.suite == suite && other.name == name
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/test_helper.rb

@@ -0,0 +1,16 @@
+msg = "FineGrainTest pid:#{$$} " \
+      "tid:#{Thread.current.object_id} " \
+      "test_env_number:#{ENV['TEST_ENV_NUMBER']}"
+
+puts msg
+Rails.logger.info msg if defined?(Rails)
+
+if defined?(Minitest::Runnable) # Minitest 5
+  require 'parallel_tests/fine_grain_test/minitest'
+elsif defined?(MiniTest::Unit) # Minitest 4
+  raise NotImplementedError.new("FineGrainTest does not currently support Minitest 4")
+elsif defined?(Test::Unit)
+  require 'parallel_tests/fine_grain_test/test_unit'
+else # WAT?
+  raise "Count not detect Minitest or TestUnit"
+end

data/lib/parallel_tests/fine_grain_test/test_unit.rb

@@ -0,0 +1,11 @@
+require 'test/unit/autorunner'
+
+Test::Unit::AutoRunner.register_collector(:fine_grain) do |auto_runner|
+  require 'parallel_tests/fine_grain_test/test_unit/collector'
+
+  collector = ParallelTests::FineGrainTest::TestUnit::Collector.new
+  collector.collect(auto_runner)
+end
+
+# Tell auto runner to use our collector.
+ARGV << "--collector=fine_grain"

data/lib/parallel_tests/fine_grain_test/test_unit/collector.rb

@@ -0,0 +1,54 @@
+require 'parallel_tests/fine_grain_test/test_case'
+require 'parallel_tests/fine_grain_test/file_queue'
+require 'parallel_tests/fine_grain_test/runtime_logger'
+require 'parallel_tests/fine_grain_test/test_unit/test_suite'
+
+module ParallelTests
+  module FineGrainTest
+    module TestUnit
+      class Collector
+        def collect(auto_runner)
+          runtime_logger = RuntimeLogger.new
+          test_suite = collect_test_suite(auto_runner)
+          file_queue = create_file_queue_from_test_suite(test_suite, runtime_logger)
+          create_test_suite_from_file_queue(file_queue, runtime_logger)
+        end
+
+        private
+
+        def collect_test_suite(auto_runner)
+          auto_runner.send(:default_collector)[auto_runner]
+        end
+
+        def create_file_queue_from_test_suite(test_suite, runtime_logger)
+          file_queue = FileQueue.new
+
+          test_cases = Set.new
+          test_suite_to_test_cases(test_suite, test_cases)
+
+          file_queue.enq_all(test_cases) do |tcs|
+            runtimes = runtime_logger.runtimes
+            runtime_logger.reset
+            tcs.sort_by { |test_case| runtimes[test_case] || 0 }.reverse
+          end
+
+          file_queue
+        end
+
+        def test_suite_to_test_cases(test_suite, test_cases)
+          if test_suite.is_a?(Test::Unit::TestSuite)
+            test_suite.tests.each do |test|
+              test_suite_to_test_cases(test, test_cases)
+            end
+          else
+            test_cases << TestCase.new(test_suite.class, test_suite.method_name)
+          end
+        end
+
+        def create_test_suite_from_file_queue(file_queue, runtime_logger)
+          TestSuite.new(file_queue, runtime_logger)
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/test_unit/test_suite.rb

@@ -0,0 +1,59 @@
+require 'test/unit/testsuite'
+
+module ParallelTests
+  module FineGrainTest
+    module TestUnit
+      class TestSuite < Test::Unit::TestSuite
+
+        def initialize(file_queue = nil, runtime_logger = nil)
+          super("Fine Grain Test")
+          @file_queue = file_queue
+          @runtime_logger = runtime_logger
+
+          @tests = self
+        end
+
+        def <<(test)
+          raise NotImplementedError
+        end
+
+        def delete(test)
+          raise NotImplementedError
+        end
+
+        def delete_tests(tests)
+          raise NotImplementedError
+        end
+
+        def size
+          @file_queue ? @file_queue.size : 0
+        end
+
+        def shift
+          test_case = @file_queue ? @file_queue.deq : nil
+          if test_case
+            test_suite = Test::Unit::TestSuite.new(test_case.suite.name)
+            test_suite << test_case.suite.new(test_case.name)
+            test_suite
+          end
+        end
+
+        protected
+
+        def run_test(test_suite, result)
+          if @runtime_logger
+            test_case = test_suite.tests.first
+            test_case = TestCase.new(test_case.class, test_case.method_name)
+
+            @runtime_logger.log_runtime(test_case) do
+              super(test_suite, result)
+            end
+          else
+            super(test_suite, result)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/parallel_tests/fine_grain_test/version.rb

@@ -0,0 +1,5 @@
+module ParallelTests
+  module FineGrainTest
+    VERSION = "0.2.0"
+  end
+end

data/parallel_tests-fine_grain_test.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parallel_tests/fine_grain_test/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "parallel_tests-fine_grain_test"
+  spec.version       = ParallelTests::FineGrainTest::VERSION
+  spec.authors       = ["Paul Kmiec"]
+  spec.email         = ["paul.kmiec@appfolio.com"]
+
+  spec.summary       = %q{Parallelizes tests dynamically at runtime based on test cases.}
+  spec.description   = %q{Parallelizes tests dynamically at runtime based on test cases.}
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency 'parallel_tests', '~> 2.4'
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: parallel_tests-fine_grain_test
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Paul Kmiec
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parallel_tests
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: Parallelizes tests dynamically at runtime based on test cases.
+email:
+- paul.kmiec@appfolio.com
+executables:
+- parallel_tests-fine_grain_test
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".hound.yml"
+- ".rubocop.default.yml"
+- ".rubocop.disabled.yml"
+- ".rubocop.enabled.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Appraisals
+- Gemfile
+- README.md
+- Rakefile
+- bin/parallel_fine_grain_test
+- exe/parallel_tests-fine_grain_test
+- gemfiles/activesupport_3.gemfile
+- gemfiles/activesupport_3.gemfile.lock
+- gemfiles/activesupport_4.gemfile
+- gemfiles/activesupport_4.gemfile.lock
+- gemfiles/activesupport_5.gemfile
+- gemfiles/activesupport_5.gemfile.lock
+- lib/parallel_tests/fine_grain_test.rb
+- lib/parallel_tests/fine_grain_test/file_queue.rb
+- lib/parallel_tests/fine_grain_test/minitest.rb
+- lib/parallel_tests/fine_grain_test/minitest/extension.rb
+- lib/parallel_tests/fine_grain_test/minitest/suite.rb
+- lib/parallel_tests/fine_grain_test/railtie.rb
+- lib/parallel_tests/fine_grain_test/runner.rb
+- lib/parallel_tests/fine_grain_test/runtime_logger.rb
+- lib/parallel_tests/fine_grain_test/tasks.rb
+- lib/parallel_tests/fine_grain_test/test_case.rb
+- lib/parallel_tests/fine_grain_test/test_helper.rb
+- lib/parallel_tests/fine_grain_test/test_unit.rb
+- lib/parallel_tests/fine_grain_test/test_unit/collector.rb
+- lib/parallel_tests/fine_grain_test/test_unit/test_suite.rb
+- lib/parallel_tests/fine_grain_test/version.rb
+- parallel_tests-fine_grain_test.gemspec
+homepage: 
+licenses: []
+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.8
+signing_key: 
+specification_version: 4
+summary: Parallelizes tests dynamically at runtime based on test cases.
+test_files: []