cucumber 1.3.10 → 2.0.0

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,27 @@ 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']
+
+        expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
       end
 
+      it "treats percent sign as ERB code block after YAML directive" do
+        yml = <<-HERE
+---
+% x = '--format "pretty" features/sync_imap_mailbox.feature:16:22'
+default: <%= x %>
+        HERE
+        given_cucumber_yml_defined_as yml
+        expect(loader.args_from('default')).to eq ['--format','pretty','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/instance_exec_spec.rb

@@ -0,0 +1,4 @@
+require 'cucumber/core_ext/instance_exec'
+
+describe 'cucumber_instance_exec' do
+end

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,60 @@
+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 }
+    let(:files) { file_specs.files }
+
+    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
+      expect(files.length).to eq 2
+      expect(files).to eq [
+        "features/foo.feature",
+        "features/bar.feature",
+      ]
+    end
+
+    context "when files are not unique" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
+
+      it "parses unique file names" do
+        expect(files.length).to eq 1
+        expect(files).to eq ["features/foo.feature"]
+      end
+    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
+
+    context "when the same file is referenced more than once" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature:10", "features/foo.feature:1"]) }
+
+      it "returns locations in the order specified" do
+        expect(locations).to eq [
+          Cucumber::Core::Ast::Location.new("features/foo.feature", 10),
+          Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
+        ]
+      end
+    end
+  end
+end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -0,0 +1,57 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+
+describe Cucumber::Filters::ActivateSteps do
+  include Cucumber::Core::Gherkin::Writer
+  include Cucumber::Core
+
+  let(:step_definitions) { double(find_match: step_match) }
+  let(:step_match) { double(activate: activated_test_step) }
+  let(:activated_test_step) { double }
+  let(:receiver) { double.as_null_object }
+
+  context "a scenario with a single step" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'a passing step'
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+  context "a scenario outline" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario_outline do
+            step 'a <status> step'
+
+            examples do
+              row 'status'
+              row 'passing'
+            end
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+end

data/spec/cucumber/filters/gated_receiver_spec.rb

@@ -0,0 +1,47 @@
+require "cucumber/filters/gated_receiver"
+
+describe Cucumber::Filters::GatedReceiver do
+  subject(:gated_receiver) { Cucumber::Filters::GatedReceiver.new(receiver) }
+
+  let(:receiver) { double(:receiver) }
+  let(:test_cases){ [double(:test_case), double(:test_case)] }
+
+  describe "#test_case" do
+    it "does not immediately describe the test case to the receiver" do
+      test_cases.each do |test_case|
+        expect(test_case).to_not receive(:describe_to).with(receiver)
+      end
+
+      test_cases.each do |test_case|
+        gated_receiver.test_case(test_case)
+      end
+    end
+  end
+
+  describe "#done" do
+    before do
+      test_cases.each do |test_case|
+        gated_receiver.test_case(test_case)
+      end
+
+      test_cases.each do |test_case|
+        allow(test_case).to receive(:describe_to).with(receiver)
+      end
+
+      allow(receiver).to receive(:done)
+    end
+
+    it "describes all test cases to the receiver" do
+      test_cases.each do |test_case|
+        expect(test_case).to receive(:describe_to).with(receiver)
+      end
+
+      gated_receiver.done
+    end
+
+    it "calls done on the receiver" do
+      expect(receiver).to receive(:done)
+      gated_receiver.done
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits/test_case_index_spec.rb

@@ -0,0 +1,38 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits::TestCaseIndex do
+  subject(:index) { Cucumber::Filters::TagLimits::TestCaseIndex.new }
+
+  let(:test_cases) do
+    [
+      double(:test_case, tags: [tag_one], location: a_location_of_tag_one),
+      double(:test_case, tags: [tag_one, tag_two], location: a_location_of_tag_one_and_tag_two)
+    ]
+  end
+
+  let(:tag_one) { double(:tag_one, name: "@one") }
+  let(:tag_two) { double(:tag_two, name: "@two") }
+
+  let(:a_location_of_tag_one) { double(:a_location_of_tag_one) }
+  let(:a_location_of_tag_one_and_tag_two) { double(:a_location_of_tag_one_and_tag_two) }
+
+  before do
+    test_cases.map do |test_case|
+      index.add(test_case)
+    end
+  end
+
+  describe "#count_by_tag_name" do
+    it "returns the number of test cases with the tag" do
+      expect(index.count_by_tag_name("@one")).to eq(2)
+      expect(index.count_by_tag_name("@two")).to eq(1)
+    end
+  end
+
+  describe "#locations_by_tag_name" do
+    it "returns the locations of test cases with the tag" do
+      expect(index.locations_of_tag_name("@one")).to eq([a_location_of_tag_one, a_location_of_tag_one_and_tag_two])
+      expect(index.locations_of_tag_name("@two")).to eq([a_location_of_tag_one_and_tag_two])
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits/verifier_spec.rb

@@ -0,0 +1,57 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits::Verifier do
+  describe "#verify!" do
+    subject(:verifier) { Cucumber::Filters::TagLimits::Verifier.new(tag_limits) }
+    let(:test_case_index) { double(:test_case_index) }
+
+    context "the tag counts exceed the tag limits" do
+      let(:tag_limits) do
+        {
+          "@exceed_me" => 1
+        }
+      end
+
+      let(:locations) do
+        [
+          double(:location, to_s: "path/to/some.feature:3"),
+          double(:location, to_s: "path/to/some/other.feature:8"),
+        ]
+      end
+
+      before do
+        allow(test_case_index).to receive(:count_by_tag_name).with("@exceed_me") { 2 }
+        allow(test_case_index).to receive(:locations_of_tag_name).with("@exceed_me") { locations }
+      end
+
+      it "raises a TagLimitExceeded error with the locations of the tags" do
+        expect {
+          verifier.verify!(test_case_index)
+        }.to raise_error(
+          Cucumber::Filters::TagLimitExceededError,
+          "@exceed_me occurred 2 times, but the limit was set to 1\n" +
+          "  path/to/some.feature:3\n" +
+          "  path/to/some/other.feature:8"
+        )
+      end
+    end
+
+    context "the tag counts do not exceed the tag limits" do
+      let(:tag_limits) do
+        {
+          "@dont_exceed_me" => 2
+        }
+      end
+
+      before do
+        allow(test_case_index).to receive(:count_by_tag_name).with("@dont_exceed_me") { 1 }
+      end
+
+      it "does not raise an error" do
+        expect {
+          verifier.verify!(test_case_index)
+        }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits_spec.rb

@@ -0,0 +1,59 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits do
+  subject(:filter) { Cucumber::Filters::TagLimits.new(tag_limits, receiver) }
+
+  let(:tag_limits) { double(:tag_limits) }
+  let(:receiver) { double(:receiver) }
+
+  let(:gated_receiver) { double(:gated_receiver) }
+  let(:test_case_index) { double(:test_case_index) }
+  let(:test_case) { double(:test_case) }
+
+  before do
+    allow(Cucumber::Filters::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
+    allow(Cucumber::Filters::TagLimits::TestCaseIndex).to receive(:new) { test_case_index }
+  end
+
+  describe "#test_case" do
+    before do
+      allow(test_case_index).to receive(:add)
+      allow(gated_receiver).to receive(:test_case)
+    end
+
+    it "indexes the test case" do
+      expect(test_case_index).to receive(:add).with(test_case)
+      filter.test_case(test_case)
+    end
+
+    it "adds the test case to the gated receiver" do
+      expect(gated_receiver).to receive(:test_case).with(test_case)
+      filter.test_case(test_case)
+    end
+  end
+
+  describe "#done" do
+    let(:verifier) { double(:verifier) }
+
+    before do
+      allow(Cucumber::Filters::TagLimits::Verifier).to receive(:new).with(tag_limits) { verifier }
+      allow(gated_receiver).to receive(:done)
+    end
+
+    it "verifies tag limits have not been exceeded" do
+      expect(verifier).to receive(:verify!).with(test_case_index)
+      filter.done
+    end
+
+    context "the verifier verifies successfully" do
+      before do
+        allow(verifier).to receive(:verify!).with(test_case_index)
+      end
+
+      it "calls done on the receiver gate" do
+        expect(gated_receiver).to receive(:done)
+        filter.done
+      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,64 @@
+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_test_case
+before_features
+before_feature
+before_tags
+after_tags
+feature_name
+before_test_step
+after_test_step
+before_test_step
+before_feature_element
+before_tags
+after_tags
+scenario_name
+before_steps
+before_step
+before_step_result
+step_name
+after_step_result
+after_step
+after_test_step
+after_steps
+after_feature_element
+after_test_case
+after_feature
+after_features
+done
+EXPECTED
+            end
+          end
+        end
+    end
+
+  end
+end

data/spec/cucumber/formatter/duration_spec.rb

@@ -6,16 +6,16 @@ module Cucumber
     describe Duration do
       include Duration
 
-      it "should format ms" do
-        format_duration(0.002103).should == '0m0.002s'
+      it "formats ms" do
+        expect(format_duration(0.002103)).to eq '0m0.002s'
       end
 
-      it "should format m" do
-        format_duration(61.002503).should == '1m1.003s'
+      it "formats m" do
+        expect(format_duration(61.002503)).to eq'1m1.003s'
       end
 
-      it "should format h" do
-        format_duration(3661.002503).should == '61m1.003s'
+      it "formats h" do
+        expect(format_duration(3661.002503)).to eq '61m1.003s'
       end
     end
   end