parallel_tests 0.13.3 → 0.14.0

data/lib/parallel_tests/test/runtime_logger.rb

@@ -6,73 +6,77 @@ module ParallelTests
     class RuntimeLogger
       @@has_started = false
 
-      def self.log(test, start_time, end_time)
-        return if test.is_a? ::Test::Unit::TestSuite # don't log for suites-of-suites
+      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
+          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))
+          locked_appending_to(logfile) do |file|
+            file.puts(message(test, start_time, end_time))
+          end
         end
-      end
 
-      def self.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
+        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 self.class_directory(suspect)
-        result = "test/"
+        # 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/"
+          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
-        result
-      end
 
-      # based on https://github.com/grosser/single_test/blob/master/lib/single_test.rb#L117
-      def self.class_to_filename(suspect)
-        word = suspect.to_s.dup
-        return word unless word.match /^[A-Z]/ and not word.match %r{/[a-z]}
+        # 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
+          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 self.locked_appending_to(file)
-        File.open(file, 'a') do |f|
-          begin
-            f.flock File::LOCK_EX
-            yield f
-          ensure
-            f.flock File::LOCK_UN
+        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
-      end
 
-      def self.logfile
-        ParallelTests::Test::Runner.runtime_log
+        def logfile
+          ParallelTests::Test::Runner.runtime_log
+        end
       end
     end
   end

data/lib/parallel_tests/version.rb

@@ -1,3 +1,3 @@
 module ParallelTests
-  VERSION = Version = '0.13.3'
+  VERSION = Version = '0.14.0'
 end

data/parallel_tests.gemspec

@@ -3,12 +3,12 @@ name = "parallel_tests"
 require "#{name}/version"
 
 Gem::Specification.new name, ParallelTests::VERSION do |s|
-  s.summary = "Run Test::Unit / RSpec / Cucumber in parallel"
+  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_cucumber", "parallel_rspec", "parallel_test"]
+  s.executables = ["parallel_spinach", "parallel_cucumber", "parallel_rspec", "parallel_test"]
   s.add_runtime_dependency "parallel"
 end

data/spec/integration_spec.rb

@@ -132,6 +132,11 @@ describe 'CLI' do
     `#{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'"
@@ -282,4 +287,60 @@ describe 'CLI' do
       results.should include("Took")
     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

data/spec/parallel_tests/cucumber/failure_logger_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'parallel_tests/cucumber/io'
+require 'parallel_tests/gherkin/io'
 require 'parallel_tests/cucumber/failures_logger'
 
 describe ParallelTests::Cucumber::FailuresLogger do

data/spec/parallel_tests/cucumber/runner_spec.rb

@@ -1,179 +1,12 @@
 require "spec_helper"
+require "parallel_tests/gherkin/runner_behaviour"
 require "parallel_tests/cucumber/runner"
 
-describe ParallelTests::Cucumber do
+describe ParallelTests::Cucumber::Runner 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
+  it_should_behave_like 'gherkin runners' do
+    let(:runner_name) {'cucumber'}
+    let(:runner_class){ParallelTests::Cucumber::Runner}
   end
 end

data/spec/parallel_tests/{cucumber/gherkin_listener_spec.rb → gherkin/listener_spec.rb}

@@ -1,9 +1,9 @@
-require 'parallel_tests/cucumber/gherkin_listener'
+require 'parallel_tests/gherkin/listener'
 
-describe ParallelTests::Cucumber::GherkinListener do
+describe ParallelTests::Gherkin::Listener do
   describe :collect do
     before(:each) do
-      @listener = ParallelTests::Cucumber::GherkinListener.new
+      @listener = ParallelTests::Gherkin::Listener.new
       @listener.uri("feature_file")
     end
 

data/spec/parallel_tests/gherkin/runner_behaviour.rb

@@ -0,0 +1,177 @@
+require "spec_helper"
+require "parallel_tests/gherkin/runner"
+
+shared_examples_for 'gherkin runners' do
+  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/#{runner_name}").and_return true
+    end
+
+    def call(*args)
+      runner_class().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 {runner_name} when on bundler 0.9" do
+      ParallelTests.stub!(:bundler_enabled?).and_return true
+      should_run_with %r{bundle exec #{runner_name}}
+      call(['xxx'], 1, 22, {})
+    end
+
+    it "runs script/{runner_name} when script/{runner_name} is found" do
+      should_run_with %r{script/#{runner_name}}
+      call(['xxx'], 1, 22, {})
+    end
+
+    it "runs {runner_name} by default" do
+      File.stub!(:file?).with("script/#{runner_name}").and_return false
+      should_run_with %r{^#{runner_name}}
+      call(['xxx'], 1, 22, {})
+    end
+
+    it "uses bin/{runner_name} when present" do
+      File.stub(:exists?).with("bin/#{runner_name}").and_return true
+      should_run_with %r{bin/#{runner_name}}
+      call(['xxx'], 1, 22, {})
+    end
+
+    it "uses options passed in" do
+      should_run_with %r{script/#{runner_name} .* -p default}
+      call(['xxx'], 1, 22, :test_options => '-p default')
+    end
+
+    it "sanitizes dangerous file runner_names" do
+      should_run_with %r{xx\\ x}
+      call(['xx x'], 1, 22, {})
+    end
+
+    context "with parallel profile in config/{runner_name}.yml" do
+      before do
+        file_contents = 'parallel: -f progress'
+        Dir.stub(:glob).and_return ["config/#{runner_name}.yml"]
+        File.stub(:read).with("config/#{runner_name}.yml").and_return file_contents
+      end
+
+      it "uses parallel profile" do
+        should_run_with %r{script/#{runner_name} .* 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/#{runner_name} .* --profile foo xxx$}
+        call(['xxx'], 1, 22, :test_options => '--profile foo')
+      end
+
+      it "uses given profile via -p" do
+        should_run_with %r{script/#{runner_name} .* -p foo xxx$}
+        call(['xxx'], 1, 22, :test_options => '-p foo')
+      end
+    end
+
+    it "does not use parallel profile if config/{runner_name}.yml does not contain it" do
+      file_contents = 'blob: -f progress'
+      should_run_with %r{script/#{runner_name} .* foo bar}
+      Dir.should_receive(:glob).and_return ["config/#{runner_name}.yml"]
+      File.should_receive(:read).with("config/#{runner_name}.yml").and_return file_contents
+      call(['xxx'], 1, 22, :test_options => 'foo bar')
+    end
+
+    it "does not use the parallel profile if config/{runner_name}.yml does not exist" do
+      should_run_with %r{script/#{runner_name}} # 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)"
+      runner_class().line_is_result?(line).should be_true
+    end
+
+    it "should match lines with multiple scenarios" do
+      line = "2 scenarios (1 failed, 1 passed)"
+      runner_class().line_is_result?(line).should be_true
+    end
+
+    it "should match lines with only one step" do
+      line = "1 step (1 failed)"
+      runner_class().line_is_result?(line).should be_true
+    end
+
+    it "should match lines with multiple steps" do
+      line = "5 steps (1 failed, 4 passed)"
+      runner_class().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'
+      runner_class().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
+      runner_class().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)
+      runner_class().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