minitest-parallel_fork 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 09d52a418fc9f248ded3902c4b7a5fd4b775cdfa
+  data.tar.gz: 36a3dcb18d5b7652af47c934c8a8a082a8ea78bc
+SHA512:
+  metadata.gz: ccc49c0c045f2c9f8d3c6003373306fa75c787bee8b95eec0c401e9e9c5353f91635f52fce24714b7d2ffb7ab7f7e849abcb7dedaae0c3210009dbcb7e00b8f8
+  data.tar.gz: dd22675a8b0cbe257640b8c2ff518f30990b827ba8c02b1d33b89c49fa84d28fca37e5a9ba7e26fcdd7cdef87fb26d525ae1196dd373069cb0e944297ca0a9e9

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 1.0.0 (2015-05-11)
+
+* Initial Public Release

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2015 Jeremy Evans
+
+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 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.rdoc

@@ -0,0 +1,80 @@
+= minitest-parallel_fork
+
+minitest-parallel_fork adds fork-based parallelization to Minitest.  Each test/spec
+suite is run one of the forks, allowing this to work correctly when using
+before_all/after_all/around_all hooks provided by minitest-hooks.  Using separate
+processes via fork can significantly improve spec performance when using MRI,
+and can work in cases where Minitest's default thread-based parallelism do not work,
+such as when tests/specs modify the constant namespace.
+
+= Installation
+
+  gem install minitest-parallel_fork
+
+= Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/minitest-parallel_fork
+
+= Usage 
+
+You can enable fork-based parallelism just by requiring +minitest/parallel_fork+. One easy
+to do so without modifying the spec code itself is to use the +RUBYOPT+ environment variable.
+So if you execute your specs using:
+
+  rake spec
+
+You can switch to fork-based parallelism using:
+
+  RUBYOPT=-rminitest/parallel_fork rake spec
+
+To control the number of forks, you can set the +NCPU+ environment variable:
+
+  NCPU=8 RUBYOPT=-rminitest/parallel_fork rake spec
+
+If you don't set the +NCPU+ environment variable, minitest-parallel_fork will use
+4 forks by default.
+
+= Hooks
+
+In some cases, especially when using external databases, you'll need to do some
+before fork or after fork setup.  minitest/parallel_fork supports +before_parallel_fork+
+and +after_parallel_fork+ hooks.
+
++before_parallel_fork+ is called before any child processes are forked:
+
+  Minitest.before_parallel_fork do
+    DB.disconnect
+  end
+
++after_parallel_fork+ is called after each child process is forked, with the number
+of the child process, starting at 0:
+
+  Minitest.after_parallel_fork do |i|
+    DB.opts[:database] += (i+1).to_s
+  end
+
+The above examples show a fairly easy way to use minitest-parallel_fork with an external
+database when using Sequel.  Before forking, all existing database connections are
+disconnecting, and after forking, the database name is changed in each child to reference
+a child-specific database, so that the child processes do not share a database and are
+thus independent.
+
+= Speedup
+
+The speedup you get greatly depends on your specs.  Here's some examples using Sequel's
+specs:
+
+                     2 forks         4 forks
+  spec_core:      1.25x - 1.36x        1.5x   
+  spec_model:     1.29x - 1.62x   1.72x - 2.02x
+  spec_plugin:    1.57x - 1.76x   2.29x - 2.37x    
+  spec_sqlite:    1.75x - 1.86x   2.26x - 2.65x
+  spec_postgres:  1.32x - 1.40x     Untested
+
+= License
+
+MIT
+
+= Author
+
+Jeremy Evans <code@jeremyevans.net>

data/Rakefile

@@ -0,0 +1,47 @@
+require "rake"
+require "rake/clean"
+
+CLEAN.include ["minitest-parallel_fork-*.gem", "rdoc", "coverage"]
+
+desc "Build minitest-parallel_fork gem"
+task :package=>[:clean] do |p|
+  sh %{#{FileUtils::RUBY} -S gem build minitest-parallel_fork.gemspec}
+end
+
+### Specs
+
+desc "Run specs"
+task :spec do
+  ENV['RUBY'] = FileUtils::RUBY
+  ENV['RUBYOPT'] = "#{ENV['RUBYOPT']} -rubygems"
+  sh %{#{FileUtils::RUBY} spec/minitest_parallel_fork_spec.rb}
+end
+
+task :default=>:spec
+
+### RDoc
+
+RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'minitest-parallel_fork: fork-based parallelization for minitest']
+
+begin
+  gem 'hanna-nouveau'
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+rescue Gem::LoadError
+end
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+
+rdoc_task_class.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
+end
+

data/lib/minitest/parallel_fork.rb

@@ -0,0 +1,94 @@
+gem 'minitest'
+require 'minitest'
+
+module Minitest
+  # Set the before_parallel_fork block to the given block
+  def self.before_parallel_fork(&block)
+    @before_parallel_fork = block
+  end
+
+  # Set the after_parallel_fork block to the given block
+  def self.after_parallel_fork(i=nil, &block)
+    @after_parallel_fork = block
+  end
+
+  # Subclass of Assertion for unexpected errors.  UnexpectedError
+  # can not be used as it can include undumpable objects.  This
+  # class converts all data it needs to plain strings, so that
+  # it will be dumpable.
+  class DumpableUnexpectedError < Assertion # :nodoc:
+    attr_accessor :backtrace
+
+    def initialize(unexpected)
+      exception_class_name = unexpected.exception.class.name.to_s
+      exception_message = unexpected.exception.message.to_s
+      super("#{exception_class_name}: #{exception_message}")
+      self.backtrace = unexpected.exception.backtrace.map(&:to_s)
+    end
+
+    def message
+      bt = Minitest.filter_backtrace(backtrace).join "\n    "
+      "#{super}\n    #{bt}"
+    end
+
+    def result_label
+      "Error"
+    end
+  end
+
+  # Override __run to use a child forks to run the speeds, which
+  # allows for parallel spec execution on MRI.
+  def self.__run(reporter, options)
+    suites = Runnable.runnables.shuffle
+    stat_reporter = reporter.reporters.detect{|rep| rep.is_a?(StatisticsReporter)}
+
+    n = (ENV['NCPU'] || 4).to_i
+    reads = []
+    if defined?(@before_parallel_fork)
+      @before_parallel_fork.call
+    end
+    n.times do |i|
+      read, write = IO.pipe.each{|io| io.binmode}
+      reads << read
+      fork do
+        read.close
+        if defined?(@after_parallel_fork)
+          @after_parallel_fork.call(i)
+        end
+
+        p_suites = []
+        suites.each_with_index{|s, j| p_suites << s if j % n == i}
+        p_suites.partition{|s| s.test_order != :parallel}.
+          map{|ss| ss.map{|s| s.run(reporter, options) }}
+
+        data = %w'count assertions results'.map{|meth| stat_reporter.send(meth)}
+        data[-1] = data[-1].map do |res|
+          [res.name, res.failures.map{|f| f.is_a?(UnexpectedError) ? DumpableUnexpectedError.new(f) : f}]
+        end
+
+        write.write(Marshal.dump(data))
+        write.close
+      end
+      write.close
+    end
+    Process.waitall
+
+    Thread.new do
+      reads.each do |r|
+        data = r.read
+        r.close
+        count, assertions, results = Marshal.load(data)
+        stat_reporter.count += count
+        stat_reporter.assertions += assertions
+        results.map! do |name, failures|
+          runnable = Test.new(name)
+          runnable.failures.concat(failures)
+          runnable
+        end
+        stat_reporter.results.concat(results)
+      end
+    end.join
+
+    nil
+  end
+end

data/spec/minitest_parallel_fork_example.rb

@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+require 'minitest/parallel_fork'
+
+a = nil
+Minitest.before_parallel_fork do
+  a = 'a'
+  print ":parent"
+end
+
+Minitest.after_parallel_fork do |i|
+  print ":child#{i}#{a}"
+end
+
+4.times do |i|
+  describe 'minitest/parallel_fork' do
+    it "should work" do
+      sleep(1).must_equal 1
+    end
+  end
+end

data/spec/minitest_parallel_fork_spec.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+
+describe 'minitest/parallel_fork' do
+  it "should work" do
+    t = Time.now
+    ENV['NCPU'] = '4'
+    output = `#{ENV['RUBY']} -I lib spec/minitest_parallel_fork_example.rb`
+    (Time.now - t).must_be :<, 4
+    output.must_match /:parent/
+    4.times do |i|
+      output.must_match /:child#{i}a/
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: minitest-parallel_fork
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: |
+  minitest-parallel_fork adds fork-based parallelization to Minitest.  Each test/spec
+  suite is run one of the forks, allowing this to work correctly when using
+  before_all/after_all/around_all hooks provided by minitest-hooks.  Using separate
+  processes via fork can significantly improve spec performance when using MRI,
+  and can work in cases where Minitest's default thread-based parallelism do not work,
+  such as when specs modify the constant namespace.
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
+files:
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/minitest/parallel_fork.rb
+- spec/minitest_parallel_fork_example.rb
+- spec/minitest_parallel_fork_spec.rb
+homepage: http://github.com/jeremyevans/minitest-parallel_fork
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'minitest-parallel_fork: fork-based parallelization for minitest'
+- "--main"
+- README.rdoc
+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.5
+signing_key: 
+specification_version: 4
+summary: Fork-based parallelization for minitest'
+test_files: []