cucumber 1.3.10 → 2.0.0

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'cucumber/ast'
-require 'cucumber/step_mother'
 require 'cucumber/rb_support/rb_language'
 
 module Cucumber
@@ -9,115 +7,163 @@ module Cucumber
       let(:user_interface) { double('user interface') }
       let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
       let(:rb)             { support_code.load_programming_language('rb') }
+      let(:scenario)       { double('scenario', iso_code: 'en').as_null_object }
       let(:dsl) do
         rb
         Object.new.extend(Cucumber::RbSupport::RbDsl)
       end
 
       before do
-        rb.before(double('scenario').as_null_object)
+        rb.begin_scenario(scenario)
         $inside = nil
       end
 
       def run_step(text)
-        support_code.step_match(text).invoke(nil)
+        step_match(text).invoke(MultilineArgument::None.new)
       end
 
-      it "should allow calling of other steps" do
-        dsl.Given /Outside/ do
+      def step_match(text)
+        support_code.step_match(text)
+      end
+
+      it "allows calling of other steps" do
+        dsl.Given(/Outside/) do
           step "Inside"
         end
-        dsl.Given /Inside/ do
+        dsl.Given(/Inside/) do
           $inside = true
         end
 
         run_step "Outside"
-        $inside.should == true
+
+        expect($inside).to be true
       end
 
-      it "should allow calling of other steps with inline arg" do
-        dsl.Given /Outside/ do
-          step "Inside", Cucumber::Ast::Table.new([['inside']])
+      it "allows calling of other steps with inline arg" do
+        dsl.Given(/Outside/) do
+          location = Core::Ast::Location.new(__FILE__, __LINE__)
+          step "Inside", table([['inside']])
         end
-        dsl.Given /Inside/ do |table|
-          $inside = table.raw[0][0]
+        dsl.Given(/Inside/) do |t|
+          $inside = t.raw[0][0]
         end
 
         run_step "Outside"
-        $inside.should == 'inside'
+
+        expect($inside).to eq 'inside'
       end
 
       context "mapping to world methods" do
-        it "should call a method on the world when specified with a symbol" do
-          rb.current_world.should_receive(:with_symbol)
-          dsl.Given /With symbol/, :with_symbol
+        it "calls a method on the world when specified with a symbol" do
+          expect(rb.current_world).to receive(:with_symbol)
+
+          dsl.Given(/With symbol/, :with_symbol)
 
           run_step "With symbol"
         end
 
-        it "should call a method on a specified object" do
+        it "calls a method on a specified object" do
           target = double('target')
-          rb.current_world.stub(:target => target)
-          dsl.Given /With symbol on block/, :with_symbol, :on => lambda { target }
 
-          target.should_receive(:with_symbol)
+          allow(rb.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on block/, :with_symbol, :on => lambda { target })
+
+          expect(target).to receive(:with_symbol)
+
           run_step "With symbol on block"
         end
 
-        it "should call a method on a specified world attribute" do
+        it "calls a method on a specified world attribute" do
           target = double('target')
-          rb.current_world.stub(:target => target)
-          dsl.Given /With symbol on symbol/, :with_symbol, :on => :target
 
-          target.should_receive(:with_symbol)
+          allow(rb.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on symbol/, :with_symbol, :on => :target)
+
+          expect(target).to receive(:with_symbol)
+
           run_step "With symbol on symbol"
         end
+
+        it "has the correct location" do
+          dsl.Given /With symbol/, :with_symbol
+          expect(step_match("With symbol").file_colon_line).to eq "spec/cucumber/rb_support/rb_step_definition_spec.rb:#{__LINE__-1}"
+        end
       end
 
-      it "should raise Undefined when inside step is not defined" do
-        dsl.Given /Outside/ do
+      it "raises UndefinedDynamicStep when inside step is not defined" do
+        dsl.Given(/Outside/) do
           step 'Inside'
         end
 
-        lambda { run_step "Outside" }.
-          should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it "raises UndefinedDynamicStep when an undefined step is parsed dynamically" do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+          }
+        end
+
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
       end
 
-      it "should allow forced pending" do
-        dsl.Given /Outside/ do
+      it "allows forced pending" do
+        dsl.Given(/Outside/) do
           pending("Do me!")
         end
 
-        lambda { run_step "Outside" }.
-          should raise_error(Cucumber::Pending, "Do me!")
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::Pending, "Do me!")
+      end
+
+      it "raises ArityMismatchError when the number of capture groups differs from the number of step arguments" do
+        dsl.Given(/No group: \w+/) do |arg|
+        end
+
+        expect(-> {
+          run_step "No group: arg"
+        }).to raise_error(Cucumber::ArityMismatchError)
       end
 
-      it "should raise ArityMismatchError when the number of capture groups differs from the number of step arguments" do
-        dsl.Given /No group: \w+/ do |arg|
+      it "does not modify the step_match arg when arg is modified in a step" do
+        dsl.Given(/My car is (.*)/) do |colour|
+          colour << "xxx"
         end
 
-        lambda { run_step "No group: arg" }.
-          should raise_error(Cucumber::ArityMismatchError)
+        step_name = "My car is white"
+        step_args = step_match(step_name).args
+
+        expect(-> {
+          run_step step_name
+        }).not_to change{ step_args.first }
       end
 
-      it "should allow puts" do
-        user_interface.should_receive(:puts).with('wasup')
-        dsl.Given /Loud/ do
+      it "allows puts" do
+        expect(user_interface).to  receive(:puts).with('wasup')
+        dsl.Given(/Loud/) do
           puts 'wasup'
         end
         run_step "Loud"
       end
 
-      it "should recognize $arg style captures" do
+      it "recognizes $arg style captures" do
         arg_value = "wow!"
         dsl.Given "capture this: $arg" do |arg|
-          arg.should == arg_value
+          expect(arg).to eq arg_value
         end
         run_step "capture this: wow!"
       end
 
-      it "should have a JSON representation of the signature" do
-        RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash.should == {'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i'}
+      it "has a JSON representation of the signature" do
+        expect(RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash).to eq({ 'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i' })
       end
     end
   end

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -7,17 +7,38 @@ module Cucumber
       def transform(regexp)
         RbTransform.new(nil, regexp, lambda { |a| })
       end
+
       describe "#to_s" do
+        it "does not touch positive lookahead captures" do
+          expect(transform(/^xy(?=z)/).to_s).to eq "xy(?=z)"
+        end
+
+        it "does not touch negative lookahead captures" do
+          expect(transform(/^xy(?!z)/).to_s).to eq "xy(?!z)"
+        end
+
+        it "does not touch positive lookbehind captures" do
+          expect(transform(/^xy(?<=z)/).to_s).to eq "xy(?<=z)"
+        end
+
+        it "does not touch negative lookbehind captures" do
+          expect(transform(/^xy(?<!z)/).to_s).to eq "xy(?<!z)"
+        end
+
+        it "converts named captures" do
+          expect(transform(/^(?<str>xyz)/).to_s).to eq "(?:<str>xyz)"
+        end
+
         it "converts captures groups to non-capture groups" do
-          transform(/(a|b)bc/).to_s.should == "(?:a|b)bc"
+          expect(transform(/(a|b)bc/).to_s).to eq "(?:a|b)bc"
         end
 
         it "leaves non capture groups alone" do
-          transform(/(?:a|b)bc/).to_s.should == "(?:a|b)bc"
+          expect(transform(/(?:a|b)bc/).to_s).to eq "(?:a|b)bc"
         end
 
         it "strips away anchors" do
-          transform(/^xyz$/).to_s.should == "xyz"
+          expect(transform(/^xyz$/).to_s).to eq "xyz"
         end
       end
     end

data/spec/cucumber/rb_support/regexp_argument_matcher_spec.rb

@@ -6,14 +6,16 @@ module Cucumber
     describe RegexpArgumentMatcher do
       include RSpec::WorkInProgress
 
-      it "should create 2 arguments" do
+      it "creates 2 arguments" do
         arguments = RegexpArgumentMatcher.arguments_from(/I (\w+) (\w+)/, "I like fish")
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [["like", 2], ["fish", 7]]
+
+        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [["like", 2], ["fish", 7]]
       end
 
-      it "should create 2 arguments when first group is optional" do
+      it "creates 2 arguments when first group is optional" do
         arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [[nil, nil], ["Login failed.", 21]]
+
+        expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ["Login failed.", 21]]
       end
     end
   end

data/spec/cucumber/rb_support/snippet_spec.rb

@@ -4,16 +4,15 @@ require 'cucumber/rb_support/snippet'
 module Cucumber
   module RbSupport
     describe Snippet do
-
       let(:code_keyword) { "Given" }
 
       before do
         @pattern = 'we have a missing step'
-        @multiline_argument_class = nil
+        @multiline_argument = Core::Ast::EmptyMultilineArgument.new
       end
 
       let(:snippet) do
-        snippet_class.new(code_keyword, @pattern, @multiline_argument_class)
+        snippet_class.new(code_keyword, @pattern, @multiline_argument)
       end
 
       def unindented(s)
@@ -24,76 +23,87 @@ module Cucumber
         let(:snippet_class) { Snippet::Regexp }
         let(:snippet_text) { snippet.to_s }
 
-        it "should wrap snippet patterns in parentheses" do
+        it "wraps snippet patterns in parentheses" do
           @pattern = 'A "string" with 4 spaces'
 
-          snippet_text.should == unindented(%{
-          Given(/^A "(.*?)" with (\\d+) spaces$/) do |arg1, arg2|
-            pending # express the regexp above with the code you wish you had
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise numbers in name and make according regexp" do
+        it "recognises numbers in name and make according regexp" do
           @pattern = 'Cloud 9 yeah'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^Cloud (\\d+) yeah$/) do |arg1|
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise a mix of ints, strings and why not a table too" do
+        it "recognises a mix of ints, strings and why not a table too" do
           @pattern = 'I have 9 "awesome" cukes in 37 "boxes"'
-          @multiline_argument_class = Cucumber::Ast::Table
+          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
-          snippet_text.should == unindented(%{
-          Given(/^I have (\\d+) "(.*?)" cukes in (\\d+) "(.*?)"$/) do |arg1, arg2, arg3, arg4, table|
-            # table is a Cucumber::Ast::Table
-            pending # express the regexp above with the code you wish you had
+          expect(snippet_text).to eq unindented(%{
+          Given(/^I have (\\d+) "([^"]*)" cukes in (\\d+) "([^"]*)"$/) do |arg1, arg2, arg3, arg4, table|
+            # table is a Cucumber::Core::Ast::DataTable
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise quotes in name and make according regexp" do
+        it "recognises quotes in name and make according regexp" do
           @pattern = 'A "first" arg'
 
-          snippet_text.should == unindented(%{
-          Given(/^A "(.*?)" arg$/) do |arg1|
-            pending # express the regexp above with the code you wish you had
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "([^"]*)" arg$/) do |arg1|
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should recognise several quoted words in name and make according regexp and args" do
+        it "recognises several quoted words in name and make according regexp and args" do
           @pattern = 'A "first" and "second" arg'
 
-          snippet_text.should == unindented(%{
-          Given(/^A "(.*?)" and "(.*?)" arg$/) do |arg1, arg2|
-            pending # express the regexp above with the code you wish you had
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should not use quote group when there are no quotes" do
+        it "does not use quote group when there are no quotes" do
           @pattern = 'A first arg'
 
-          snippet_text.should == unindented(%{
+          expect(snippet_text).to eq unindented(%{
           Given(/^A first arg$/) do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
+          end
+          })
+        end
+
+        it "is helpful with tables" do
+          @pattern = 'A "first" arg'
+          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
+
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "([^"]*)" arg$/) do |arg1, table|
+            # table is a Cucumber::Core::Ast::DataTable
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
 
-        it "should be helpful with tables" do
+        it "is helpful with doc string" do
           @pattern = 'A "first" arg'
-          @multiline_argument_class = Cucumber::Ast::Table
+          @multiline_argument = MultilineArgument.from("", Core::Ast::Location.new(""))
 
-          snippet_text.should == unindented(%{
-          Given(/^A "(.*?)" arg$/) do |arg1, table|
-            # table is a Cucumber::Ast::Table
-            pending # express the regexp above with the code you wish you had
+          expect(snippet_text).to eq unindented(%{
+          Given(/^A "([^"]*)" arg$/) do |arg1, string|
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
@@ -103,9 +113,9 @@ module Cucumber
         let(:snippet_class) { Snippet::Classic }
 
         it "renders snippet as unwrapped regular expression" do
-          snippet.to_s.should eql unindented(%{
+          expect(snippet.to_s).to eq unindented(%{
           Given /^we have a missing step$/ do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
@@ -115,14 +125,13 @@ module Cucumber
         let(:snippet_class) { Snippet::Percent }
 
         it "renders snippet as percent-style regular expression" do
-          snippet.to_s.should eql unindented(%{
+          expect(snippet.to_s).to eq unindented(%{
           Given %r{^we have a missing step$} do
-            pending # express the regexp above with the code you wish you had
+            pending # Write code here that turns the phrase above into concrete actions
           end
           })
         end
       end
-
     end
   end
 end

data/spec/cucumber/running_test_case_spec.rb

@@ -0,0 +1,83 @@
+require 'cucumber/running_test_case'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber
+  describe RunningTestCase do
+    include Core
+    include Core::Gherkin::Writer
+
+    attr_accessor :wrapped_test_case, :core_test_case
+
+    before do
+      receiver = double.as_null_object
+      allow(receiver).to receive(:test_case) { |core_test_case|
+        self.core_test_case = core_test_case
+        self.wrapped_test_case = RunningTestCase.new(core_test_case)
+      }
+      compile [gherkin_doc], receiver
+    end
+
+    context "for a regular scenario" do
+      let(:gherkin_doc) do
+        gherkin do
+          feature "feature name" do
+            scenario "scenario name" do
+              step "passing"
+            end
+          end
+        end
+      end
+
+      it "sets the scenario name correctly" do
+        expect(wrapped_test_case.name).to eq "scenario name"
+      end
+
+      it "sets the feature name correctly" do
+        expect(wrapped_test_case.feature.name).to eq "feature name"
+      end
+
+      it "exposes properties of the test_case" do
+        expect(wrapped_test_case.location).to eq core_test_case.location
+        expect(wrapped_test_case.source).to eq core_test_case.source
+        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
+      end
+    end
+
+    context "for a scenario outline" do
+      let(:gherkin_doc) do
+        gherkin do
+          feature "feature name" do
+            scenario_outline "scenario outline name" do
+              step "passing with <arg1> <arg2>"
+
+              examples "examples name" do
+                row "arg1", "arg2"
+                row "a", "b"
+              end
+            end
+          end
+        end
+      end
+
+      it "sets the test case's name correctly" do
+        expect(wrapped_test_case.name).to eq "scenario outline name, examples name (#1)"
+      end
+
+      it "sets the feature name correctly" do
+        expect(wrapped_test_case.feature.name).to eq "feature name"
+      end
+
+      it "exposes properties of the test_case" do
+        expect(wrapped_test_case.location).to eq core_test_case.location
+        expect(wrapped_test_case.source).to eq core_test_case.source
+        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
+      end
+
+      it "exposes the examples table row cell values" do
+        expect(wrapped_test_case.cell_values).to eq ["a", "b"]
+      end
+
+    end
+  end
+end

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -7,25 +7,30 @@ 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
-      str = runtime_facade.doc_string('DOC')
-      str.should be_kind_of(Ast::DocString)
-      str.content_type.should eq('')
-    end
+    describe "#doc_string" do
+
+      it 'defaults to a blank content-type' do
+        str = runtime_facade.doc_string('DOC')
+        expect(str).to be_kind_of(MultilineArgument::DocString)
+        expect(str.content_type).to eq('')
+      end
+
+      it 'can have a content type' do
+        str = runtime_facade.doc_string('DOC','ruby')
+        expect(str.content_type).to eq('ruby')
+      end
 
-    it 'should produce 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')
     end
 
-    it 'should produce Ast::Table by #table' do
-      runtime_facade.table(%{
+    describe "#table" do
+
+      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(MultilineArgument::DataTable)
+      end
     end
-
   end
 end