parallel_tests 1.0.9 → 1.1.0

data/lib/parallel_tests/test/runner.rb

@@ -1,186 +0,0 @@
-require 'parallel_tests'
-
-module ParallelTests
-  module Test
-    class Runner
-      NAME = 'Test'
-
-      class << self
-        # --- usually overwritten by other runners
-
-        def name
-          NAME
-        end
-
-        def runtime_log
-          'tmp/parallel_runtime_test.log'
-        end
-
-        def test_suffix
-          /_(test|spec).rb$/
-        end
-
-        def test_file_name
-          "test"
-        end
-
-        def run_tests(test_files, process_number, num_processes, options)
-          require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
-          cmd = "#{executable} -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
-          execute_command(cmd, process_number, num_processes, options)
-        end
-
-        def line_is_result?(line)
-          line.gsub!(/[.F*]/,'')
-          line =~ /\d+ failure/
-        end
-
-        # --- usually used by other runners
-
-        # finds all tests and partitions them into groups
-        def tests_in_groups(tests, num_groups, options={})
-          tests = find_tests(tests, options)
-
-          tests = if options[:group_by] == :found
-            tests.map { |t| [t, 1] }
-          elsif options[:group_by] == :filesize
-            with_filesize_info(tests)
-          else
-            with_runtime_info(tests, options)
-          end
-          Grouper.in_even_groups_by_size(tests, num_groups, options)
-        end
-
-        def execute_command(cmd, process_number, num_processes, options)
-          env = (options[:env] || {}).merge(
-            "TEST_ENV_NUMBER" => test_env_number(process_number),
-            "PARALLEL_TEST_GROUPS" => num_processes
-          )
-          cmd = "nice #{cmd}" if options[:nice]
-          cmd = "#{cmd} 2>&1" if options[:combine_stderr]
-
-          execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
-        end
-
-        def execute_command_and_capture_output(env, cmd, silence)
-          # make processes descriptive / visible in ps -ef
-          separator = (WINDOWS ? ' & ' : ';')
-          exports = env.map do |k,v|
-            if WINDOWS
-              "(SET \"#{k}=#{v}\")"
-            else
-              "#{k}=#{v};export #{k}"
-            end
-          end.join(separator)
-          cmd = "#{exports}#{separator}#{cmd}"
-
-          output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
-          exitstatus = $?.exitstatus
-
-          {:stdout => output, :exit_status => exitstatus}
-        end
-
-        def find_results(test_output)
-          test_output.split("\n").map {|line|
-            line.gsub!(/\e\[\d+m/,'')
-            next unless line_is_result?(line)
-            line
-          }.compact
-        end
-
-        def test_env_number(process_number)
-          process_number == 0 ? '' : process_number + 1
-        end
-
-        def summarize_results(results)
-          sums = sum_up_results(results)
-          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
-        end
-
-        protected
-
-        def executable
-          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
-        end
-
-        def determine_executable
-          "ruby"
-        end
-
-        def sum_up_results(results)
-          results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
-          counts = results.scan(/(\d+) (\w+)/)
-          counts.inject(Hash.new(0)) do |sum, (number, word)|
-            sum[word] += number.to_i
-            sum
-          end
-        end
-
-        # read output of the process and print it in chunks
-        def capture_output(out, silence)
-          result = ""
-          loop do
-            begin
-              read = out.readpartial(1000000) # read whatever chunk we can get
-              if RUBY_VERSION >= "1.9" && Encoding.default_internal
-                read = read.force_encoding(Encoding.default_internal)
-              end
-              result << read
-              unless silence
-                $stdout.print read
-                $stdout.flush
-              end
-            end
-          end rescue EOFError
-          result
-        end
-
-        def with_runtime_info(tests, options = {})
-          log = options[:runtime_log] || runtime_log
-          lines = File.read(log).split("\n") rescue []
-
-          # use recorded test runtime if we got enough data
-          if lines.size * 1.5 > tests.size
-            puts "Using recorded test runtime: #{log}"
-            times = Hash.new(1)
-            lines.each do |line|
-              test, time = line.split(":")
-              next unless test and time
-              times[File.expand_path(test)] = time.to_f
-            end
-            tests.sort.map{|test| [test, times[File.expand_path(test)]] }
-          else # use file sizes
-            with_filesize_info(tests)
-          end
-        end
-
-        def with_filesize_info(tests)
-          # use filesize to group files
-          tests.sort.map { |test| [test, File.stat(test).size] }
-        end
-
-        def find_tests(tests, options = {})
-          (tests || []).map do |file_or_folder|
-            if File.directory?(file_or_folder)
-              files = files_in_folder(file_or_folder, options)
-              files.grep(test_suffix).grep(options[:pattern]||//)
-            else
-              file_or_folder
-            end
-          end.flatten.uniq
-        end
-
-        def files_in_folder(folder, options={})
-          pattern = if options[:symlinks] == false # not nil or true
-            "**/*"
-          else
-            # follow one symlink and direct children
-            # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
-            "**{,/*/**}/*"
-          end
-          Dir[File.join(folder, pattern)].uniq
-        end
-      end
-    end
-  end
-end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -1,98 +0,0 @@
-require 'parallel_tests'
-require 'parallel_tests/test/runner'
-
-module ParallelTests
-  module Test
-    class RuntimeLogger
-      @@has_started = false
-
-      class << self
-        def log(test, start_time, end_time)
-          return if test.is_a? ::Test::Unit::TestSuite # don't log for suites-of-suites
-
-          if !@@has_started # make empty log file
-            File.open(logfile, 'w'){}
-            @@has_started = true
-          end
-
-          locked_appending_to(logfile) do |file|
-            file.puts(message(test, start_time, end_time))
-          end
-        end
-
-        private
-
-        def message(test, start_time, end_time)
-          delta = "%.2f" % (end_time.to_f-start_time.to_f)
-          filename = class_directory(test.class) + class_to_filename(test.class) + ".rb"
-          "#{filename}:#{delta}"
-        end
-
-        # Note: this is a best guess at conventional test directory structure, and may need
-        # tweaking / post-processing to match correctly for any given project
-        def class_directory(suspect)
-          result = "test/"
-
-          if defined?(Rails)
-            result += case suspect.superclass.name
-            when "ActionDispatch::IntegrationTest"
-              "integration/"
-            when "ActionDispatch::PerformanceTest"
-              "performance/"
-            when "ActionController::TestCase"
-              "functional/"
-            when "ActionView::TestCase"
-              "unit/helpers/"
-            else
-              "unit/"
-            end
-          end
-          result
-        end
-
-        # based on https://github.com/grosser/single_test/blob/master/lib/single_test.rb#L117
-        def class_to_filename(suspect)
-          word = suspect.to_s.dup
-          return word unless word.match /^[A-Z]/ and not word.match %r{/[a-z]}
-
-          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-          word.gsub!(/\:\:/, '/')
-          word.tr!("-", "_")
-          word.downcase!
-          word
-        end
-
-        def locked_appending_to(file)
-          File.open(file, 'a') do |f|
-            begin
-              f.flock File::LOCK_EX
-              yield f
-            ensure
-              f.flock File::LOCK_UN
-            end
-          end
-        end
-
-        def logfile
-          ParallelTests::Test::Runner.runtime_log
-        end
-      end
-    end
-  end
-end
-
-require 'test/unit/testsuite'
-class ::Test::Unit::TestSuite
-  alias :run_without_timing :run unless defined? @@timing_installed
-
-  def run(result, &progress_block)
-    first_test = self.tests.first
-    start_time = ParallelTests.now
-    run_without_timing(result, &progress_block)
-    end_time = ParallelTests.now
-    ParallelTests::Test::RuntimeLogger.log(first_test, start_time, end_time)
-  end
-
-  @@timing_installed = true
-end

data/lib/parallel_tests/version.rb

@@ -1,3 +0,0 @@
-module ParallelTests
-  VERSION = Version = '1.0.9'
-end

data/parallel_tests.gemspec

@@ -1,14 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-name = "parallel_tests"
-require "#{name}/version"
-
-Gem::Specification.new name, ParallelTests::VERSION do |s|
-  s.summary = "Run Test::Unit / RSpec / Cucumber / Spinach in parallel"
-  s.authors = ["Michael Grosser"]
-  s.email = "michael@grosser.it"
-  s.homepage = "http://github.com/grosser/#{name}"
-  s.files = `git ls-files`.split("\n")
-  s.license = "MIT"
-  s.executables = ["parallel_spinach", "parallel_cucumber", "parallel_rspec", "parallel_test"]
-  s.add_runtime_dependency "parallel"
-end

data/spec/integration_spec.rb

@@ -1,437 +0,0 @@
-#encoding: utf-8
-
-require 'spec_helper'
-
-describe 'CLI' do
-  before do
-    `rm -rf #{folder}`
-  end
-
-  after do
-    `rm -rf #{folder}`
-  end
-
-  def folder
-    "/tmp/parallel_tests_tests"
-  end
-
-  def write(file, content)
-    path = "#{folder}/#{file}"
-    ensure_folder File.dirname(path)
-    File.open(path, 'w'){|f| f.write content }
-    path
-  end
-
-  def read(file)
-    File.read "#{folder}/#{file}"
-  end
-
-  def bin_folder
-    "#{File.expand_path(File.dirname(__FILE__))}/../bin"
-  end
-
-  def executable(options={})
-    "#{bin_folder}/parallel_#{options[:type] || 'test'}"
-  end
-
-  def ensure_folder(folder)
-    `mkdir -p #{folder}` unless File.exist?(folder)
-  end
-
-  def run_tests(test_folder, options={})
-    ensure_folder folder
-    processes = "-n #{options[:processes]||2}" unless options[:processes] == false
-    command = "cd #{folder} && #{options[:export]} #{executable(options)} #{test_folder} #{processes} #{options[:add]} 2>&1"
-    result = `#{command}`
-    raise "FAILED #{command}\n#{result}" if $?.success? == !!options[:fail]
-    result
-  end
-
-  it "runs tests in parallel" do
-    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
-    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
-    result = run_tests "spec", :type => 'rspec'
-
-    # test ran and gave their puts
-    result.should include('TEST1')
-    result.should include('TEST2')
-
-    # all results present
-    result.scan('1 example, 0 failure').size.should == 2 # 2 results
-    result.scan('2 examples, 0 failures').size.should == 1 # 1 summary
-    result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
-    result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
-  end
-
-  it "runs tests which outputs accented characters" do
-    write "spec/xxx_spec.rb", "#encoding: utf-8\ndescribe('it'){it('should'){puts 'Byłem tu'}}"
-    result = run_tests "spec", :type => 'rspec'
-    # test ran and gave their puts
-    result.should include('Byłem tu')
-  end
-
-  it "respects default encoding when reading child stdout", :encoding => true do
-    write 'test/xxx_test.rb', <<-EOF
-      # encoding: utf-8
-      require 'test/unit'
-      class XTest < Test::Unit::TestCase
-        def test_unicode
-          raise '¯\\_(ツ)_/¯'
-        end
-      end
-    EOF
-    # Need to tell Ruby to default to utf-8 to simulate environments where
-    # this is set. (Otherwise, it defaults to nil and the undefined conversion
-    # issue doesn't come up.)
-    result = run_tests('test', :fail => true,
-                       :export => 'RUBYOPT=-Eutf-8:utf-8')
-    result.should include('¯\_(ツ)_/¯')
-  end
-
-  it "does not run any tests if there are none" do
-    write 'spec/xxx_spec.rb', '1'
-    result = run_tests "spec", :type => 'rspec'
-    result.should include('No examples found')
-    result.should include('Took')
-  end
-
-  it "fails when tests fail" do
-    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
-    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
-    result = run_tests "spec", :fail => true, :type => 'rspec'
-
-    result.scan('1 example, 1 failure').size.should == 1
-    result.scan('1 example, 0 failure').size.should == 1
-    result.scan('2 examples, 1 failure').size.should == 1
-  end
-
-  it "can serialize stdout" do
-    write 'spec/xxx_spec.rb', '5.times{describe("it"){it("should"){sleep 0.01; puts "TEST1"}}}'
-    write 'spec/xxx2_spec.rb', 'sleep 0.01; 5.times{describe("it"){it("should"){sleep 0.01; puts "TEST2"}}}'
-    result = run_tests "spec", :type => 'rspec', :add => "--serialize-stdout"
-
-    result.should_not =~ /TEST1.*TEST2.*TEST1/m
-    result.should_not =~ /TEST2.*TEST1.*TEST2/m
-  end
-
-  it "can serialize stdout and stderr" do
-    write 'spec/xxx_spec.rb', '5.times{describe("it"){it("should"){sleep 0.01; $stderr.puts "errTEST1"; puts "TEST1"}}}'
-    write 'spec/xxx2_spec.rb', 'sleep 0.01; 5.times{describe("it"){it("should"){sleep 0.01; $stderr.puts "errTEST2"; puts "TEST2"}}}'
-    result = run_tests "spec", :type => 'rspec', :add => "--serialize-stdout --combine-stderr"
-
-    result.should_not =~ /TEST1.*TEST2.*TEST1/m
-    result.should_not =~ /TEST2.*TEST1.*TEST2/m
-  end
-
-  context "with given commands" do
-    it "can exec given commands with ENV['TEST_ENV_NUM']" do
-      result = `#{executable} -e 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"' -n 4`
-      result.gsub('"','').split('').sort.should == %w[0 2 3 4]
-    end
-
-    it "can exec given command non-parallel" do
-      result = `#{executable} -e 'ruby -e "sleep(rand(10)/100.0); puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4 --non-parallel`
-      result.split("\n").should == %w["" "2" "3" "4"]
-    end
-
-    it "can serialize stdout" do
-      result = `#{executable} -e 'ruby -e "5.times{sleep 0.01;puts ENV[:TEST_ENV_NUMBER.to_s].to_i;STDOUT.flush}"' -n 2 --serialize-stdout`
-      result.should_not =~ /0.*2.*0/m
-      result.should_not =~ /2.*0.*2/m
-    end
-
-    it "exists with success if all sub-processes returned success" do
-      system("#{executable} -e 'cat /dev/null' -n 4").should == true
-    end
-
-    it "exists with failure if any sub-processes returned failure" do
-      system("#{executable} -e 'test -e xxxx' -n 4").should == false
-    end
-  end
-
-  it "runs through parallel_rspec" do
-    version = `#{executable} -v`
-    `#{bin_folder}/parallel_rspec -v`.should == version
-  end
-
-  it "runs through parallel_cucumber" do
-    version = `#{executable} -v`
-    `#{bin_folder}/parallel_cucumber -v`.should == version
-  end
-
-  it "runs through parallel_spinach" do
-    version = `#{executable} -v`
-    `#{bin_folder}/parallel_spinach -v`.should == version
-  end
-
-  it "runs with --group-by found" do
-    # it only tests that it does not blow up, as it did before fixing...
-    write "spec/x1_spec.rb", "puts '111'"
-    run_tests "spec", :type => 'rspec', :add => '--group-by found'
-  end
-
-  it "runs faster with more processes" do
-    pending if RUBY_PLATFORM == "java"  # just too slow ...
-    2.times{|i|
-      write "spec/xxx#{i}_spec.rb",  'describe("it"){it("should"){sleep 5}}; $stderr.puts ENV["TEST_ENV_NUMBER"]'
-    }
-    t = Time.now
-    run_tests("spec", :processes => 2, :type => 'rspec')
-    expected = 10
-    (Time.now - t).should <= expected
-  end
-
-  it "can run with given files" do
-    write "spec/x1_spec.rb", "puts '111'"
-    write "spec/x2_spec.rb", "puts '222'"
-    write "spec/x3_spec.rb", "puts '333'"
-    result = run_tests "spec/x1_spec.rb spec/x3_spec.rb", :type => 'rspec'
-    result.should include('111')
-    result.should include('333')
-    result.should_not include('222')
-  end
-
-  it "runs successfully without any files" do
-    results = run_tests "", :type => 'rspec'
-    results.should include("2 processes for 0 specs")
-    results.should include("Took")
-  end
-
-  it "can run with test-options" do
-    write "spec/x1_spec.rb", "111"
-    write "spec/x2_spec.rb", "111"
-    result = run_tests "spec",
-      :add => "--test-options ' --version'",
-      :processes => 2,
-      :type => 'rspec'
-    result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
-  end
-
-  it "runs with PARALLEL_TEST_PROCESSORS processes" do
-    processes = 5
-    processes.times{|i|
-      write "spec/x#{i}_spec.rb", "puts %{ENV-\#{ENV['TEST_ENV_NUMBER']}-}"
-    }
-    result = run_tests "spec",
-      :export => "PARALLEL_TEST_PROCESSORS=#{processes}",
-      :processes => processes,
-      :type => 'rspec'
-    result.scan(/ENV-.?-/).should =~ ["ENV--", "ENV-2-", "ENV-3-", "ENV-4-", "ENV-5-"]
-  end
-
-  it "filters test by given pattern and relative paths" do
-    write "spec/x_spec.rb", "puts 'XXX'"
-    write "spec/y_spec.rb", "puts 'YYY'"
-    write "spec/z_spec.rb", "puts 'ZZZ'"
-    result = run_tests "spec", :add => "-p '^spec/(x|z)'", :type => "rspec"
-    result.should include('XXX')
-    result.should_not include('YYY')
-    result.should include('ZZZ')
-  end
-
-  it "can wait_for_other_processes_to_finish" do
-    pending if RUBY_PLATFORM == "java" # just too slow ...
-    write "test/a_test.rb", "require 'parallel_tests'; sleep 0.5 ; ParallelTests.wait_for_other_processes_to_finish; puts 'a'"
-    write "test/b_test.rb", "sleep 1; puts 'b'"
-    write "test/c_test.rb", "sleep 1.5; puts 'c'"
-    write "test/d_test.rb", "sleep 2; puts 'd'"
-    run_tests("test", :processes => 4).should include("b\nc\nd\na\n")
-  end
-
-  it "can run only a single group" do
-    pending if RUBY_PLATFORM == "java" # just too slow ...
-    write "test/long_test.rb", "puts 'this is a long test'"
-    write "test/short_test.rb", "puts 'short test'"
-
-    group_1_result = run_tests("test", :processes => 2, :add => '--only-group 1')
-    group_1_result.should include("this is a long test")
-    group_1_result.should_not include("short test")
-
-    group_2_result = run_tests("test", :processes => 2, :add => '--only-group 2')
-    group_2_result.should_not include("this is a long test")
-    group_2_result.should include("short test")
-  end
-
-  context "Test::Unit" do
-    it "runs" do
-      write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
-      result = run_tests("test")
-      result.should include('1 test')
-    end
-
-    it "passes test options" do
-      write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
-      result = run_tests("test", :add => '--test-options "-v"')
-      result.should include('test_xxx') # verbose output of every test
-    end
-
-    it "runs successfully without any files" do
-      results = run_tests("")
-      results.should include("2 processes for 0 tests")
-      results.should include("Took")
-    end
-  end
-
-  context "Cucumber" do
-    before do
-      write "features/steps/a.rb", "
-        Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }
-        And('I sleep a bit'){ sleep 0.2 }
-        And('I pass'){ true }
-        And('I fail'){ fail }
-      "
-    end
-
-    it "runs tests which outputs accented characters" do
-      write "features/good1.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print accented characters"
-      write "features/steps/a.rb", "#encoding: utf-8\nGiven('I print accented characters'){ puts \"I tu też\" }"
-      result = run_tests "features", :type => "cucumber", :add => '--pattern good'
-      result.should include('I tu też')
-    end
-
-    it "passes TEST_ENV_NUMBER when running with pattern (issue #86)" do
-      write "features/good1.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      write "features/good2.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      write "features/b.feature", "Feature: xxx\n  Scenario: xxx\n    Given I FAIL"
-      write "features/steps/a.rb", "Given('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }"
-
-      result = run_tests "features", :type => "cucumber", :add => '--pattern good'
-
-      result.should include('YOUR TEST ENV IS 2!')
-      result.should include('YOUR TEST ENV IS !')
-      result.should_not include('I FAIL')
-    end
-
-    it "writes a runtime log" do
-      pending "TODO find out why this fails" if RUBY_PLATFORM == "java"
-
-      log = "tmp/parallel_runtime_cucumber.log"
-      write(log, "x")
-      2.times{|i|
-        # needs sleep so that runtime loggers dont overwrite each other initially
-        write "features/good#{i}.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER\n    And I sleep a bit"
-      }
-      run_tests "features", :type => "cucumber"
-      read(log).gsub(/\.\d+/,'').split("\n").should =~ [
-        "features/good0.feature:0",
-        "features/good1.feature:0"
-      ]
-    end
-
-    it "runs each feature once when there are more processes then features (issue #89)" do
-      2.times{|i|
-        write "features/good#{i}.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      }
-      result = run_tests "features", :type => "cucumber", :add => '-n 3'
-      result.scan(/YOUR TEST ENV IS \d?!/).sort.should == ["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"]
-    end
-
-    it "runs successfully without any files" do
-      results = run_tests("", :type => "cucumber")
-      results.should include("2 processes for 0 features")
-      results.should include("Took")
-    end
-
-    it "collates failing scenarios" do
-      write "features/pass.feature", "Feature: xxx\n  Scenario: xxx\n    Given I pass"
-      write "features/fail1.feature", "Feature: xxx\n  Scenario: xxx\n    Given I fail"
-      write "features/fail2.feature", "Feature: xxx\n  Scenario: xxx\n    Given I fail"
-      results = run_tests "features", :processes => 3, :type => "cucumber", :fail => true
-
-      results.should include """
-Failing Scenarios:
-cucumber features/fail2.feature:2 # Scenario: xxx
-cucumber features/fail1.feature:2 # Scenario: xxx
-
-3 scenarios (2 failed, 1 passed)
-3 steps (2 failed, 1 passed)
-"""
-    end
-
-    it "groups by scenario" do
-      write "features/long.feature", <<-EOS
-      Feature: xxx
-        Scenario: xxx
-          Given I print TEST_ENV_NUMBER
-
-        Scenario: xxx
-          Given I print TEST_ENV_NUMBER
-
-        Scenario Outline: xxx
-          Given I print TEST_ENV_NUMBER
-
-        Examples:
-          | num |
-          | one |
-          | two |
-      EOS
-      result = run_tests "features", :type => "cucumber", :add => "--group-by scenarios"
-      result.should include("2 processes for 4 scenarios")
-    end
-
-    it "groups by step" do
-      write "features/good1.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      write "features/good2.feature", "Feature: xxx\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-
-      result = run_tests "features", :type => "cucumber", :add => '--group-by steps'
-
-      result.should include("2 processes for 2 features")
-    end
-  end
-
-  context "Spinach", :fails_on_ruby_187 => true do
-    before do
-      write "features/steps/a.rb", "class A < Spinach::FeatureSteps\n  Given 'I print TEST_ENV_NUMBER' do\n    puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\"\n  end\n  And 'I sleep a bit' do\n    sleep 0.2\n  end\nend"
-    end
-
-    it "runs tests which outputs accented characters" do
-      write "features/good1.feature", "Feature: a\n  Scenario: xxx\n    Given I print accented characters"
-      write "features/steps/a.rb", "#encoding: utf-8\nclass A < Spinach::FeatureSteps\nGiven 'I print accented characters' do\n  puts \"I tu też\" \n  end\nend"
-      result = run_tests "features", :type => "spinach", :add => 'features/good1.feature'#, :add => '--pattern good'
-      result.should include('I tu też')
-    end
-
-    it "passes TEST_ENV_NUMBER when running with pattern (issue #86)" do
-      write "features/good1.feature", "Feature: a\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      write "features/good2.feature", "Feature: a\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER"
-      write "features/b.feature", "Feature: b\n  Scenario: xxx\n    Given I FAIL" #Expect this not to be run
-      write "features/steps/a.rb", "class A < Spinach::FeatureSteps\nGiven('I print TEST_ENV_NUMBER'){ puts \"YOUR TEST ENV IS \#{ENV['TEST_ENV_NUMBER']}!\" }\nend"
-
-      result = run_tests "features", :type => "spinach", :add => '--pattern good'
-
-      result.should include('YOUR TEST ENV IS 2!')
-      result.should include('YOUR TEST ENV IS !')
-      result.should_not include('I FAIL')
-    end
-
-    it "writes a runtime log" do
-      pending 'not yet implemented -- custom runtime logging'
-      log = "tmp/parallel_runtime_spinach.log"
-      write(log, "x")
-
-      2.times{|i|
-        # needs sleep so that runtime loggers dont overwrite each other initially
-        write "features/good#{i}.feature", "Feature: A\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER\n    And I sleep a bit"
-      }
-      result = run_tests "features", :type => "spinach"
-      read(log).gsub(/\.\d+/,'').split("\n").should =~ [
-        "features/good0.feature:0",
-        "features/good1.feature:0"
-      ]
-    end
-
-    it "runs each feature once when there are more processes then features (issue #89)" do
-      2.times{|i|
-        write "features/good#{i}.feature", "Feature: A\n  Scenario: xxx\n    Given I print TEST_ENV_NUMBER\n"
-      }
-      result = run_tests "features", :type => "spinach", :add => '-n 3'
-      result.scan(/YOUR TEST ENV IS \d?!/).sort.should == ["YOUR TEST ENV IS !", "YOUR TEST ENV IS 2!"]
-    end
-
-    it "runs successfully without any files" do
-      results = run_tests("", :type => "spinach")
-      results.should include("2 processes for 0 features")
-      results.should include("Took")
-    end
-  end
-end