friendlyfashion-parallel_tests 0.9.0

data/spec/parallel_tests/cli_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'parallel_tests/cli'
+
+describe ParallelTest::CLI do
+  describe ".parse_options" do
+    let(:defaults){ {:files => []} }
+
+    def call(*args)
+      ParallelTest::CLI.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
+  end
+
+  describe ".final_fail_message" do
+    it 'returns a plain fail message if colors are nor supported' do
+      ParallelTest::CLI.should_receive(:use_colors?).and_return false
+      ParallelTest::CLI.send(:final_fail_message, "Test").should ==  "Tests Failed"
+    end
+
+    it 'returns a colorized fail message if colors are supported' do
+      ParallelTest::CLI.should_receive(:use_colors?).and_return true
+      ParallelTest::CLI.send(:final_fail_message, "Test").should == "\e[31mTests Failed\e[0m"
+    end
+  end
+end

data/spec/parallel_tests/cucumber/gherkin_listener_spec.rb

@@ -0,0 +1,48 @@
+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
+  end
+end

data/spec/parallel_tests/cucumber/runner_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+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
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      call(['xxx'],0,{})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      $stdout.stub!(:print)
+      ParallelTests::Cucumber::Runner.should_receive(:open).and_return io
+      call(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+
+    it "runs bundle exec cucumber when on bundler 0.9" do
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "runs script/cucumber when script/cucumber is found" do
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "runs cucumber by default" do
+      File.stub!(:file?).with('script/cucumber').and_return false
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x !~ %r{(script/cucumber)|(bundle exec cucumber)}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses options passed in" do
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p default}}.and_return mocked_process
+      call(['xxx'],1,:test_options => '-p default')
+    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
+        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* foo bar --profile parallel xxx}}.and_return mocked_process
+        call(['xxx'],1, :test_options => 'foo bar')
+      end
+
+      it "uses given profile via --profile" do
+        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* --profile foo xxx$}}.and_return mocked_process
+        call(['xxx'],1, :test_options => '--profile foo')
+      end
+
+      it "uses given profile via -p" do
+        ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* -p foo xxx$}}.and_return mocked_process
+        call(['xxx'],1, :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'
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .* foo bar}}.and_return mocked_process
+      Dir.should_receive(:glob).and_return ['config/cucumber.yml']
+      File.should_receive(:read).with('config/cucumber.yml').and_return file_contents
+      call(['xxx'],1,:test_options => 'foo bar')
+    end
+
+    it "does not use the parallel profile if config/cucumber.yml does not exist" do
+      ParallelTests::Cucumber::Runner.should_receive(:open).with{|x,y| x =~ %r{script/cucumber .*}}.and_return mocked_process
+      Dir.should_receive(:glob).and_return []
+      call(['xxx'],1,{})
+    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

data/spec/parallel_tests/grouper_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'parallel_tests/grouper'
+require 'tmpdir'
+
+describe ParallelTests::Grouper do
+  describe :by_steps do
+    def write(file, content)
+      File.open(file,'w'){|f| f.write content }
+    end
+
+    it "sorts features by steps" do
+      tmpdir = nil
+      result = Dir.mktmpdir do |dir|
+        tmpdir = dir
+        write("#{dir}/a.feature", "Feature: xxx\n  Scenario: xxx\n    Given something")
+        write("#{dir}/b.feature", "Feature: xxx\n  Scenario: xxx\n    Given something\n  Scenario: yyy\n    Given something")
+        write("#{dir}/c.feature", "Feature: xxx\n  Scenario: xxx\n    Given something")
+        ParallelTests::Grouper.by_steps(["#{dir}/a.feature", "#{dir}/b.feature", "#{dir}/c.feature"],2)
+      end
+
+      # testing inside mktmpdir is always green
+      result.should =~ [
+        ["#{tmpdir}/a.feature", "#{tmpdir}/c.feature"],
+        ["#{tmpdir}/b.feature"]
+      ]
+    end
+  end
+
+  describe :in_even_groups_by_size do
+    let(:files_with_size){ {"1" => 1, "2" => 2, "3" => 3, "4" => 4, "5" => 5} }
+
+    def call(num_groups)
+      ParallelTests::Grouper.in_even_groups_by_size(files_with_size, num_groups)
+    end
+
+    it "groups 1 by 1 for same groups as size" do
+      call(5).should == [["5"], ["4"], ["3"], ["2"], ["1"]]
+    end
+
+    it "groups into even groups" do
+      call(2).should ==  [["1", "2", "5"], ["3", "4"]]
+    end
+
+    it "groups into a single group" do
+      call(1).should == [["1", "2", "3", "4", "5"]]
+    end
+
+    it "adds empty groups if there are more groups than feature files" do
+      call(6).should == [["5"], ["4"], ["3"], ["2"], ["1"], []]
+    end
+  end
+end

data/spec/parallel_tests/rspec/failure_logger_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe ParallelTests::RSpec::FailuresLogger do
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  before do
+    @output     = OutputLogger.new([])
+    @example1   = mock( 'example', :location => "#{Dir.pwd}/spec/path/to/example:123", :full_description => 'should do stuff', :description => 'd' )
+    @example2   = mock( 'example', :location => "#{Dir.pwd}/spec/path/to/example2:456", :full_description => 'should do other stuff', :description => 'd')
+    @exception1 = mock( :to_s => 'exception', :backtrace => [ '/path/to/error/line:33' ] )
+    @failure1   = mock( 'example', :location => "#{Dir.pwd}/example:123", :header => 'header', :exception => @exception1 )
+    @logger = ParallelTests::RSpec::FailuresLogger.new(@output)
+  end
+
+  after do
+    silence_warnings{ ParallelTests::RSpec::LoggerBase::RSPEC_1 = false }
+  end
+
+  def clean_output
+    @output.output.join("\n").gsub(/\e\[\d+m/,'')
+  end
+
+  it "should produce a list of command lines for failing examples" do
+    @logger.example_failed @example1
+    @logger.example_failed @example2
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^rspec .*? should do stuff/
+    clean_output.should =~ /^rspec .*? should do other stuff/
+  end
+
+  it "should invoke spec for rspec 1" do
+    silence_warnings{ ParallelTests::RSpec::LoggerBase::RSPEC_1 = true }
+    ParallelTests.stub!(:bundler_enabled?).and_return true
+    ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+    @logger.example_failed @example1
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^bundle exec spec/
+  end
+
+  it "should invoke rspec for rspec 2" do
+    ParallelTests.stub!(:bundler_enabled?).and_return true
+    ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+    @logger.example_failed @example1
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ /^rspec/
+  end
+
+  it "should return relative paths" do
+    @logger.example_failed @example1
+    @logger.example_failed @example2
+
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+
+    clean_output.should =~ %r(\./spec/path/to/example:123)
+    clean_output.should =~ %r(\./spec/path/to/example2:456)
+  end
+
+
+  # should not longer be a problem since its using native rspec methods
+  xit "should not log examples without location" do
+    example = mock('example', :location => 'bla', :full_description => 'before :all')
+    @logger.example_failed example
+    @logger.dump_failures
+    @logger.dump_summary(1,2,3,4)
+    clean_output.should == ''
+  end
+end

data/spec/parallel_tests/rspec/runner_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe ParallelTests::RSpec::Runner do
+  test_tests_in_groups(ParallelTests::RSpec::Runner, 'spec', '_spec.rb')
+
+  describe :run_tests do
+    before do
+      File.stub!(:file?).with('script/spec').and_return false
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      File.stub!(:file?).with('spec/parallel_spec.opts').and_return false
+      File.stub!(:file?).with('.rspec_parallel').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return false
+    end
+
+    def call(*args)
+      ParallelTests::RSpec::Runner.run_tests(*args)
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      call(['xxx'], 0, {})
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "runs with color when called from cmdline" do
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/ --tty /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      call(['xxx'],1,{})
+    end
+
+    it "runs without color when not called from cmdline" do
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ / --tty /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      call(['xxx'],1,{})
+    end
+
+    it "runs with color for rspec 1 when called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x=~/ RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      call(['xxx'],1,{})
+    end
+
+    it "runs without color for rspec 1 when not called for the cmdline" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ / RSPEC_COLOR=1 /}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      call(['xxx'],1,{})
+    end
+
+    it "run bundle exec spec when on bundler rspec 1" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "run bundle exec rspec when on bundler rspec 2" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{bundle exec rspec}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "runs script/spec when script/spec can be found" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "runs spec when script/spec cannot be found" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ %r{script/spec}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses no -O when no opts where found" do
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x !~ %r{spec/spec.opts}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses -O spec/spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.stub!(:file?).with('spec/spec.opts').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/spec.opts}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses -O .rspec_parallel when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('.rspec_parallel').and_return true
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+ -O .rspec_parallel}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec1" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec2" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      ParallelTests::RSpec::Runner.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.4.2"
+
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --color --tty -O spec/parallel_spec.opts}}.and_return mocked_process
+      call(['xxx'],1,{})
+    end
+
+    it "uses options passed in" do
+      ParallelTests::RSpec::Runner.should_receive(:open).with{|x,y| x =~ %r{rspec -f n}}.and_return mocked_process
+      call(['xxx'],1, :test_options => '-f n')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      $stdout.stub!(:print)
+      ParallelTests::RSpec::Runner.should_receive(:open).and_return io
+      call(['xxx'],1,{})[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :find_results do
+    def call(*args)
+      ParallelTests::RSpec::Runner.find_results(*args)
+    end
+
+    it "finds multiple results in spec output" do
+      output = "
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 examples, 0 failures, 0 pending
+ff.**..
+1 example, 1 failure, 1 pending
+"
+
+      call(output).should == ['0 examples, 0 failures, 0 pending','1 example, 1 failure, 1 pending']
+    end
+
+    it "is robust against scrambeled output" do
+      output = "
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 exFampl*es, 0 failures, 0 pend.ing
+ff.**..
+1 exampF.les, 1 failures, 1 pend.ing
+"
+
+      call(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
+    end
+  end
+end