friendlyfashion-parallel_tests 0.9.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+gemspec
+
+gem 'bump'
+gem 'test-unit', :platform => :ruby_19
+gem 'rspec', '>=2.4'
+gem 'cucumber'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    parallel_tests (0.9.0)
+      parallel
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    bump (0.3.8)
+    cucumber (1.1.4)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.7.1)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    gherkin (2.7.6)
+      json (>= 1.4.6)
+    json (1.7.5)
+    parallel (0.6.1)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+    term-ansicolor (1.0.7)
+    test-unit (2.4.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bump
+  cucumber
+  parallel_tests!
+  rake
+  rspec (>= 2.4)
+  test-unit

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bump/tasks'
+require 'bundler/gem_tasks'
+
+task :default do
+  sh "rspec spec/"
+end

data/Readme.md

@@ -0,0 +1,232 @@
+Speedup Test::Unit + RSpec + Cucumber by running parallel on multiple CPUs (or cores).<br/>
+ParallelTests splits tests into even groups(by number of tests or runtime) and runs each group in a single process with its own database.
+
+[upgrading from 0.6 ?](https://github.com/grosser/parallel_tests/wiki/Upgrading-0.6.x-to-0.7.x)
+
+Setup for Rails
+===============
+[still using Rails 2?](https://github.com/grosser/parallel_tests/blob/master/ReadmeRails2.md)
+
+### Install
+If you use RSpec: ensure you got >= 2.4
+
+As gem
+
+```ruby
+# add to Gemfile
+gem "parallel_tests", :group => :development
+```
+OR as plugin
+
+    rails plugin install git://github.com/grosser/parallel_tests.git
+
+```ruby
+# add to Gemfile
+gem "parallel", :group => :development
+```
+
+### Add to `config/database.yml`
+ParallelTests uses 1 database per test-process, 2 processes will use `*_test` and `*_test2`.
+
+```yaml
+test:
+  database: yourproject_test<%= ENV['TEST_ENV_NUMBER'] %>
+```
+
+### Create additional database(s)
+    rake parallel:create
+
+### Copy development schema (repeat after migrations)
+    rake parallel:prepare
+
+### 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[^test/unit] # every test file in test/unit folder
+    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 `.rspec_parallel` (or `.rspec`) :
+
+    If installed as plugin: -I vendor/plugins/parallel_tests/lib
+    --format progress
+    --format ParallelTests::RSpec::RuntimeLogger --out tmp/parallel_runtime_rspec.log
+
+Test::Unit:  Add to your `test_helper.rb`:
+```ruby
+require 'parallel_tests/test/runtime_logger'
+```
+
+RSpec: SummaryLogger
+--------------------
+
+This logger logs the test output without the different processes overwriting each other.
+
+Add the following to your `.rspec_parallel` (or `.rspec`) :
+
+    If installed as plugin: -I vendor/plugins/parallel_tests/lib
+    --format progress
+    --format ParallelTests::RSpec::SummaryLogger --out tmp/spec_summary.log
+
+RSpec: FailuresLogger
+-----------------------
+
+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 `.rspec_parallel` (or `.rspec`) :
+
+    If installed as plugin: -I vendor/plugins/parallel_tests/lib
+    --format progress
+    --format ParallelTests::RSpec::FailuresLogger --out tmp/failing_specs.log
+
+Setup for non-rails
+===================
+    gem install parallel_tests
+    # go to your project dir
+    parallel_test test/
+    parallel_rspec spec/
+    parallel_cucumber features/
+
+ - use ENV['TEST_ENV_NUMBER'] inside your tests to select separate db/memcache/etc.
+ - Only run selected files & folders:
+
+    parallel_test test/bar test/baz/foo_text.rb
+
+Options are:
+
+    -n [PROCESSES]                   How many processes to use, default: available CPUs
+    -p, --pattern [PATTERN]          run tests matching this pattern
+        --group-by [TYPE]            group tests by:
+          found - order of finding files
+          steps - number of cucumber steps
+          default - runtime or filesize
+    -m, --multiply-processes [FLOAT] use given number as a multiplier of processes to run
+    -s, --single [PATTERN]           Run all matching files in the same process
+    -i, --isolate                    Do not run any other tests in the group used by --single(-s)
+    -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]                test(default) / rspec / cucumber
+        --non-parallel               execute same commands but do not in parallel, needs --exec
+        --no-symlinks                Do not traverse symbolic links to find test files
+    -v, --version                    Show Version
+    -h, --help                       Show this.
+
+You can run any kind of code in parallel 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
+====
+ - [RSpec] add a `.rspec_parallel` to use different options, e.g. **no --drb**
+ - [RSpec] delete `script/spec`
+ - [[Spork](https://github.com/sporkrb/spork)] does not work with parallel_tests
+ - [RSpec] remove --loadby from you spec/*.opts
+ - [RSpec] Instantly see failures (instead of just a red F) with [rspec-instafail](https://github.com/grosser/rspec-instafail)
+ - [Bundler] if you have a `Gemfile` then `bundle exec` will be used to run tests
+ - [Cucumber] add a `parallel: foo` profile to your `config/cucumber.yml` and it will be used to run parallel 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`
+ - `export PARALLEL_TEST_PROCESSORS=X` in your environment and parallel_tests will use this number of processors by default
+ - [ZSH] use quotes to use rake arguments `rake "parallel:prepare[3]"`
+ - [email_spec and/or action_mailer_cache_delivery](https://github.com/grosser/parallel_tests/wiki)
+ - [Memcached] use different namespaces e.g. `config.cache_store = ..., :namespace => "test_#{ENV['TEST_ENV_NUMBER']}"`
+
+TODO
+====
+ - fix tests vs cucumber >= 1.2 `unknown option --format`
+ - add tests for the rake tasks, maybe generate a rails project ...
+ - add unit tests for cucumber runtime formatter
+ - 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)
+ - [Lawrence Wang](https://github.com/levity)
+ - [Potapov Sergey](https://github.com/greyblake)
+ - [Łukasz Tackowiak](https://github.com/lukasztackowiak)
+ - [Pedro Carriço](https://github.com/pedrocarrico)
+ - [Pablo Manrubia Díez](https://github.com/pmanrubia)
+ - [Slawomir Smiechura](https://github.com/ssmiech)
+ - [Georg Friedrich](https://github.com/georg)
+ - [R. Tyler Croy](https://github.com/rtyler)
+ - [Ulrich Berkmüller](https://github.com/ulrich-berkmueller)
+ - [Grzegorz Derebecki](https://github.com/madmax)
+ - [Florian Motlik](https://github.com/flomotlik)
+ - [Artem Kuzko](https://github.com/akuzko)
+ - [Zeke Fast](https://github.com/zekefast)
+
+[Michael Grosser](http://grosser.it)<br/>
+michael@grosser.it<br/>
+License: MIT

data/ReadmeRails2.md

@@ -0,0 +1,48 @@
+### Install
+
+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
+
+    # add to Rakefile
+    begin; require 'vendor/plugins/parallel_tests/lib/parallel_tests/tasks'; rescue LoadError; end
+
+
+Even process runtimes
+-----------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/rspec/runtime_logger
+      --format ParallelTests::RSpec::RuntimeLogger:tmp/parallel_runtime_rspec.log
+
+SpecSummaryLogger
+--------------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/rspec/summary_logger
+      --format ParallelTests::RSpec::SummaryLogger:tmp/spec_summary.log
+
+SpecFailuresLogger
+-----------------------
+
+    RSpec 1.x:
+      --format progress
+      --require parallel_tests/rspec/failures_logger
+      --format ParallelTests::RSpec::FailuresLogger:tmp/failing_specs.log

data/bin/parallel_cucumber

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

data/bin/parallel_rspec

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

data/bin/parallel_test

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "parallel_tests"
+require "parallel_tests/cli"
+
+ParallelTest::CLI.run(ARGV)

data/lib/parallel_tests.rb

@@ -0,0 +1,30 @@
+require 'parallel'
+require 'parallel_tests/version'
+require 'parallel_tests/grouper'
+require 'parallel_tests/railtie' if defined? Rails::Railtie
+
+module ParallelTests
+  def self.determine_number_of_processes(count)
+    [
+      count,
+      ENV['PARALLEL_TEST_PROCESSORS'],
+      Parallel.processor_count
+    ].detect{|c| not c.to_s.strip.empty? }.to_i
+  end
+
+  # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
+  def self.bundler_enabled?
+    return true if Object.const_defined?(:Bundler)
+
+    previous = nil
+    current = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      filename = File.join(current, "Gemfile")
+      return true if File.exists?(filename)
+      current, previous = File.expand_path("..", current), current
+    end
+
+    false
+  end
+end

data/lib/parallel_tests/cli.rb

@@ -0,0 +1,159 @@
+require 'optparse'
+require 'parallel_tests/test/runner'
+
+module ParallelTest
+  module CLI
+    def self.run(argv)
+      options = parse_options!(argv)
+
+      num_processes = ParallelTests.determine_number_of_processes(options[:count])
+      num_processes = num_processes * (options[:multiply] || 1)
+
+      if options[:execute]
+        execute_shell_command_in_parallel(options[:execute], num_processes, options)
+      else
+        run_tests_in_parallel(num_processes, options)
+      end
+    end
+
+    private
+
+    def self.run_tests_in_parallel(num_processes, options)
+      test_results = nil
+      lib = options[:type] || 'test'
+      runner = load_runner_for(lib)
+
+      report_time_taken do
+        groups = runner.tests_in_groups(options[:files], num_processes, options)
+        report_number_of_tests(runner, groups)
+
+        test_results = Parallel.map(groups, :in_processes => groups.size) do |group|
+          run_tests(runner, group, groups.index(group), options)
+        end
+
+        report_results(runner, test_results)
+      end
+
+      abort final_fail_message(lib) if any_test_failed?(test_results)
+    end
+
+    def self.run_tests(runner, group, process_number, options)
+      if group.empty?
+        {:stdout => '', :exit_status => 0}
+      else
+        runner.run_tests(group, process_number, options)
+      end
+    end
+
+    def self.report_results(runner, test_results)
+      results = runner.find_results(test_results.map { |result| result[:stdout] }*"")
+      puts ""
+      puts runner.summarize_results(results)
+    end
+
+    def self.report_number_of_tests(runner, groups)
+      name = runner.test_file_name
+      num_processes = groups.size
+      num_tests = groups.map(&:size).inject(:+)
+      puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+    end
+
+    #exit with correct status code so rake parallel:test && echo 123 works
+    def self.any_test_failed?(test_results)
+      test_results.any? { |result| result[:exit_status] != 0 }
+    end
+
+    def self.load_runner_for(lib)
+      require "parallel_tests/#{lib}/runner"
+      eval("ParallelTests::#{lib.capitalize.sub('Rspec','RSpec')}::Runner")
+    end
+
+    def self.parse_options!(argv)
+      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("--group-by [TYPE]", <<-TEXT
+group tests by:
+          found - order of finding files
+          steps - number of cucumber steps
+          default - runtime or filesize
+TEXT
+) { |type| options[:group_by] = type.to_sym }
+        opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run") { |multiply| options[:multiply] = multiply }
+
+        opts.on("-s [PATTERN]", "--single [PATTERN]",
+          "Run all matching files in the same process") do |pattern|
+
+          options[:single_process] ||= []
+          options[:single_process] << /#{pattern}/
+        end
+
+        opts.on("-i", "--isolate",
+          "Do not run any other tests in the group used by --single(-s)") do |pattern|
+
+          options[:isolate] = true
+        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]", "test(default) / rspec / cucumber") { |type| options[:type] = type }
+        opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec") { options[:non_parallel] = true }
+        opts.on("--no-symlinks", "Do not traverse symbolic links to find test files") { options[:symlinks] = false }
+        opts.on("--advance-number [NUMBER]", Integer, "Advance test env number by specified number") { |n| options[:advance_number] = n }
+        opts.on("-v", "--version", "Show Version") { puts ParallelTests::VERSION; exit }
+        opts.on("-h", "--help", "Show this.") { puts opts; exit }
+      end.parse!(argv)
+
+      raise "--group-by found and --single-process are not supported" if options[:group_by] == :found and options[:single_process]
+
+      if options[:count] == 0
+        options.delete(:count)
+        options[:non_parallel] = true
+      end
+
+      options[:files] = argv
+      options
+    end
+
+    def self.execute_shell_command_in_parallel(command, num_processes, options)
+      runs = (0...num_processes).to_a
+      results = if options[:non_parallel]
+        runs.map do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, options)
+        end
+      else
+        Parallel.map(runs, :in_processes => num_processes) do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, options)
+        end
+      end.flatten
+
+      abort if results.any? { |r| r[:exit_status] != 0 }
+    end
+
+    def self.report_time_taken
+      start = Time.now
+      yield
+      puts "\nTook #{Time.now - start} seconds"
+    end
+
+    def self.final_fail_message(lib)
+      fail_message = "#{lib.capitalize}s Failed"
+      fail_message = "\e[31m#{fail_message}\e[0m" if use_colors?
+
+      fail_message
+    end
+
+    def self.use_colors?
+      $stdout.tty?
+    end
+  end
+end