vinted-parallel_tests 0.13.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14191ef3ae581ab27537c66e193d840bda6cd543
+  data.tar.gz: b8a86d1c3f2ca975d563c0c7531fe7871ac3a06c
+SHA512:
+  metadata.gz: fdcf4a6e6456c7c142ab7fe45ceb751886f6d124585f6a3e1cc8d46dcf09d418ef30c4b5ed6c3426a55b8f901921c3518198ba7ce57ab547e806cb73ca59cce5
+  data.tar.gz: fc9842768d2028f2943e43d905028b2bf0f692682265eae17c0c9ff3ac080073454f8a9cfd7826518e1084c85f277f570a479f8d0da9261645609bc0a5184e35

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - ree
+  - 1.9.3
+  - 2.0.0
+  - jruby-1.7.3
+  - jruby-head

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'bump'
+gem 'test-unit'
+gem 'rspec', '>=2.4'
+gem 'cucumber'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    parallel_tests (0.13.3)
+      parallel
+
+GEM
+  remote: https://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.2.4)
+    gherkin (2.7.6)
+      json (>= 1.4.6)
+    gherkin (2.7.6-java)
+      json (>= 1.4.6)
+    json (1.7.5)
+    json (1.7.5-java)
+    parallel (0.6.5)
+    rake (10.0.3)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    term-ansicolor (1.0.7)
+    test-unit (2.4.4)
+
+PLATFORMS
+  java
+  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,293 @@
+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
+===============
+[RailsCasts episode #413 Fast Tests](http://railscasts.com/episodes/413-fast-tests)
+[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.
+<table>
+  <tr><td>Process number</td><td>1</td><td>2</td><td>3</td></tr>
+  <tr><td>`ENV['TEST_ENV_NUMBER']`</td><td>''</td><td>'2'</td><td>'3'</td></tr>
+</table>
+
+```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
+
+### Run an arbitrary task in parallel
+```Bash
+RAILS_ENV=test parallel_test -e "rake my:custom:task"
+# or
+rake parallel:rake[my:custom:task]
+```
+
+
+Running things once
+===================
+
+```Ruby
+# effected by race-condition: first process may boot slower the second
+# either sleep a bit or use a lock for example File.lock
+ParallelTests.first_process? ? do_something : sleep(1)
+
+at_exit do
+  if ParallelTests.first_process?
+    ParallelTests.wait_for_other_processes_to_finish
+    undo_something
+  end
+end
+```
+
+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
+
+Cucumber: FailuresLogger
+-----------------------
+
+This logger logs failed cucumber scenarios to the specified file. The filename can be passed to cucumber, prefixed with '@' to rerun failures.
+
+Usage:
+
+    cucumber --format ParallelTests::Cucumber::FailuresLogger --out tmp/cucumber_failures.log
+
+Or add the formatter to the `parallel:` profile of your `cucumber.yml`:
+
+    parallel: --format progress --format ParallelTests::Cucumber::FailuresLogger --out tmp/cucumber_failures.log
+
+
+To rerun failures:
+
+	cucumber @tmp/cucumber_failures.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
+        --serialize-stdout           Serialize stdout output, nothing will be written until everything is done
+        --non-parallel               execute same commands but do not in parallel, needs --exec
+        --no-symlinks                Do not traverse symbolic links to find test files
+        --ignore-tags [PATTERN]      When counting steps ignore scenarios with tags that match this pattern
+        --nice                       execute test commands with low priority.
+    -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
+====
+ - make tests consistently pass with `--order random` in .rspec
+ - fix tests vs cucumber >= 1.2 `unknown option --format`
+ - add integration tests for the rake tasks, maybe generate a rails project ...
+ - add unit tests for cucumber runtime formatter
+ - 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)
+ - [Joseph Shraibman](https://github.com/jshraibman-mdsol)
+ - [David Davis](https://github.com/daviddavis)
+ - [Ari Pollak](https://github.com/aripollak)
+ - [Aaron Jensen](https://github.com/aaronjensen)
+ - [Artur Roszczyk](https://github.com/sevos)
+ - [Caleb Tomlinson](https://github.com/calebTomlinson)
+ - [Jawwad Ahmad](https://github.com/jawwad)
+ - [Iain Beeston](https://github.com/iainbeeston)
+ - [Alejandro Pulver](https://github.com/alepulver)
+ - [Felix Clack](https://github.com/felixclack)
+
+[Michael Grosser](http://grosser.it)<br/>
+michael@grosser.it<br/>
+License: MIT<br/>
+[![Build Status](https://travis-ci.org/grosser/parallel_tests.png)](https://travis-ci.org/grosser/parallel_tests)

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,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require "parallel_tests"
+
+ParallelTests::CLI.new.run(["--type", "cucumber"] + ARGV)

data/bin/parallel_rspec

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require "parallel_tests"
+
+ParallelTests::CLI.new.run(["--type", "rspec"] + ARGV)

data/bin/parallel_test

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require "parallel_tests"
+
+ParallelTests::CLI.new.run(["--type", "test"] + ARGV)

data/lib/parallel_tests/cli.rb

@@ -0,0 +1,187 @@
+require 'optparse'
+require 'tempfile'
+require 'parallel_tests'
+
+module ParallelTests
+  class CLI
+    def 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 execute_in_parallel(items, num_processes, options)
+      Tempfile.open 'parallel_tests-lock' do |lock|
+        return Parallel.map(items, :in_threads => num_processes) do |item|
+          result = yield(item)
+          report_output(result, lock) if options[:serialize_stdout]
+          result
+        end
+      end
+    end
+
+    def run_tests_in_parallel(num_processes, options)
+      test_results = nil
+
+      report_time_taken do
+        groups = @runner.tests_in_groups(options[:files], num_processes, options)
+        report_number_of_tests(groups)
+
+        test_results = execute_in_parallel(groups, groups.size, options) do |group|
+          run_tests(group, groups.index(group), num_processes, options)
+        end
+
+        report_results(test_results)
+      end
+
+      abort final_fail_message if any_test_failed?(test_results)
+    end
+
+    def run_tests(group, process_number, num_processes, options)
+      if group.empty?
+        {:stdout => '', :exit_status => 0}
+      else
+        @runner.run_tests(group, process_number, num_processes, options)
+      end
+    end
+
+    def report_output(result, lock)
+      lock.flock File::LOCK_EX
+      $stdout.puts result[:stdout]
+      $stdout.flush
+    ensure
+      lock.flock File::LOCK_UN
+    end
+
+    def report_results(test_results)
+      results = @runner.find_results(test_results.map { |result| result[:stdout] }*"")
+      puts ""
+      puts @runner.summarize_results(results)
+    end
+
+    def report_number_of_tests(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 any_test_failed?(test_results)
+      test_results.any? { |result| result[:exit_status] != 0 }
+    end
+
+    def 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") do |type|
+          begin
+            @runner = load_runner(type)
+          rescue NameError, LoadError => e
+            puts "Runner for `#{type}` type has not been found! (#{e})"
+            abort
+          end
+        end
+        opts.on("--serialize-stdout", "Serialize stdout output, nothing will be written until everything is done") { options[:serialize_stdout] = true }
+        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('--ignore-tags [PATTERN]', 'When counting steps ignore scenarios with tags that match this pattern')  { |arg| options[:ignore_tag_pattern] = arg }
+        opts.on("--nice", "execute test commands with low priority.") { options[:nice] = true }
+        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 load_runner(type)
+      require "parallel_tests/#{type}/runner"
+      klass_name = "ParallelTests::#{type.capitalize.sub("Rspec", "RSpec")}::Runner"
+      klass_name.split('::').inject(Object) { |x, y| x.const_get(y) }
+    end
+
+    def 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, num_processes, options)
+        end
+      else
+        execute_in_parallel(runs, num_processes, options) do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, num_processes, options)
+        end
+      end.flatten
+
+      abort if results.any? { |r| r[:exit_status] != 0 }
+    end
+
+    def report_time_taken
+      start = Time.now
+      yield
+      puts "\nTook #{Time.now - start} seconds"
+    end
+
+    def final_fail_message
+      fail_message = "#{@runner.name}s Failed"
+      fail_message = "\e[31m#{fail_message}\e[0m" if use_colors?
+
+      fail_message
+    end
+
+    def use_colors?
+      $stdout.tty?
+    end
+  end
+end

data/lib/parallel_tests/cucumber/failures_logger.rb

@@ -0,0 +1,25 @@
+require 'cucumber/formatter/rerun'
+require 'parallel_tests/cucumber/io'
+
+module ParallelTests
+  module Cucumber
+    class FailuresLogger < ::Cucumber::Formatter::Rerun
+      include Io
+
+      def initialize(runtime, path_or_io, options)
+        @io = prepare_io(path_or_io)
+      end
+
+      def after_feature(feature)
+        unless @lines.empty?
+          lock_output do
+            @lines.each do |line|
+              @io.puts "#{feature.file}:#{line}"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end