vinted-parallel_tests 0.13.3

data/spec/integration_spec.rb

@@ -0,0 +1,285 @@
+#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 "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
+
+  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 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
+
+  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 }
+      "
+    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
+      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
+  end
+end

data/spec/parallel_tests/cli_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+require "parallel_tests/cli"
+require "parallel_tests/rspec/runner"
+
+
+describe ParallelTests::CLI do
+  subject { ParallelTests::CLI.new }
+
+  describe "#parse_options" do
+    let(:defaults){ {:files => []} }
+
+    def call(*args)
+      subject.send(:parse_options!, *args)
+    end
+
+    it "parses regular count" do
+      call(["-n3"]).should == defaults.merge(:count => 3)
+    end
+
+    it "parses count 0 as non-parallel" do
+      call(["-n0"]).should == defaults.merge(:non_parallel => true)
+    end
+
+    it "parses non-parallel as non-parallel" do
+      call(["--non-parallel"]).should == defaults.merge(:non_parallel => true)
+    end
+
+    it "finds the correct type when multiple are given" do
+      call(["--type", "test", "-t", "rspec"])
+      subject.instance_variable_get(:@runner).should == ParallelTests::RSpec::Runner
+    end
+
+    it "parses nice as nice" do
+      call(["--nice"]).should == defaults.merge(:nice => true)
+    end
+  end
+
+  describe "#load_runner" do
+    it "requires and loads default runner" do
+      subject.should_receive(:require).with("parallel_tests/test/runner")
+      subject.send(:load_runner, "test").should == ParallelTests::Test::Runner
+    end
+
+    it "requires and loads rspec runner" do
+      subject.should_receive(:require).with("parallel_tests/rspec/runner")
+      subject.send(:load_runner, "rspec").should == ParallelTests::RSpec::Runner
+    end
+
+    it "fails to load unfindable runner" do
+      expect{
+        subject.send(:load_runner, "foo").should == ParallelTests::RSpec::Runner
+      }.to raise_error(LoadError)
+    end
+  end
+
+  describe "#final_fail_message" do
+    before do
+      subject.instance_variable_set(:@runner, ParallelTests::Test::Runner)
+    end
+
+    it 'returns a plain fail message if colors are nor supported' do
+      subject.should_receive(:use_colors?).and_return(false)
+      subject.send(:final_fail_message).should ==  "Tests Failed"
+    end
+
+    it 'returns a colorized fail message if colors are supported' do
+      subject.should_receive(:use_colors?).and_return(true)
+      subject.send(:final_fail_message).should == "\e[31mTests Failed\e[0m"
+    end
+  end
+end

data/spec/parallel_tests/cucumber/failure_logger_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'parallel_tests/cucumber/io'
+require 'parallel_tests/cucumber/failures_logger'
+
+describe ParallelTests::Cucumber::FailuresLogger do
+
+  before do
+    @output = OutputLogger.new([])
+    @output.stub(:write)
+
+    @logger1 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
+    @logger2 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
+    @logger3 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
+
+    @feature1 = mock('feature', :file => "feature/path/to/feature1.feature")
+    @feature2 = mock('feature', :file => "feature/path/to/feature2.feature")
+    @feature3 = mock('feature', :file => "feature/path/to/feature3.feature")
+
+    @logger1.instance_variable_set("@lines", [1, 2, 3])
+    @logger2.instance_variable_set("@lines", [2, 4, 6])
+    @logger3.instance_variable_set("@lines", [3, 6, 9])
+  end
+
+  it "should produce a list of lines for failing scenarios" do
+    @logger1.after_feature(@feature1)
+    @logger2.after_feature(@feature2)
+    @logger3.after_feature(@feature3)
+
+    output_file_contents = @output.output.join("\n").concat("\n")
+
+    output_file_contents.should == <<END
+feature/path/to/feature1.feature:1
+feature/path/to/feature1.feature:2
+feature/path/to/feature1.feature:3
+feature/path/to/feature2.feature:2
+feature/path/to/feature2.feature:4
+feature/path/to/feature2.feature:6
+feature/path/to/feature3.feature:3
+feature/path/to/feature3.feature:6
+feature/path/to/feature3.feature:9
+END
+  end
+end

data/spec/parallel_tests/cucumber/gherkin_listener_spec.rb

@@ -0,0 +1,97 @@
+require 'parallel_tests/cucumber/gherkin_listener'
+
+describe ParallelTests::Cucumber::GherkinListener do
+  describe :collect do
+    before(:each) do
+      @listener = ParallelTests::Cucumber::GherkinListener.new
+      @listener.uri("feature_file")
+    end
+
+    it "returns steps count" do
+      3.times {@listener.step(nil)}
+      @listener.collect.should == {"feature_file" => 3}
+    end
+
+    it "counts background steps separately" do
+      @listener.background("background")
+      5.times {@listener.step(nil)}
+      @listener.collect.should == {"feature_file" => 0}
+
+      @listener.scenario("scenario")
+      2.times {@listener.step(nil)}
+      @listener.collect.should == {"feature_file" => 2}
+
+      @listener.scenario("scenario")
+      @listener.collect.should == {"feature_file" => 2}
+
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 12}
+    end
+
+    it "counts scenario outlines steps separately" do
+      @listener.scenario_outline("outline")
+      5.times {@listener.step(nil)}
+      @listener.collect.should == {"feature_file" => 0}
+
+      @listener.scenario("scenario")
+      2.times {@listener.step(nil)}
+      @listener.collect.should == {"feature_file" => 2}
+
+      @listener.scenario("scenario")
+      @listener.collect.should == {"feature_file" => 2}
+
+      3.times {@listener.examples}
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 17}
+    end
+
+    it 'counts scenarios that should not be ignored' do
+      @listener.ignore_tag_pattern = nil
+      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
+      @listener.step(nil)
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 1}
+
+      @listener.ignore_tag_pattern = /@something_other_than_WIP/
+      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
+      @listener.step(nil)
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 2}
+    end
+
+    it 'does not count scenarios that should be ignored' do
+      @listener.ignore_tag_pattern = /@WIP/
+      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]))
+      @listener.step(nil)
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 0}
+    end
+
+    it 'counts outlines that should not be ignored' do
+      @listener.ignore_tag_pattern = nil
+      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
+      @listener.step(nil)
+      3.times {@listener.examples}
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 3}
+
+
+      @listener.ignore_tag_pattern = /@something_other_than_WIP/
+      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
+      @listener.step(nil)
+      3.times {@listener.examples}
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 6}
+    end
+
+    it 'does not count outlines that should be ignored' do
+      @listener.ignore_tag_pattern = /@WIP/
+      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
+      @listener.step(nil)
+      3.times {@listener.examples}
+      @listener.eof
+      @listener.collect.should == {"feature_file" => 0}
+    end
+
+  end
+end

data/spec/parallel_tests/cucumber/runner_spec.rb

@@ -0,0 +1,179 @@
+require "spec_helper"
+require "parallel_tests/cucumber/runner"
+
+describe ParallelTests::Cucumber do
+  test_tests_in_groups(ParallelTests::Cucumber::Runner, 'features', ".feature")
+
+  describe :run_tests do
+    before do
+      ParallelTests.stub!(:bundler_enabled?).and_return false
+      File.stub!(:file?).with('.bundle/environment.rb').and_return false
+      File.stub!(:file?).with('script/cucumber').and_return true
+    end
+
+    def call(*args)
+      ParallelTests::Cucumber::Runner.run_tests(*args)
+    end
+
+    def should_run_with(regex)
+      ParallelTests::Test::Runner.should_receive(:execute_command).with{|a,b,c,d| a =~ regex}
+    end
+
+    it "allows to override runner executable via PARALLEL_TESTS_EXECUTABLE" do
+      ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
+      should_run_with /script\/custom_rspec/
+      call(['xxx'],1,22,{})
+      ENV.delete('PARALLEL_TESTS_EXECUTABLE')
+    end
+
+    it "runs bundle exec cucumber when on bundler 0.9" do
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      should_run_with %r{bundle exec cucumber}
+      call(['xxx'],1,22,{})
+    end
+
+    it "runs script/cucumber when script/cucumber is found" do
+      should_run_with %r{script/cucumber}
+      call(['xxx'],1,22,{})
+    end
+
+    it "runs cucumber by default" do
+      File.stub!(:file?).with('script/cucumber').and_return false
+      should_run_with %r{^cucumber}
+      call(['xxx'],1,22,{})
+    end
+
+    it "uses bin/cucumber when present" do
+      File.stub(:exists?).with("bin/cucumber").and_return true
+      should_run_with %r{bin/cucumber}
+      call(['xxx'],1,22,{})
+    end
+
+    it "uses options passed in" do
+      should_run_with %r{script/cucumber .* -p default}
+      call(['xxx'],1,22,:test_options => '-p default')
+    end
+
+    it "sanitizes dangerous file names" do
+      should_run_with %r{xx\\ x}
+      call(['xx x'],1,22,{})
+    end
+
+    context "with parallel profile in config/cucumber.yml" do
+      before do
+        file_contents = 'parallel: -f progress'
+        Dir.stub(:glob).and_return ['config/cucumber.yml']
+        File.stub(:read).with('config/cucumber.yml').and_return file_contents
+      end
+
+      it "uses parallel profile" do
+        should_run_with %r{script/cucumber .* foo bar --profile parallel xxx}
+        call(['xxx'],1,22, :test_options => 'foo bar')
+      end
+
+      it "uses given profile via --profile" do
+        should_run_with %r{script/cucumber .* --profile foo xxx$}
+        call(['xxx'],1,22, :test_options => '--profile foo')
+      end
+
+      it "uses given profile via -p" do
+        should_run_with  %r{script/cucumber .* -p foo xxx$}
+        call(['xxx'],1,22, :test_options => '-p foo')
+      end
+    end
+
+    it "does not use parallel profile if config/cucumber.yml does not contain it" do
+      file_contents = 'blob: -f progress'
+      should_run_with  %r{script/cucumber .* foo bar}
+      Dir.should_receive(:glob).and_return ['config/cucumber.yml']
+      File.should_receive(:read).with('config/cucumber.yml').and_return file_contents
+      call(['xxx'],1,22,:test_options => 'foo bar')
+    end
+
+    it "does not use the parallel profile if config/cucumber.yml does not exist" do
+      should_run_with %r{script/cucumber} # TODO this test looks useless...
+      Dir.should_receive(:glob).and_return []
+      call(['xxx'],1,22,{})
+    end
+  end
+
+  describe :line_is_result? do
+    it "should match lines with only one scenario" do
+      line = "1 scenario (1 failed)"
+      ParallelTests::Cucumber::Runner.line_is_result?(line).should be_true
+    end
+
+    it "should match lines with multiple scenarios" do
+      line = "2 scenarios (1 failed, 1 passed)"
+      ParallelTests::Cucumber::Runner.line_is_result?(line).should be_true
+    end
+
+    it "should match lines with only one step" do
+      line = "1 step (1 failed)"
+      ParallelTests::Cucumber::Runner.line_is_result?(line).should be_true
+    end
+
+    it "should match lines with multiple steps" do
+      line = "5 steps (1 failed, 4 passed)"
+      ParallelTests::Cucumber::Runner.line_is_result?(line).should be_true
+    end
+
+    it "should not match other lines" do
+      line = '    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25'
+      ParallelTests::Cucumber::Runner.line_is_result?(line).should be_false
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+And I should not see "/en/"                                       # features/step_definitions/webrat_steps.rb:87
+
+7 scenarios (3 failed, 4 passed)
+33 steps (3 failed, 2 skipped, 28 passed)
+/apps/rs/features/signup.feature:2
+    Given I am on "/"                                           # features/step_definitions/common_steps.rb:12
+    When I click "register"                                     # features/step_definitions/common_steps.rb:6
+    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25
+
+4 scenarios (4 passed)
+40 steps (40 passed)
+
+And I should not see "foo"                                       # features/step_definitions/webrat_steps.rb:87
+
+1 scenario (1 passed)
+1 step (1 passed)
+
+EOF
+      ParallelTests::Cucumber::Runner.find_results(output).should == ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)", "40 steps (40 passed)", "1 scenario (1 passed)", "1 step (1 passed)"]
+    end
+  end
+
+  describe :summarize_results do
+    def call(*args)
+      ParallelTests::Cucumber::Runner.summarize_results(*args)
+    end
+
+    it "sums up results for scenarios and steps separately from each other" do
+      results = ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)",
+                 "40 steps (40 passed)", "1 scenario (1 passed)", "1 step (1 passed)"]
+      call(results).should == "12 scenarios (3 failed, 9 passed)\n74 steps (3 failed, 2 skipped, 69 passed)"
+    end
+
+    it "adds same results with plurals" do
+      results = ["1 scenario (1 passed)", "2 steps (2 passed)",
+                 "2 scenarios (2 passed)", "7 steps (7 passed)"]
+      call(results).should == "3 scenarios (3 passed)\n9 steps (9 passed)"
+    end
+
+    it "adds non-similar results" do
+      results = ["1 scenario (1 passed)", "1 step (1 passed)",
+                 "2 scenarios (1 failed, 1 pending)", "2 steps (1 failed, 1 pending)"]
+      call(results).should == "3 scenarios (1 failed, 1 pending, 1 passed)\n3 steps (1 failed, 1 pending, 1 passed)"
+    end
+
+    it "does not pluralize 1" do
+      call(["1 scenario (1 passed)", "1 step (1 passed)"]).should == "1 scenario (1 passed)\n1 step (1 passed)"
+    end
+  end
+end