parallelized_specs 0.0.1

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'parallel'
+
+group :dev do
+  gem 'test-unit', :platform => :ruby_19
+  gem 'rspec', '>=2.4'
+  gem 'rake'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+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)
+    test-unit (2.4.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  parallel
+  rake
+  rspec (>= 2.4)
+  test-unit

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     = "parallelized_specs"
+    gem.summary  = "Run rspec tests in parallel"
+    gem.email    = "jake@instructure.com"
+    gem.homepage = "http://github.com/jake/#{gem.name}"
+    gem.authors  = "Jake Sorce, Bryan Madsen"
+    gem.version = "0.0.1"
+  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,240 @@
+Speedup Test::RSpec by running parallel on multiple CPUs (or cores).<br/>
+ParallelizedSpecs splits tests into even groups(by number of tests or runtime) 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
+
+Loggers
+===================
+
+Even process runtimes
+-----------------
+
+Log test runtime to give each process the same runtime.
+
+Rspec: Add to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_runtime_logger
+      --format ParallelSpecs::SpecRuntimeLogger:tmp/parallel_profile.log
+    RSpec >= 2.4:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecRuntimeLogger --out tmp/parallel_profile.log
+
+Test::Unit:  Add to your `test_helper.rb`:
+    require 'parallel_tests/runtime_logger'
+
+
+SpecSummaryLogger
+--------------------
+
+This logger logs the test output without the different processes overwriting each other.
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_summary_logger
+      --format ParallelSpecs::SpecSummaryLogger:tmp/spec_summary.log
+    RSpec >= 2.2:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --format ParallelSpecs::SpecSummaryLogger --out tmp/spec_summary.log
+
+SpecFailuresLogger
+-----------------------
+
+This logger produces pasteable command-line snippets for each failed example.
+
+E.g.
+
+    rspec /path/to/my_spec.rb:123 # should do something
+
+Add the following to your `spec/parallel_spec.opts` (or `spec/spec.opts`) :
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_specs/spec_failures_logger
+      --format ParallelSpecs::SpecFailuresLogger:tmp/failing_specs.log
+    RSpec >= 2.4:
+      If installed as plugin: -I vendor/plugins/parallel_tests/lib
+      --format progress
+      --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)
+ - [RSpec] remove --loadby from you spec/*.opts
+ - [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)
+ - [Capistrano setup](https://github.com/grosser/parallel_tests/wiki/Remotely-with-capistrano) let your tests run on a big box instead of your laptop
+ - [SQL schema format] use :ruby schema format to get faster parallel:prepare`
+ - [ActiveRecord] if you do not have `db:abort_if_pending_migrations` add this to your Rakefile: `task('db:abort_if_pending_migrations'){}`
+ - `export PARALLEL_TEST_PROCESSORS=X` in your environment and parallel_tests will use this number of processors by default
+ - 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)
+ - [Doug Barth](https://github.com/dougbarth)
+ - [Geoffrey Hichborn](https://github.com/phene)
+ - [Trae Robrock](https://github.com/trobrock)
+ - [Lawrence Wang](https://github.com/levity)
+ - [Sean Walbran](https://github.com/seanwalbran)
+
+[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...<br/>
+[![Flattr](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=grosser&url=https://github.com/grosser/parallel_tests&title=parallel_tests&language=en_GB&tags=github&category=software)

data/VERSION

@@ -0,0 +1 @@
+0.0.1

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,97 @@
+#!/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("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in only one process") do |pattern|
+    options[:single_process] ||= []
+    options[:single_process] << /#{pattern}/
+  end
+  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!
+
+raise "--no-sort and --single-process are not supported" if options[:no_sort] and options[:single_process]
+
+# 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, options)
+  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_specs/spec_error_count_logger.rb

@@ -0,0 +1,30 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecErrorCountLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    super
+    @passed_examples = []
+    @pending_examples = []
+    @failed_examples = []
+  end
+
+  def example_passed(example)
+    @passed_examples << example
+  end
+
+  def example_pending(*args)
+    @pending_examples << args
+  end
+
+  def example_failed(example, count, failure)
+    @failed_examples << failure
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    lock_output do
+      @output.puts "#{ @failed_examples.size }"
+    end
+    @output.flush
+  end
+end

data/lib/parallel_specs/spec_error_logger.rb

@@ -0,0 +1,45 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecErrorLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    super
+    @passed_examples = []
+    @pending_examples = []
+    @failed_examples = []
+  end
+
+  def example_passed(example)
+    @passed_examples << example
+  end
+
+  def example_pending(*args)
+    @pending_examples << args
+  end
+
+  def example_failed(example, count, failure)
+    @failed_examples << failure
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    lock_output do
+      env_test_number = ENV['TEST_ENV_NUMBER']
+      env_test_number = 1 if ENV['TEST_ENV_NUMBER'].blank?
+      @output.puts ""
+      @output.puts ""
+      @output.puts "FOR TEST EXECUTOR #{env_test_number}: #{@failed_examples.size} failed, #{@passed_examples.size} passed:"
+      @failed_examples.each.with_index do | failure, i |
+        @output.puts ""
+        @output.puts "#{ i + 1 })"
+        @output.puts failure.header
+        unless failure.exception.nil?
+          @output.puts failure.exception.to_s
+          failure.exception.backtrace.each do | caller |
+            @output.puts caller
+          end
+        end
+      end
+    end
+    @output.flush
+  end
+end