cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -7,25 +7,26 @@ module Cucumber
     subject               { Runtime::SupportCode.new(user_interface,{}) }
     let(:runtime_facade)  { Runtime::ForProgrammingLanguages.new(subject, user_interface) }
 
-    it 'should produce Ast::DocString by #doc_string with default content-type' do
+    it 'produces Ast::DocString by #doc_string with default content-type' do
       str = runtime_facade.doc_string('DOC')
-      str.should be_kind_of(Ast::DocString)
-      str.content_type.should eq('')
+
+      expect(str).to be_kind_of(Core::Ast::DocString)
+      expect(str.content_type).to eq('')
     end
 
-    it 'should produce Ast::DocString by #doc_string with ruby content-type' do
+    it 'produces Ast::DocString by #doc_string with ruby content-type' do
       str = runtime_facade.doc_string('DOC','ruby')
-      str.should be_kind_of(Ast::DocString)
-      str.content_type.should eq('ruby')
+
+      expect(str).to be_kind_of(Core::Ast::DocString)
+      expect(str.content_type).to eq('ruby')
     end
 
-    it 'should produce Ast::Table by #table' do
-      runtime_facade.table(%{
+    it 'produces Ast::Table by #table' do
+      expect(runtime_facade.table(%{
       | account | description | amount |
       | INT-100 | Taxi        | 114    |
       | CUC-101 | Peeler      | 22     |
-      }).should be_kind_of(Ast::Table)
+      })).to be_kind_of(Core::Ast::DataTable)
     end
-
   end
 end

data/spec/cucumber/runtime/gated_receiver_spec.rb

@@ -0,0 +1,47 @@
+require "cucumber/runtime/gated_receiver"
+
+describe Cucumber::Runtime::GatedReceiver do
+  subject(:gated_receiver) { Cucumber::Runtime::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/runtime/results_spec.rb

@@ -3,77 +3,84 @@ require 'spec_helper'
 module Cucumber
   describe Runtime::Results do
 
-    let(:configuration) {double 'Configuration', :strict? => false}
+    let(:configuration)   {double 'Configuration', :strict? => false}
     let(:passed_scenario) {double 'Scenario', :status => :passed}
     let(:failed_scenario) {double 'Scenario', :status => :failed}
-    let(:passed_step) {double 'Step', :status => :passed}
-    let(:failed_step) {double 'Step', :status => :failed}
-    let(:pending_step) {double 'Step', :status => :pending}
-    let(:undefined_step) {double 'Step', :status => :undefined}
+    let(:passed_step)     {double 'Step', :status => :passed}
+    let(:failed_step)     {double 'Step', :status => :failed}
+    let(:pending_step)    {double 'Step', :status => :pending}
+    let(:undefined_step)  {double 'Step', :status => :undefined}
 
     subject {described_class.new(configuration)}
 
     describe '#failure?' do
       context 'feature is not work in progress' do
         before do
-          configuration.stub(:wip? => false)
+          allow(configuration).to receive(:wip?) { false }
         end
 
-        it 'should return true if a scenario failed' do
+        it 'returns true if a scenario failed' do
           subject.scenario_visited(passed_scenario)
           subject.scenario_visited(failed_scenario)
-          subject.should be_failure
+
+          expect(subject).to be_failure
         end
 
-        it 'should return true if a step failed' do
+        it 'returns true if a step failed' do
           subject.step_visited(failed_step)
-          subject.should be_failure
+
+          expect(subject).to be_failure
         end
 
-        it 'should return false if there are no scenarios' do
-          subject.should_not be_failure
+        it 'returns false if there are no scenarios' do
+          expect(subject).not_to be_failure
         end
 
-        it 'should return false if all scenarios passed' do
+        it 'returns false if all scenarios passed' do
           subject.scenario_visited(passed_scenario)
           subject.scenario_visited(passed_scenario)
-          subject.should_not be_failure
+
+          expect(subject).not_to be_failure
         end
 
         context 'configuration is strict' do
           before do
-            configuration.stub(:strict? => true)
+            allow(configuration).to receive(:strict?) { true }
           end
 
-          it 'should return true if a step is pending' do
+          it 'returns true if a step is pending' do
             subject.step_visited(pending_step)
-            subject.should be_failure
+
+            expect(subject).to be_failure
           end
 
-          it 'should return true if a step is undefined' do
+          it 'returns true if a step is undefined' do
             subject.step_visited(undefined_step)
-            subject.should be_failure
+
+            expect(subject).to be_failure
           end
         end
       end
 
       context 'feature is work in progress' do
         before do
-          configuration.stub(:wip? => true)
+          allow(configuration).to receive(:wip?) { true }
         end
 
-        it 'should return true if a scenario passed' do
+        it 'returns true if a scenario passed' do
           subject.scenario_visited(passed_scenario)
-          subject.should be_failure
+
+          expect(subject).to be_failure
         end
 
-        it 'should return false if there are no scenarios' do
-          subject.should_not be_failure
+        it 'returns false if there are no scenarios' do
+          expect(subject).not_to be_failure
         end
 
-        it 'should return false if all scenarios fail' do
+        it 'returns false if all scenarios fail' do
           subject.scenario_visited(failed_scenario)
-          subject.should_not be_failure
+
+          expect(subject).not_to be_failure
         end
       end
     end

data/spec/cucumber/runtime/support_code_spec.rb

@@ -4,34 +4,35 @@ module Cucumber
   describe Runtime::SupportCode do
     let(:user_interface) { double('user interface') }
     subject { Runtime::SupportCode.new(user_interface, options) }
-    let(:options)     { {} }
+    let(:options) { {} }
     let(:dsl) do
       @rb = subject.load_programming_language('rb')
       Object.new.extend(RbSupport::RbDsl)
     end
 
-    it "should format step names" do
+    it "formats step names" do
       dsl.Given(/it (.*) in (.*)/) { |what, month| }
       dsl.Given(/nope something else/) { |what, month| }
 
       format = subject.step_match("it snows in april").format_args("[%s]")
-      format.should == "it [snows] in [april]"
+
+      expect(format).to eq "it [snows] in [april]"
     end
 
-    it "should cache step match results" do
+    it "caches step match results" do
       dsl.Given(/it (.*) in (.*)/) { |what, month| }
 
       step_match = subject.step_match("it snows in april")
 
-      @rb.should_not_receive :step_matches
+      expect(@rb).not_to receive(:step_matches)
       second_step_match = subject.step_match("it snows in april")
 
-      step_match.should equal(second_step_match)
+      expect(step_match).to equal(second_step_match)
     end
 
     describe "resolving step defintion matches" do
 
-      it "should raise Ambiguous error with guess hint when multiple step definitions match" do
+      it "raises Ambiguous error with guess hint when multiple step definitions match" do
         expected_error = %{Ambiguous match of "Three blind mice":
 
 spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
@@ -42,15 +43,15 @@ You can run again with --guess to make Cucumber be more smart about it
         dsl.Given(/Three (.*) mice/) {|disability|}
         dsl.Given(/Three blind (.*)/) {|animal|}
 
-        lambda do
+        expect(-> {
           subject.step_match("Three blind mice")
-        end.should raise_error(Ambiguous, /#{expected_error}/)
+        }).to raise_error(Ambiguous, /#{expected_error}/)
       end
 
       describe "when --guess is used" do
         let(:options) { {:guess => true} }
 
-        it "should not show --guess hint" do
+        it "does not show --guess hint" do
         expected_error = %{Ambiguous match of "Three cute mice":
 
 spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three (.*) mice/'
@@ -60,64 +61,63 @@ spec/cucumber/runtime/support_code_spec.rb:\\d+:in `/Three cute (.*)/'
           dsl.Given(/Three (.*) mice/) {|disability|}
           dsl.Given(/Three cute (.*)/) {|animal|}
 
-          lambda do
+          expect(-> {
             subject.step_match("Three cute mice")
-          end.should raise_error(Ambiguous, /#{expected_error}/)
+          }).to raise_error(Ambiguous, /#{expected_error}/)
         end
 
-        it "should not raise Ambiguous error when multiple step definitions match" do
+        it "does not raise Ambiguous error when multiple step definitions match" do
           dsl.Given(/Three (.*) mice/) {|disability|}
           dsl.Given(/Three (.*)/) {|animal|}
 
-          lambda do
+          expect(-> {
             subject.step_match("Three blind mice")
-          end.should_not raise_error
+          }).not_to raise_error
         end
 
-        it "should not raise NoMethodError when guessing from multiple step definitions with nil fields" do
+        it "does not raise NoMethodError when guessing from multiple step definitions with nil fields" do
           dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
           dsl.Given(/Three (.*)?/) {|animal|}
 
-          lambda do
+          expect(-> {
             subject.step_match("Three blind mice")
-          end.should_not raise_error
+          }).not_to raise_error
         end
 
-        it "should pick right step definition when an equal number of capture groups" do
+        it "picks right step definition when an equal number of capture groups" do
           right = dsl.Given(/Three (.*) mice/) {|disability|}
           wrong = dsl.Given(/Three (.*)/) {|animal|}
 
-          subject.step_match("Three blind mice").step_definition.should == right
+          expect(subject.step_match("Three blind mice").step_definition).to eq right
         end
 
-        it "should pick right step definition when an unequal number of capture groups" do
+        it "picks right step definition when an unequal number of capture groups" do
           right = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
           wrong = dsl.Given(/Three (.*)/) {|animal|}
 
-          subject.step_match("Three blind mice ran far").step_definition.should == right
+          expect(subject.step_match("Three blind mice ran far").step_definition).to eq right
         end
 
-        it "should pick most specific step definition when an unequal number of capture groups" do
+        it "picks most specific step definition when an unequal number of capture groups" do
           general       = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
           specific      = dsl.Given(/Three blind mice ran far/) do; end
           more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
 
-          subject.step_match("Three blind mice ran far").step_definition.should == more_specific
+          expect(subject.step_match("Three blind mice ran far").step_definition).to eq more_specific
         end
       end
 
-      it "should raise Undefined error when no step definitions match" do
-        lambda do
+      it "raises Undefined error when no step definitions match" do
+        expect(-> {
           subject.step_match("Three blind mice")
-        end.should raise_error(Undefined)
+        }).to raise_error(Undefined)
       end
 
       # http://railsforum.com/viewtopic.php?pid=93881
-      it "should not raise Redundant unless it's really redundant" do
+      it "does not raise Redundant unless it's really redundant" do
         dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
         dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
       end
     end
-
   end
 end

data/spec/cucumber/runtime/tag_limits/filter_spec.rb

@@ -0,0 +1,59 @@
+require "cucumber/runtime/tag_limits"
+
+describe Cucumber::Runtime::TagLimits::Filter do
+  subject(:filter) { Cucumber::Runtime::TagLimits::Filter.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::Runtime::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
+    allow(Cucumber::Runtime::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::Runtime::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/runtime/tag_limits/test_case_index_spec.rb

@@ -0,0 +1,38 @@
+require "cucumber/runtime/tag_limits"
+
+describe Cucumber::Runtime::TagLimits::TestCaseIndex do
+  subject(:index) { Cucumber::Runtime::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/runtime/tag_limits/verifier_spec.rb

@@ -0,0 +1,57 @@
+require "cucumber/runtime/tag_limits"
+
+describe Cucumber::Runtime::TagLimits::Verifier do
+  describe "#verify!" do
+    subject(:verifier) { Cucumber::Runtime::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::Runtime::TagLimits::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