phene-parallel_tests 0.6.2

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    parallel (0.5.1)
+    rake (0.8.7)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  parallel
+  rake
+  rspec (>= 2.4)

data/Rakefile

@@ -0,0 +1,20 @@
+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     = "parallel_tests"
+    gem.summary  = "Run tests / specs / features in parallel"
+    gem.email    = "grosser.michael@gmail.com"
+    gem.homepage = "http://github.com/grosser/#{gem.name}"
+    gem.authors  = "Michael Grosser"
+  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,219 @@
+Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs (or cores).<br/>
+ParallelTests splits tests into even groups and runs each group in a single process with its own database.
+
+Setup for Rails
+===============
+## Install
+### Rails 3
+If you use RSpec: ensure you got >= 2.4
+
+As gem
+
+    # add to Gemfile
+    gem "parallel_tests", :group => :development
+
+OR as plugin
+
+    rails plugin install git://github.com/grosser/parallel_tests.git
+
+    # add to Gemfile
+    gem "parallel", :group => :development
+
+
+### Rails 2
+
+As gem
+
+    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
+
+    gem install parallel
+
+    # add to config/environments/development.rb
+    config.gem "parallel"
+
+    ./script/plugin install git://github.com/grosser/parallel_tests.git
+
+## Setup
+ParallelTests uses 1 database per test-process, 2 processes will use `*_test` and `*_test2`.
+
+
+### 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 by pattern (e.g. use one integration server per subfolder / see if you broke any 'user'-related tests)
+
+    rake parallel:test[^unit] # everything in test/unit folder (every test file matching /^unit/)
+    rake parallel:test[user]  # run users_controller + user_helper + user tests
+    rake parallel:test['user|product']  # run user and product related tests
+
+
+Example output
+--------------
+    2 processes for 210 specs, ~ 105 specs per process
+    ... test output ...
+
+    843 examples, 0 failures, 1 pending
+
+    Took 29.925333 seconds
+
+Spec Loggers
+===================
+
+Even process runtimes
+-----------------
+
+Log test runtime to give each process the same test runtime.
+
+Add to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
+    RSpec >= 2.4:
+      Installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecRuntimeLogger --out tmp/parallel_profile.log
+
+SpecSummaryLogger
+--------------------
+
+This logger stops the different processes overwriting each other's output.
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --format ParallelSpecs::SpecSummaryLogger:tmp/spec_summary.log
+    RSpec >= 2.2:
+      --format progress
+      --format ParallelSpecs::SpecSummaryLogger --out tmp/spec_summary.log
+
+SpecFailuresLogger
+-----------------------
+
+This logger produces command lines for running any failing examples.
+
+E.g.
+
+    spec /path/to/my_spec.rb -e "should do something"
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format ParallelSpecs::SpecFailuresLogger:tmp/failing_specs.log
+    RSpec >= 2.4:
+      --format ParallelSpecs::SpecFailuresLogger --out tmp/failing_specs.log
+
+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 Kintzer](https://github.com/rockrep)
+ - [nathansobo](https://github.com/nathansobo)
+ - [Joe Yates](http://titusd.co.uk)
+ - [asmega](http://www.ph-lee.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.6.1

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,91 @@
+#!/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", '--pattern [PATTERN]', "run tests matching this pattern"){|pattern| options[:pattern] = pattern }
+  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"){ options[:non_parallel] = true }
+  opts.on("--chunk-timeout [TIMEOUT]", "timeout before re-printing the output of a child-process"){|timeout| options[:chunk_timeout] = timeout.to_f }
+  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, options)
+    end
+  else
+    Parallel.map(runs, :in_processes => num_processes) do |i|
+      ParallelTests.execute_command(options[:execute], i, options)
+    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
+
+  tests_folder = task
+  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
+
+  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, :no_sort => options[:no_sort], :pattern => options[:pattern])
+  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)
+  end
+
+  #parse and print results
+  results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
+  puts ""
+  puts klass.summarize_results(results)
+
+  #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,36 @@
+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
+    runtime_logging = " --format ParallelCucumber::RuntimeLogger --out #{runtime_log}"
+    cmd = "#{color} #{executable}"
+    cmd << runtime_logging if File.directory?(File.dirname(runtime_log))
+    cmd << " #{options[:test_options]} #{test_files*' '}"
+    execute_command(cmd, process_number, options)
+  end
+
+  def self.executable
+    if bundler_enabled?
+      "bundle exec cucumber"
+    elsif File.file?("script/cucumber")
+      "script/cucumber"
+    else
+      "cucumber"
+    end
+  end
+
+  def self.runtime_log
+    'tmp/parallel_runtime_cucumber.log'
+  end
+
+  protected
+
+  def self.test_suffix
+    ".feature"
+  end
+
+  def self.line_is_result?(line)
+    line =~ /^\d+ (steps|scenarios)/
+  end
+end

data/lib/parallel_cucumber/runtime_logger.rb

@@ -0,0 +1,57 @@
+class ParallelCucumber
+  class RuntimeLogger
+
+    def initialize(step_mother, path_or_io, options=nil)
+      @io = prepare_io(path_or_io)
+      @example_times = Hash.new(0)
+    end
+
+    def before_feature(_)
+      @start_at = Time.now.to_f
+    end
+
+    def after_feature(feature)
+      @example_times[feature.file] += Time.now.to_f - @start_at
+    end
+
+    def after_features(*args)
+      lock_output do
+        @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+      end
+    end
+
+    private
+
+    def prepare_io(path_or_io)
+      if path_or_io.respond_to?(:write)
+        path_or_io
+      else # its a path
+        File.open(path_or_io, 'w').close # clean out the file
+        file = File.open(path_or_io, 'a')
+
+        at_exit do
+          unless file.closed?
+            file.flush
+            file.close
+          end
+        end
+
+        file
+      end
+    end
+
+    # do not let multiple processes get in each others way
+    def lock_output
+      if File === @io
+        begin
+          @io.flock File::LOCK_EX
+          yield
+        ensure
+          @io.flock File::LOCK_UN
+        end
+      else
+        yield
+      end
+    end
+  end
+end