cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -5,10 +5,12 @@ module Cucumber
   module Cli
     describe ProfileLoader do
       def given_cucumber_yml_defined_as(hash_or_string)
-        Dir.stub(:glob).with('{,.config/,config/}cucumber{.yml,.yaml}').and_return(['cucumber.yml'])
-        File.stub(:exist?).and_return(true)
+        allow(Dir).to receive(:glob).with('{,.config/,config/}cucumber{.yml,.yaml}') { ['cucumber.yml'] }
+        allow(File).to receive(:exist?) { true }
+
         cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
-        IO.stub(:read).with('cucumber.yml').and_return(cucumber_yml)
+
+        allow(IO).to receive(:read).with('cucumber.yml') { cucumber_yml }
       end
 
       def loader
@@ -18,18 +20,17 @@ module Cucumber
       it "treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)" do
         given_cucumber_yml_defined_as({'default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22'})
         if(Cucumber::WINDOWS)
-          loader.args_from('default').should == ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
+          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
         else
-          loader.args_from('default').should == ['--format','pretty','featuressync_imap_mailbox.feature:16:22']
+          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22']
         end
-
       end
 
       it "treats forward slashes as literals" do
         given_cucumber_yml_defined_as({'default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22'})
-        loader.args_from('default').should == ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
-      end
 
+        expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
+      end
     end
   end
 end

data/spec/cucumber/configuration_spec.rb

@@ -6,8 +6,8 @@ module Cucumber
       subject { Configuration.default }
 
       it "has an autoload_code_paths containing the standard support and step_definitions folders" do
-        subject.autoload_code_paths.should include('features/support')
-        subject.autoload_code_paths.should include('features/step_definitions')
+        expect(subject.autoload_code_paths).to include('features/support')
+        expect(subject.autoload_code_paths).to include('features/step_definitions')
       end
     end
 
@@ -16,7 +16,7 @@ module Cucumber
       subject { Configuration.new(user_options) }
 
       it "allows you to override the defaults" do
-        subject.autoload_code_paths.should == ['foo/bar/baz']
+        expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
       end
     end
   end

data/spec/cucumber/constantize_spec.rb

@@ -8,7 +8,8 @@ module Cucumber
 
     it "loads html formatter" do
       clazz = constantize('Cucumber::Formatter::Html')
-      clazz.name.should == 'Cucumber::Formatter::Html'
+
+      expect(clazz.name).to eq 'Cucumber::Formatter::Html'
     end
 
     it "fails to load a made up class" do

data/spec/cucumber/core_ext/proc_spec.rb

@@ -3,78 +3,67 @@ require 'spec_helper'
 require 'cucumber/core_ext/proc'
 
 describe Proc do
-  it "should remove extraneous path info for file" do
+  it "removes extraneous path info for file" do
     proc = lambda {|a,b|}
-    proc.file_colon_line.should =~ /^spec\/cucumber\/core_ext\/proc_spec\.rb:7/
-  end
 
-  unless Cucumber::RUBY_1_8_7
-    it "should work with non-English path" do
-      proc = lambda {|a,b|}
-      def proc.to_s
-        "#<Proc:0x00000003c04740@#{Dir.pwd}/å/spec/cucumber/core_ext/proc_spec.rb:12 (lambda)>".force_encoding('ASCII-8BIT')
-      end
+    expect(proc.file_colon_line).to match /^spec\/cucumber\/core_ext\/proc_spec\.rb:7/
+  end
 
-      proc.file_colon_line.force_encoding('UTF-8').should =~ /^å\/spec\/cucumber\/core_ext\/proc_spec\.rb:12/
+  it "works with non-English path" do
+    proc = lambda {|a,b|}
+    def proc.to_s
+      "#<Proc:0x00000003c04740@#{Dir.pwd}/å/spec/cucumber/core_ext/proc_spec.rb:12 (lambda)>".force_encoding('ASCII-8BIT')
     end
+
+    expect(proc.file_colon_line.force_encoding('UTF-8')).to match /^å\/spec\/cucumber\/core_ext\/proc_spec\.rb:12/
   end
 
-  it "should raise ArityMismatchError for too many args (expecting 0)" do
-    lambda {
+  it "raises ArityMismatchError for too many args (expecting 0)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, 'foo', 1) do
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
   end
 
-  it "should raise ArityMismatchError for too many args (expecting 1)" do
-    lambda {
+  it "raises ArityMismatchError for too many args (expecting 1)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
+    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
   end
 
-  it "should raise ArityMismatchError for too few args (expecting 1)" do
-    lambda {
+  it "raises ArityMismatchError for too few args (expecting 1)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, 'foo') do |a|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
+    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
   end
 
-  it "should raise ArityMismatchError for too few args (expecting 2)" do
-    lambda {
+  it "raises ArityMismatchError for too few args (expecting 2)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
+    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
   end
 
-  if Cucumber::RUBY_1_8_7
-    # Ruby 1.8
-    it "should not allow varargs 0+ because Ruby 1.8 reports same arity as with no args, so we can't really tell the difference." do
-      lambda {
-        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
-        end
-      }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
-    end
-  else
-    it "should allow varargs (expecting 0+)" do
-      lambda {
-        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
-        end
-      }.should_not raise_error
-    end
+  it "allows varargs (expecting 0+)" do
+    expect(-> {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+      end
+    }).not_to raise_error
   end
 
-  it "should allow varargs (expecting 1+)" do
-    lambda {
+  it "allows varargs (expecting 1+)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, 'foo', 1) do |arg,*args|
       end
-    }.should_not raise_error
+    }).not_to raise_error
   end
 
-  it "should raise ArityMismatchError for too few required args when using varargs (expecting 1+)" do
-    lambda {
+  it "raises ArityMismatchError for too few required args when using varargs (expecting 1+)" do
+    expect(-> {
       Object.new.cucumber_instance_exec(true, nil) do |arg,*args|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1+ arguments, but the Regexp matched 0 arguments.")
+    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1+ arguments, but the Regexp matched 0 arguments.")
   end
 end

data/spec/cucumber/file_specs_spec.rb

@@ -0,0 +1,41 @@
+require 'cucumber/file_specs'
+
+module Cucumber
+  describe FileSpecs do
+    let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
+    let(:locations) { file_specs.locations }
+
+    it "parses locations from multiple files" do
+      expect(locations.length).to eq 6
+      expect(locations).to eq [
+        Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
+        Cucumber::Core::Ast::Location.new("features/foo.feature", 2),
+        Cucumber::Core::Ast::Location.new("features/foo.feature", 3),
+        Cucumber::Core::Ast::Location.new("features/bar.feature", 4),
+        Cucumber::Core::Ast::Location.new("features/bar.feature", 5),
+        Cucumber::Core::Ast::Location.new("features/bar.feature", 6),
+      ]
+    end
+
+    it "parses file names from multiple file specs" do
+      files = file_specs.files
+
+      expect(files.length).to eq 2
+      expect(files).to eq [
+        "features/foo.feature",
+        "features/bar.feature",
+      ]
+    end
+
+    context "when no line number is specified" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature", "features/bar.feature:34"]) }
+
+      it "returns a wildcard location for that file" do
+        expect(locations).to eq [
+          Cucumber::Core::Ast::Location.new("features/foo.feature"),
+          Cucumber::Core::Ast::Location.new("features/bar.feature", 34),
+        ]
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -6,25 +6,26 @@ module Cucumber
     describe ANSIColor do
       include ANSIColor
 
-      it "should wrap passed_param with bold green and reset to green" do
-        passed_param("foo").should == "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
+      it "wraps passed_param with bold green and reset to green" do
+        expect(passed_param("foo")).to eq "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
       end
 
-      it "should wrap passed in green" do
-        passed("foo").should == "\e[32mfoo\e[0m"
+      it "wraps passed in green" do
+        expect(passed("foo")).to eq "\e[32mfoo\e[0m"
       end
 
-      it "should not reset passed if there are no arguments" do
-        passed.should == "\e[32m"
+      it "does not reset passed if there are no arguments" do
+        expect(passed).to eq "\e[32m"
       end
 
-      it "should wrap comments in grey" do
-        comment("foo").should == "\e[90mfoo\e[0m"
+      it "wraps comments in grey" do
+        expect(comment("foo")).to eq "\e[90mfoo\e[0m"
       end
 
-      it "should not generate ansi codes when colors are disabled" do
+      it "does not generate ansi codes when colors are disabled" do
         ::Cucumber::Term::ANSIColor.coloring = false
-        passed("foo").should == "foo"
+
+        expect(passed("foo")).to eq "foo"
       end
     end
   end

data/spec/cucumber/formatter/debug_spec.rb

@@ -0,0 +1,569 @@
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
+require 'cucumber/formatter/debug'
+require 'cucumber/cli/options'
+
+module Cucumber
+  module Formatter
+    describe Debug do
+      extend SpecHelperDsl
+      include SpecHelper
+
+        before(:each) do
+          Cucumber::Term::ANSIColor.coloring = false
+          @out = StringIO.new
+          @formatter = Debug.new(runtime, @out, {})
+        end
+
+        describe "given a single feature" do
+          before(:each) { run_defined_feature }
+
+          describe "with a scenario" do
+            define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: Monkey eats banana
+              Given there are bananas
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a scenario with multiple steps" do
+            define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario:
+              Given there are bananas
+              And there are berries
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with 2 scenarios" do
+            define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: Monkey eats banana
+              Given there are bananas
+
+            Scenario: Monkey is hungry
+              Given there are no bananas
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a background" do
+            define_feature <<-FEATURE
+          Feature:
+
+            Background:
+              Given there is a tree
+
+            Scenario:
+              Given there are bananas
+            FEATURE
+
+            it "outputs the events as expected" do
+              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_background
+      background_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_background
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a scenario outline" do
+            define_feature <<-FEATURE
+          Feature: Fud Pyramid
+
+            Scenario Outline: Monkey eats a balanced diet
+              Given there are <Things>
+
+              Examples: Fruit
+               | Things  |
+               | apples  |
+               | bananas |
+              Examples: Vegetables
+               | Things   |
+               | broccoli |
+               | carrots  |
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+          after_step_result
+        after_step
+      after_steps
+      before_examples_array
+        before_examples
+          examples_name
+          before_outline_table
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+          after_outline_table
+        after_examples
+        before_examples
+          examples_name
+          before_outline_table
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+          after_outline_table
+        after_examples
+      after_examples_array
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+              end
+            end
+
+          describe "with a scenario outline with a pystring" do
+            define_feature <<-FEATURE
+          Feature:
+            Scenario Outline: Monkey eats a balanced diet
+              Given a multiline string:
+                """
+                Monkeys eat <things>
+                """
+
+              Examples:
+               | things |
+               | apples |
+            FEATURE
+
+            it "outputs the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              doc_string
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+      before_examples_array
+        before_examples
+          examples_name
+          before_outline_table
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+            before_table_row
+              before_table_cell
+                table_cell_value
+              after_table_cell
+            after_table_row
+          after_outline_table
+        after_examples
+      after_examples_array
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a step with a py string" do
+            define_feature <<-FEATURE
+          Feature: Traveling circus
+
+            Scenario: Monkey goes to town
+              Given there is a monkey called:
+               """
+               foo
+               """
+            FEATURE
+
+            it "displays the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              doc_string
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a multiline step arg" do
+            define_feature <<-FEATURE
+          Feature: Traveling circus
+
+            Scenario: Monkey goes to town
+              Given there are monkeys:
+               | name |
+               | foo  |
+               | bar  |
+            FEATURE
+
+            it "displays the events as expected" do
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a table in the background and the scenario" do
+            define_feature <<-FEATURE
+          Feature: accountant monkey
+
+            Background:
+              Given table:
+                | a | b |
+                | c | d |
+            Scenario:
+              Given another table:
+               | e | f |
+               | g | h |
+            FEATURE
+
+            it "displays the table for the background" do
+              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_background
+      background_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_background
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+              before_table_row
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+                before_table_cell
+                  table_cell_value
+                after_table_cell
+              after_table_row
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+
+          describe "with a py string in the background and the scenario" do
+            define_feature <<-FEATURE
+          Feature: py strings
+
+            Background:
+              Given stuff:
+                """
+                foo
+                """
+            Scenario:
+              Given more stuff:
+                """
+                bar
+                """
+            FEATURE
+
+            it "displays the background py string" do
+              pending("legacy cucumber fires extra step events") if ENV['USE_LEGACY']
+              expect(@out.string).to eq(<<EXPECTED)
+before_features
+  before_feature
+    before_tags
+    after_tags
+    feature_name
+    before_background
+      background_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              doc_string
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_background
+    before_feature_element
+      before_tags
+      after_tags
+      scenario_name
+      before_steps
+        before_step
+          before_step_result
+            step_name
+            before_multiline_arg
+              doc_string
+            after_multiline_arg
+          after_step_result
+        after_step
+      after_steps
+    after_feature_element
+  after_feature
+after_features
+EXPECTED
+            end
+          end
+        end
+    end
+  end
+end