moxiesoft_parallel_tests 0.4.12

data/.gitignore

@@ -0,0 +1 @@
+*.sh

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+gem 'parallel'
+
+group :dev do
+  gem 'rake'
+  gem 'rspec', '~>2'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    parallel (0.5.1)
+    rake (0.8.7)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  parallel
+  rake
+  rspec (~> 2)

data/Rakefile

@@ -0,0 +1,21 @@
+task :default => :spec
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--backtrace --color'
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name     = "moxiesoft_parallel_tests"
+    gem.summary  = "Run tests / specs / features in parallel"
+    gem.email    = "grosser.michael@gmail.com"
+    gem.homepage = "http://github.com/edebill-moxiesoft/#{gem.name}"
+    gem.authors  = ['Michael Grosser', 'Eric DeBill']
+    gem.add_dependency "parallel"
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/Readme.md

@@ -0,0 +1,156 @@
+Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs(or cores).
+
+Setup for Rails
+===============
+
+## Install
+### Rails 3
+As gem
+    sudo gem install parallel_tests
+    # add to Gemfile
+    gem "parallel_tests", :group=>:development
+
+OR as plugin
+    sudo gem install parallel
+    rails plugin install git://github.com/grosser/parallel_tests.git
+
+### Rails 2
+
+As gem
+    sudo gem install parallel_tests
+    # add to config/environments/development.rb
+    config.gem "parallel_tests"
+    # add to Rakefile
+    begin; require 'parallel_tests/tasks'; rescue LoadError; end
+
+OR as plugin
+
+    sudo gem install parallel
+    ./script/plugin install git://github.com/grosser/parallel_tests.git
+
+## Setup
+### 1: Add to `config/database.yml`
+    test:
+      database: xxx_test<%= ENV['TEST_ENV_NUMBER'] %>
+
+### 2: Create additional database(s)
+    rake parallel:create
+
+### 3: Copy development schema (repeat after migrations)
+    rake parallel:prepare
+
+### 4: Run!
+    rake parallel:test          # Test::Unit
+    rake parallel:spec          # RSpec
+    rake parallel:features      # Cucumber
+
+    rake parallel:test[1] --> force 1 CPU --> 86 seconds
+    rake parallel:test    --> got 2 CPUs? --> 47 seconds
+    rake parallel:test    --> got 4 CPUs? --> 26 seconds
+    ...
+
+Test just a subfolder (e.g. use one integration server per subfolder)
+    rake parallel:test[models]
+    rake parallel:test[something/else]
+
+    partial paths are OK too...
+    rake parallel:test[functional] == rake parallel:test[fun]
+
+Example output
+--------------
+    2 processes for 210 specs, ~ 105 specs per process
+    ... test output ...
+
+    Results:
+    877 examples, 0 failures, 11 pending
+    843 examples, 0 failures, 1 pending
+
+    Took 29.925333 seconds
+
+Even process runtimes (for specs only atm)
+-----------------
+Add to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+    --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
+It will log test runtime and partition the test-load accordingly.
+
+Setup for non-rails
+===================
+    sudo gem install parallel_tests
+    # go to your project dir
+    parallel_test OR parallel_spec OR parallel_cucumber
+    # [Optional] use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
+
+[optional] Only run selected files & folders:
+    parallel_test test/bar test/baz/xxx_text.rb
+
+Options are:
+    -n [PROCESSES]                   How many processes to use, default: available CPUs
+    -p, --path [PATH]                run tests inside this path only
+        --no-sort                    do not sort files before running them
+    -m, --multiply-processes [FLOAT] use given number as a multiplier of processes to run
+    -r, --root [PATH]                execute test commands from this path
+    -e, --exec [COMMAND]             execute this code parallel and with ENV['TEST_ENV_NUM']
+    -o, --test-options '[OPTIONS]'   execute test commands with those options
+    -t, --type [TYPE]                which type of tests to run? test, spec or features
+        --non-parallel               execute same commands but do not in parallel, needs --exec
+    -v, --version                    Show Version
+    -h, --help                       Show this.
+
+You can run any kind of code with -e / --execute
+    parallel_test -n 5 -e 'ruby -e "puts %[hello from process #{ENV[:TEST_ENV_NUMBER.to_s].inspect}]"'
+    hello from process "2"
+    hello from process ""
+    hello from process "3"
+    hello from process "5"
+    hello from process "4"
+
+<table>
+<tr><td></td><td>1 Process</td><td>2 Processes</td><td>4 Processes</td></tr>
+<tr><td>RSpec spec-suite</td><td>18s</td><td>14s</td><td>10s</td></tr>
+<tr><td>Rails-ActionPack</td><td>88s</td><td>53s</td><td>44s</td></tr>
+</table>
+
+TIPS
+====
+ - [Capybara + Selenium] add to env.rb: `Capybara.server_port = 8888 + ENV['TEST_ENV_NUMBER'].to_i`
+ - [RSpec] add a `spec/parallel_spec.opts` to use different options, e.g. no --drb (default: `spec/spec.opts`)
+ - [RSpec] if something looks fishy try to delete `script/spec`
+ - [RSpec] if `script/spec` is missing parallel:spec uses just `spec` (which solves some issues with double-loaded environment.rb)
+ - [RSpec] 'script/spec_server' or [spork](http://github.com/timcharper/spork/tree/master) do not work in parallel
+ - [RSpec] `./script/generate rspec` if you are running rspec from gems (this plugin uses script/spec which may fail if rspec files are outdated)
+ - [Bundler] if you have a `Gemfile` then `bundle exec` will be used to run tests
+ - [Capybara setup](https://github.com/grosser/parallel_tests/wiki)
+ - [Sphinx setup](https://github.com/grosser/parallel_tests/wiki)
+ - [SQL schema format] use :ruby schema format to get faster parallel:prepare`
+ - with zsh this would be `rake "parallel:prepare[3]"`
+
+TODO
+====
+ - make jRuby compatible [basics](http://yehudakatz.com/2009/07/01/new-rails-isolation-testing/)
+ - make windows compatible
+
+Authors
+====
+inspired by [pivotal labs](http://pivotallabs.com/users/miked/blog/articles/849-parallelize-your-rspec-suite)
+
+### [Contributors](http://github.com/grosser/parallel_tests/contributors)
+ - [Charles Finkel](http://charlesfinkel.com/)
+ - [Indrek Juhkam](http://urgas.eu)
+ - [Jason Morrison](http://jayunit.net)
+ - [jinzhu](http://github.com/jinzhu)
+ - [Joakim Kolsjö](http://www.rubyblocks.se)
+ - [Kevin Scaldeferri](http://kevin.scaldeferri.com/blog/)
+ - [Kpumuk](http://kpumuk.info/)
+ - [Maksim Horbul](http://github.com/mhorbul)
+ - [Pivotal Labs](http://www.pivotallabs.com)
+ - [Rohan Deshpande](http://github.com/rdeshpande)
+ - [Tchandy](http://thiagopradi.net/)
+ - [Terence Lee](http://hone.heroku.com/)
+ - [Will Bryant](http://willbryant.net/)
+ - [Fred Wu](http://fredwu.me)
+ - [xxx](https://github.com/xxx)
+ - [Levent Ali](http://purebreeze.com/)
+
+[Michael Grosser](http://grosser.it)<br/>
+michael@grosser.it<br/>
+Hereby placed under public domain, do what you want, just do not hold me accountable...

data/VERSION

@@ -0,0 +1 @@
+0.4.12

data/bin/parallel_cucumber

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t features #{ARGV * ' '}"

data/bin/parallel_spec

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "#{File.join(File.dirname(__FILE__), 'parallel_test')} -t spec #{ARGV * ' '}"

data/bin/parallel_test

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require 'parallel'
+raise "please ' gem install parallel '" if Gem::Version.new(Parallel::VERSION) < Gem::Version.new('0.4.2')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "parallel_tests"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+
+[optional] Only run selected files & folders:
+    parallel_test test/bar test/baz/xxx_text.rb
+
+Options are:
+BANNER
+  opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
+  opts.on("-p", '--path [PATH]', "run tests inside this path only"){|path| options[:path_prefix] = path }
+  opts.on("--no-sort", "do not sort files before running them"){ |no_sort| options[:no_sort] = no_sort }
+  opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run"){ |multiply| options[:multiply] = multiply }
+  opts.on("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
+  opts.on("-e", '--exec [COMMAND]', "execute this code parallel and with ENV['TEST_ENV_NUM']"){|path| options[:execute] = path }
+  opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options"){|arg| options[:test_options] = arg }
+  opts.on("-t", "--type [TYPE]", "which type of tests to run? test, spec or features"){|type| options[:type] = type }
+  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){|type| options[:non_parallel] = true }
+  opts.on('-v', '--version', 'Show Version'){ puts ParallelTests::VERSION; exit}
+  opts.on("-h", "--help", "Show this.") { puts opts; exit }
+end.parse!
+
+# get files to run from arguments
+options[:files] = ARGV if ARGV.size > 0
+
+num_processes = options[:count] || Parallel.processor_count
+num_processes = num_processes * (options[:multiply] || 1)
+
+if options[:execute]
+  runs = (0...num_processes).to_a
+  results = if options[:non_parallel]
+    runs.map do |i|
+      ParallelTests.execute_command(options[:execute], i)
+    end
+  else
+    Parallel.map(runs, :in_processes => num_processes) do |i|
+      ParallelTests.execute_command(options[:execute], i)
+    end
+  end.flatten
+  abort if results.any?{|r| r[:exit_status] != 0 }
+else
+  lib, name, task = {
+    'test' => ["tests", "test", "test"],
+    'spec' => ["specs", "spec", "spec"],
+    'features' => ["cucumber", "feature", "features"]
+  }[options[:type]||'test']
+
+  require "parallel_#{lib}"
+  klass = eval("Parallel#{lib.capitalize}")
+
+  start = Time.now
+
+  options[:path_prefix] = options[:path_prefix] ? options[:path_prefix].split(',') : ['']
+  tests_folder = options[:path_prefix].collect do |path| 
+    tests_folder = File.join(task, path.to_s)
+    tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
+    tests_folder
+  end
+  tests_folder = nil if tests_folder.empty?
+
+  puts "test folders => #{tests_folder}" if tests_folder
+
+  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, :no_sort => options[:no_sort])
+  num_processes = groups.size
+
+  #adjust processes to groups
+  abort "no #{name}s found!" if groups.size == 0
+
+  num_tests = groups.inject(0){|sum,item| sum + item.size }
+  puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+
+  test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
+    klass.run_tests(group, groups.index(group), options[:test_options])
+  end
+
+  #parse and print results
+  results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
+  puts ""
+  puts "Results:"
+  results.each{|r| puts r }
+
+  #report total time taken
+  puts ""
+  puts "Took #{Time.now - start} seconds"
+
+  #exit with correct status code so rake parallel:test && echo 123 works
+  failed = test_results.any?{|result| result[:exit_status] != 0 }
+  abort "#{name.capitalize}s Failed" if failed
+end

data/lib/parallel_cucumber.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'parallel_tests')
+
+class ParallelCucumber < ParallelTests
+  def self.run_tests(test_files, process_number, options)
+    color = ($stdout.tty? ? 'AUTOTEST=1 ; export AUTOTEST ;' : '')#display color when we are in a terminal
+    cmd = "#{color} #{executable} #{options} #{test_files*' '}"
+    execute_command(cmd, process_number)
+  end
+
+  def self.executable
+    if bundler_enabled?
+      "bundle exec cucumber"
+    elsif File.file?("script/cucumber")
+      "script/cucumber"
+    else
+      "cucumber"
+    end
+  end
+
+  protected
+
+  def self.test_suffix
+    ".feature"
+  end
+
+  def self.line_is_result?(line)
+    line =~ /^\d+ (steps|scenarios)/
+  end
+end

data/lib/parallel_specs/spec_runtime_logger.rb

@@ -0,0 +1,49 @@
+require 'spec/runner/formatter/progress_bar_formatter'
+
+class ParallelSpecs::SpecRuntimeLogger < Spec::Runner::Formatter::BaseTextFormatter
+  def initialize(options, output)
+    if String === output
+      FileUtils.mkdir_p(File.dirname(output))
+      File.open(output,'w'){|f| f.write ''} # clean the file
+      @output = File.open(output, 'a+') #append so that multiple processes can write at once
+    else
+      @output = output
+    end
+    @example_times = Hash.new(0)
+  end
+
+  def example_started(*args)
+    @time = Time.now
+  end
+
+  def example_passed(example)
+    file = example.location.split(':').first
+    @example_times[file] += Time.now - @time
+  end
+
+  def start_dump(*args)
+    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
+    # TODO: Figure out why sometimes time can be less than 0
+    @output.puts @example_times.map { |file, time| "#{file}:#{time > 0 ? time : 0}" }
+    @output.flush
+  end
+
+  # stubs so that rspec doe not crash
+
+  def example_pending(*args)
+  end
+
+  def dump_summary(*args)
+  end
+
+  def dump_pending(*args)
+  end
+
+  def dump_failure(*args)
+  end
+
+  #stolen from Rspec
+  def close
+    @output.close  if (IO === @output) & (@output != $stdout)
+  end
+end

data/lib/parallel_specs.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), 'parallel_tests')
+
+class ParallelSpecs < ParallelTests
+  def self.run_tests(test_files, process_number, options)
+    exe = executable # its expensive with bundler, so do not call it twice
+    cmd = "#{color} #{exe} #{options} #{spec_opts(exe)} #{test_files*' '}"
+    execute_command(cmd, process_number)
+  end
+
+  def self.executable
+    cmd = if File.file?("script/spec")
+      "script/spec"
+    elsif bundler_enabled?
+      cmd = (run("bundle show rspec") =~ %r{/rspec-1[^/]+$} ? "spec" : "rspec")
+      "bundle exec #{cmd}"
+    else
+      %w[spec rspec].detect{|cmd| system "#{cmd} --version > /dev/null 2>&1" }
+    end
+    cmd or raise("Can't find executables rspec or spec")
+  end
+
+  protected
+
+  # so it can be stubbed....
+  def self.run(cmd)
+    `#{cmd}`
+  end
+
+  def self.spec_opts(executable)
+    opts = ['spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+    return unless opts
+    if executable =~ /\brspec\b/
+      # RSpec2 does not handle -O, so we inline the options
+      File.read(opts).tr("\n", ' ')
+    else
+      "-O #{opts}"
+    end
+  end
+
+  #display color when we are in a terminal
+  def self.color
+    ($stdout.tty? ? 'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' : '')
+  end
+
+  def self.test_suffix
+    "_spec.rb"
+  end
+end

data/lib/parallel_tests/grouper.rb

@@ -0,0 +1,31 @@
+class ParallelTests
+  class Grouper
+    def self.in_groups(items, num_groups)
+      [].tap do |groups|
+        while ! items.empty?
+          (0...num_groups).map do |group_number|
+            groups[group_number] ||= []
+            groups[group_number] << items.shift
+          end
+        end
+      end
+    end
+
+    def self.in_even_groups_by_size(items_with_sizes, num_groups)
+      items_with_size = smallest_first(items_with_sizes)
+      groups = Array.new(num_groups){{:items => [], :size => 0}}
+      items_with_size.each do |item, size|
+        # always add to smallest group
+        smallest = groups.sort_by{|g| g[:size] }.first
+        smallest[:items] << item
+        smallest[:size] += size
+      end
+
+      groups.map{|g| g[:items] }
+    end
+
+    def self.smallest_first(files)
+      files.sort_by{|item, size| size }.reverse
+    end
+  end
+end

data/lib/parallel_tests/railtie.rb

@@ -0,0 +1,10 @@
+# add rake tasks if we are inside Rails
+if defined?(Rails::Railtie)
+  class ParallelTests
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load File.expand_path("../../tasks/parallel_tests.rake", __FILE__)
+      end
+    end
+  end
+end

data/lib/parallel_tests/tasks.rb

@@ -0,0 +1,80 @@
+namespace :parallel do
+  def run_in_parallel(cmd, options)
+    count = (options[:count] ? options[:count].to_i : nil)
+    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+    command = "#{executable} --exec '#{cmd}' -n #{count} #{'--non-parallel' if options[:non_parallel]}"
+    abort unless system(command)
+  end
+
+  desc "create test databases via db:create --> parallel:create[num_cpus]"
+  task :create, :count do |t,args|
+    run_in_parallel('rake db:create RAILS_ENV=test', args)
+  end
+
+  desc "drop test databases via db:drop --> parallel:drop[num_cpus]"
+  task :drop, :count do |t,args|
+    run_in_parallel('rake db:drop RAILS_ENV=test', args)
+  end
+
+  desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
+  task(:prepare, [:count] => 'db:abort_if_pending_migrations') do |t,args|
+    if ActiveRecord::Base.schema_format == :ruby
+      # dump then load in parallel
+      Rake::Task['db:schema:dump'].invoke
+      Rake::Task['parallel:load_schema'].invoke(args[:count])
+    else
+      # there is no separate dump / load for schema_format :sql -> do it safe and slow
+      args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
+      run_in_parallel('rake db:test:prepare --trace', args)
+    end
+  end
+
+  # when dumping/resetting takes too long
+  desc "update test databases via db:mgrate --> parallel:migrate[num_cpus]"
+  task :migrate, :count do |t,args|
+    run_in_parallel('rake db:migrate RAILS_ENV=test', args)
+  end
+
+  # just load the schema (good for integration server <-> no development db)
+  desc "load dumped schema for test databases via db:schema:load --> parallel:load_schema[num_cpus]"
+  task :load_schema, :count do |t,args|
+    run_in_parallel('rake db:test:load', args)
+  end
+
+  ['test', 'spec', 'features'].each do |type|
+    desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
+    task type, :count, :path_prefix, :options do |t,args|
+      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      require "parallel_tests"
+      count, prefix, options = ParallelTests.parse_rake_args(args)
+      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+      command = "#{executable} --type #{type} -n #{count} -p '#{prefix}' -r '#{Rails.root}' -o '#{options}'"
+      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+    end
+  end
+end
+
+#backwards compatability
+#spec:parallel:prepare
+#spec:parallel
+#test:parallel
+namespace :spec do
+  namespace :parallel do
+    task :prepare, :count do |t,args|
+      $stderr.puts "WARNING -- Deprecated!  use parallel:prepare"
+      Rake::Task['parallel:prepare'].invoke(args[:count])
+    end
+  end
+
+  task :parallel, :count, :path_prefix do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:spec"
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:path_prefix])
+  end
+end
+
+namespace :test do
+  task :parallel, :count, :path_prefix do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:test"
+    Rake::Task['parallel:test'].invoke(args[:count], args[:path_prefix])
+  end
+end