cucumber 2.99.0 → 3.0.0

data/spec/cucumber/{rb_support → glue}/snippet_spec.rb

@@ -1,18 +1,24 @@
+# frozen_string_literal: true
 require 'spec_helper'
-require 'cucumber/rb_support/snippet'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/glue/snippet'
 
 module Cucumber
-  module RbSupport
+  module Glue
     describe Snippet do
-      let(:code_keyword) { "Given" }
+      let(:code_keyword) { 'Given' }
 
       before do
-        @pattern = 'we have a missing step'
+        @step_text = 'we have a missing step'
         @multiline_argument = Core::Ast::EmptyMultilineArgument.new
+        @registry = CucumberExpressions::ParameterTypeRegistry.new
+        @cucumber_expression_generator = CucumberExpressions::CucumberExpressionGenerator.new(@registry)
       end
 
       let(:snippet) do
-        snippet_class.new(code_keyword, @pattern, @multiline_argument)
+        snippet_class.new(@cucumber_expression_generator, code_keyword, @step_text, @multiline_argument)
       end
 
       def unindented(s)
@@ -23,8 +29,8 @@ module Cucumber
         let(:snippet_class) { Snippet::Regexp }
         let(:snippet_text) { snippet.to_s }
 
-        it "wraps snippet patterns in parentheses" do
-          @pattern = 'A "string" with 4 spaces'
+        it 'wraps snippet patterns in parentheses' do
+          @step_text = 'A "string" with 4 spaces'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
@@ -33,8 +39,8 @@ module Cucumber
           })
         end
 
-        it "recognises numbers in name and make according regexp" do
-          @pattern = 'Cloud 9 yeah'
+        it 'recognises numbers in name and make according regexp' do
+          @step_text = 'Cloud 9 yeah'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^Cloud (\\d+) yeah$/) do |arg1|
@@ -43,8 +49,8 @@ module Cucumber
           })
         end
 
-        it "recognises a mix of ints, strings and why not a table too" do
-          @pattern = 'I have 9 "awesome" cukes in 37 "boxes"'
+        it 'recognises a mix of ints, strings and why not a table too' do
+          @step_text = 'I have 9 "awesome" cukes in 37 "boxes"'
           @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
@@ -55,8 +61,8 @@ module Cucumber
           })
         end
 
-        it "recognises quotes in name and make according regexp" do
-          @pattern = 'A "first" arg'
+        it 'recognises quotes in name and make according regexp' do
+          @step_text = 'A "first" arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" arg$/) do |arg1|
@@ -65,8 +71,8 @@ module Cucumber
           })
         end
 
-        it "recognises several quoted words in name and make according regexp and args" do
-          @pattern = 'A "first" and "second" arg'
+        it 'recognises several quoted words in name and make according regexp and args' do
+          @step_text = 'A "first" and "second" arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
@@ -75,8 +81,8 @@ module Cucumber
           })
         end
 
-        it "does not use quote group when there are no quotes" do
-          @pattern = 'A first arg'
+        it 'does not use quote group when there are no quotes' do
+          @step_text = 'A first arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A first arg$/) do
@@ -85,9 +91,9 @@ module Cucumber
           })
         end
 
-        it "is helpful with tables" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
+        it 'is helpful with tables' do
+          @step_text = '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|
@@ -97,9 +103,9 @@ module Cucumber
           })
         end
 
-        it "is helpful with doc string" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = MultilineArgument.from("", Core::Ast::Location.new(""))
+        it 'is helpful with doc string' do
+          @step_text = 'A "first" arg'
+          @multiline_argument = MultilineArgument.from('', Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" arg$/) do |arg1, string|
@@ -112,7 +118,7 @@ module Cucumber
       describe Snippet::Classic do
         let(:snippet_class) { Snippet::Classic }
 
-        it "renders snippet as unwrapped regular expression" do
+        it 'renders snippet as unwrapped regular expression' do
           expect(snippet.to_s).to eq unindented(%{
           Given /^we have a missing step$/ do
             pending # Write code here that turns the phrase above into concrete actions
@@ -124,7 +130,7 @@ module Cucumber
       describe Snippet::Percent do
         let(:snippet_class) { Snippet::Percent }
 
-        it "renders snippet as percent-style regular expression" do
+        it 'renders snippet as percent-style regular expression' do
           expect(snippet.to_s).to eq unindented(%{
           Given %r{^we have a missing step$} do
             pending # Write code here that turns the phrase above into concrete actions
@@ -132,6 +138,37 @@ module Cucumber
           })
         end
       end
+
+      describe Snippet::CucumberExpression do
+        let(:snippet_class) { Snippet::CucumberExpression }
+
+        it 'renders snippet as cucumber expression' do
+          @step_text = 'I have 2.3 cukes in my belly'
+          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
+                                            'veg',
+                                            /(cuke|banana)s?/,
+                                            Object,
+                                            ->(s) { s },
+                                            true,
+                                            false
+          ))
+          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
+                                            'cucumis',
+                                            /(bella|cuke)s?/,
+                                            Object,
+                                            ->(s) { s },
+                                            true,
+                                            false
+          ))
+
+          expect(snippet.to_s).to eq unindented(%{
+          Given("I have {float} {cucumis} in my belly") do |float, cucumis|
+          # Given("I have {float} {veg} in my belly") do |float, veg|
+            pending # Write code here that turns the phrase above into concrete actions
+          end
+          })
+        end
+      end
     end
   end
 end

data/spec/cucumber/glue/step_definition_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'cucumber/glue/registry_and_more'
+
+module Cucumber
+  module Glue
+    describe StepDefinition do
+      let(:user_interface) { double('user interface') }
+      let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
+      let(:registry)       { support_code.registry }
+      let(:scenario)       { double('scenario', iso_code: 'en').as_null_object }
+      let(:dsl) do
+        registry
+        Object.new.extend(Cucumber::Glue::Dsl)
+      end
+
+      before do
+        registry.begin_scenario(scenario)
+        $inside = nil
+      end
+
+      def run_step(text)
+        step_match(text).invoke(MultilineArgument::None.new)
+      end
+
+      def step_match(text)
+        StepMatchSearch.new(registry.method(:step_matches), Configuration.default).call(text).first
+      end
+
+      it 'allows calling of other steps' do
+        dsl.Given(/Outside/) do
+          step 'Inside'
+        end
+        dsl.Given(/Inside/) do
+          $inside = true
+        end
+
+        run_step 'Outside'
+
+        expect($inside).to be true
+      end
+
+      it 'allows calling of other steps with inline arg' do
+        dsl.Given(/Outside/) do
+          step 'Inside', table([['inside']])
+        end
+        dsl.Given(/Inside/) do |t|
+          $inside = t.raw[0][0]
+        end
+
+        run_step 'Outside'
+
+        expect($inside).to eq 'inside'
+      end
+
+      context 'mapping to world methods' do
+        it 'calls a method on the world when specified with a symbol' do
+          expect(registry.current_world).to receive(:with_symbol)
+
+          dsl.Given(/With symbol/, :with_symbol)
+
+          run_step 'With symbol'
+        end
+
+        it 'calls a method on a specified object' do
+          target = double('target')
+
+          allow(registry.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 'calls a method on a specified world attribute' do
+          target = double('target')
+
+          allow(registry.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/glue/step_definition_spec.rb:#{__LINE__-1}"
+        end
+      end
+
+      it 'raises UndefinedDynamicStep when inside step is not defined' do
+        dsl.Given(/Outside/) do
+          step 'Inside'
+        end
+
+        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 'raises UndefinedDynamicStep when an undefined step with doc string is parsed dynamically' do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+            """
+            abc
+            """
+          }
+        end
+
+        expect(-> {
+          run_step 'Outside'
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it 'raises UndefinedDynamicStep when an undefined step with data table is parsed dynamically' do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+             | a |
+             | 1 |
+          }
+        end
+
+        expect(-> {
+          run_step 'Outside'
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it 'allows forced pending' do
+        dsl.Given(/Outside/) do
+          pending('Do me!')
+        end
+
+        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::Glue::ArityMismatchError)
+      end
+
+      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
+
+        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 'allows puts' do
+        expect(user_interface).to receive(:puts).with('wasup')
+        dsl.Given(/Loud/) do
+          puts 'wasup'
+        end
+        run_step 'Loud'
+      end
+
+      it 'recognizes $arg style captures' do
+        arg_value = 'up'
+        dsl.Given 'capture this: {word}' do |arg|
+          expect(arg).to eq arg_value
+        end
+        run_step 'capture this: up'
+      end
+
+      it 'has a JSON representation of the signature' do
+        expect(StepDefinition.new(registry, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash).to eq({
+          source: {
+            type: 'regular expression',
+            expression: 'I CAN HAZ (\\d+) CUKES'
+          },
+          regexp: {
+            source: 'I CAN HAZ (\\d+) CUKES', flags: 'i'
+          }
+        })
+      end
+    end
+  end
+end

data/spec/cucumber/hooks_spec.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
 require 'cucumber/hooks'
 module Cucumber::Hooks
   shared_examples_for 'a source node' do
-    it "responds to name" do
-      expect( subject.name ).to be_a(String)
+    it 'responds to text' do
+      expect( subject.text ).to be_a(String)
     end
 
-    it "responds to location" do
+    it 'responds to location' do
       expect( subject.location ).to eq(location)
     end
 
-    it "responds to match_locations?" do
+    it 'responds to match_locations?' do
       expect( subject.match_locations? [location] ).to be_truthy
       expect( subject.match_locations? [] ).to be_falsey
     end