cucumber-cucumber-expressions 8.3.1

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -0,0 +1,57 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpression do
+      context "Regexp translation" do
+        def assert_regexp(expression, regexp)
+          cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
+          expect(regexp).to eq(cucumber_expression.regexp)
+        end
+
+        it "translates no arguments" do
+          assert_regexp(
+            "I have 10 cukes in my belly now",
+            /^I have 10 cukes in my belly now$/
+          )
+        end
+
+        it "translates alternation" do
+          assert_regexp(
+            "I had/have a great/nice/charming friend",
+            /^I (?:had|have) a (?:great|nice|charming) friend$/
+          )
+        end
+
+        it "translates alternation with non-alpha" do
+          assert_regexp(
+            "I said Alpha1/Beta1",
+            /^I said (?:Alpha1|Beta1)$/
+          )
+        end
+
+        it "translates parameters" do
+          assert_regexp(
+            "I have {float} cukes at {int} o'clock",
+            /^I have ((?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?) cukes at ((?:-?\d+)|(?:\d+)) o'clock$/
+          )
+        end
+
+        it "translates parenthesis to non-capturing optional capture group" do
+          assert_regexp(
+            "I have many big(ish) cukes",
+            /^I have many big(?:ish)? cukes$/
+          )
+        end
+
+        it "translates parenthesis with alpha unicode" do
+          assert_regexp(
+            "Привет, Мир(ы)!",
+            /^Привет, Мир(?:ы)?!$/
+          )
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -0,0 +1,212 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpression do
+      it "documents match arguments" do
+        parameter_registry = ParameterTypeRegistry.new
+
+        ### [capture-match-arguments]
+        expr = "I have {int} cuke(s)"
+        expression = CucumberExpression.new(expr, parameter_registry)
+        args = expression.match("I have 7 cukes")
+        expect(args[0].value(nil)).to eq(7)
+        ### [capture-match-arguments]
+      end
+
+      it "matches word" do
+        expect(match("three {word} mice", "three blind mice")).to eq(['blind'])
+      end
+
+      it('matches double quoted string') do
+        expect(match('three {string} mice', 'three "blind" mice')).to eq(['blind'])
+      end
+
+      it('matches multiple double quoted strings') do
+        expect(match('three {string} and {string} mice', 'three "blind" and "crippled" mice')).to eq(['blind', 'crippled'])
+      end
+
+      it('matches single quoted string') do
+        expect(match('three {string} mice', "three 'blind' mice")).to eq(['blind'])
+      end
+
+      it('matches multiple single quoted strings') do
+        expect(match('three {string} and {string} mice', "three 'blind' and 'crippled' mice")).to eq(['blind', 'crippled'])
+      end
+
+      it('does not match misquoted string') do
+        expect(match('three {string} mice', 'three "blind\' mice')).to eq(nil)
+      end
+
+      it('matches single quoted string with double quotes') do
+        expect(match('three {string} mice', 'three \'"blind"\' mice')).to eq(['"blind"'])
+      end
+
+      it('matches double quoted string with single quotes') do
+        expect(match('three {string} mice', 'three "\'blind\'" mice')).to eq(["'blind'"])
+      end
+
+      it('matches double quoted string with escaped double quote') do
+        expect(match('three {string} mice', 'three "bl\\"nd" mice')).to eq(['bl"nd'])
+      end
+
+      it('matches single quoted string with escaped single quote') do
+        expect(match('three {string} mice', "three 'bl\\'nd' mice")).to eq(["bl'nd"])
+      end
+
+      it('matches single quoted empty string as empty string') do
+        expect(match('three {string} mice', "three '' mice")).to eq([''])
+      end
+
+      it('matches double quoted empty string as empty string') do
+        expect(match('three {string} mice', 'three "" mice')).to eq([''])
+      end
+
+      it('matches single quoted empty string as empty string, along with other strings') do
+        expect(match('three {string} and {string} mice', "three '' and 'handsome' mice")).to eq(['', 'handsome'])
+      end
+
+      it('matches double quoted empty string as empty string, along with other strings') do
+        expect(match('three {string} and {string} mice', 'three "" and "handsome" mice')).to eq(['', 'handsome'])
+      end
+
+      it 'matches escaped parentheses' do
+        expect(match('three \\(exceptionally) {string} mice', 'three (exceptionally) "blind" mice')).to eq(['blind'])
+      end
+
+      it "matches escaped slash" do
+        expect(match("12\\/2020", "12/2020")).to eq([])
+      end
+
+      it "matches int" do
+        expect(match("{int}", "22")).to eq([22])
+      end
+
+      it "doesn't match float as int" do
+        expect(match("{int}", "1.22")).to be_nil
+      end
+
+      it "matches int as float" do
+        expect(match("{float}", "0")).to eq([0.0])
+      end
+
+      it "matches float" do
+        expect(match("{float}", "")).to eq(nil)
+        expect(match("{float}", ".")).to eq(nil)
+        expect(match("{float}", ",")).to eq(nil)
+        expect(match("{float}", "-")).to eq(nil)
+        expect(match("{float}", "E")).to eq(nil)
+        expect(match("{float}", "1,")).to eq(nil)
+        expect(match("{float}", ",1")).to eq(nil)
+        expect(match("{float}", "1.")).to eq(nil)
+
+        expect(match("{float}", "1")).to eq([1])
+        expect(match("{float}", "-1")).to eq([-1])
+        expect(match("{float}", "1.1")).to eq([1.1])
+        expect(match("{float}", "1,000")).to eq(nil)
+        expect(match("{float}", "1,000,0")).to eq(nil)
+        expect(match("{float}", "1,000.1")).to eq(nil)
+        expect(match("{float}", "1,000,10")).to eq(nil)
+        expect(match("{float}", "1,0.1")).to eq(nil)
+        expect(match("{float}", "1,000,000.1")).to eq(nil)
+        expect(match("{float}", "-1.1")).to eq([-1.1])
+
+        expect(match("{float}", ".1")).to eq([0.1])
+        expect(match("{float}", "-.1")).to eq([-0.1])
+        expect(match("{float}", "-.1000001")).to eq([-0.1000001])
+        expect(match("{float}", "1E1")).to eq([10.0])
+        expect(match("{float}", ".1E1")).to eq([1])
+        expect(match("{float}", "E1")).to eq(nil)
+        expect(match("{float}", "-.1E-1")).to eq([-0.01])
+        expect(match("{float}", "-.1E-2")).to eq([-0.001])
+        expect(match("{float}", "-.1E+1")).to eq([-1])
+        expect(match("{float}", "-.1E+2")).to eq([-10])
+        expect(match("{float}", "-.1E1")).to eq([-1])
+        expect(match("{float}", "-.1E2")).to eq([-10])
+      end
+
+      it "matches anonymous" do
+        expect(match("{}", "0.22")).to eq(["0.22"])
+      end
+
+      '[]()$.|?*+'.split('').each do |char|
+        it "does not allow parameter type with #{char}" do
+          expect {match("{#{char}string}", "something")}.to raise_error("Illegal character '#{char}' in parameter name {#{char}string}")
+        end
+      end
+
+      it "throws unknown parameter type" do
+        expect {match("{unknown}", "something")}.to raise_error('Undefined parameter type {unknown}')
+      end
+
+      it "does not allow optional parameter types" do
+        expect {match("({int})", "3")}.to raise_error('Parameter types cannot be optional: ({int})')
+      end
+
+      it "does allow escaped optional parameter types" do
+        expect(match("\\({int})", "(3)")).to eq([3])
+      end
+
+      it "does not allow text/parameter type alternation" do
+        expect {match("x/{int}", "3")}.to raise_error('Parameter types cannot be alternative: x/{int}')
+      end
+
+      it "does not allow parameter type/text alternation" do
+        expect {match("{int}/x", "3")}.to raise_error('Parameter types cannot be alternative: {int}/x')
+      end
+
+      it "exposes source" do
+        expr = "I have {int} cuke(s)"
+        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
+      end
+
+      it "delegates transform to custom object" do
+        parameter_type_registry = ParameterTypeRegistry.new
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+                  'widget',
+                  /\w+/,
+                  Object,
+                  -> (s) {
+                    self.create_widget(s)
+                  },
+                  false,
+                  true
+              )
+        )
+        expression = CucumberExpression.new(
+          'I have a {widget}',
+          parameter_type_registry
+        )
+
+        class World
+          def create_widget(s)
+            "widget:#{s}"
+          end
+        end
+
+        args = expression.match("I have a bolt")
+        expect(args[0].value(World.new)).to eq('widget:bolt')
+      end
+
+      describe "escapes special characters" do
+        %w(\\ [ ] ^ $ . | ? * +).each do |character|
+          it "escapes #{character}" do
+            expr = "I have {int} cuke(s) and #{character}"
+            expression = CucumberExpression.new(expr, ParameterTypeRegistry.new)
+            arg1 = expression.match("I have 800 cukes and #{character}")[0]
+            expect(arg1.value(nil)).to eq(800)
+          end
+        end
+      end
+
+      def match(expression, text)
+        cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
+        args = cucumber_expression.match(text)
+        return nil if args.nil?
+        args.map {|arg| arg.value(nil)}
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -0,0 +1,202 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    class Color
+      attr_reader :name
+
+      ### [color-constructor]
+      def initialize(name)
+        @name = name
+      end
+
+      ### [color-constructor]
+
+      def ==(other)
+        other.is_a?(Color) && other.name == name
+      end
+    end
+
+    class CssColor
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(CssColor) && other.name == name
+      end
+    end
+
+    class Coordinate
+      attr_reader :x, :y, :z
+
+      def initialize(x, y, z)
+        @x, @y, @z = x, y, z
+      end
+
+      def ==(other)
+        other.is_a?(Coordinate) && other.x == x && other.y == y && other.z == z
+      end
+    end
+
+    describe "Custom parameter type" do
+      before do
+        parameter_type_registry = ParameterTypeRegistry.new
+        ### [add-color-parameter-type]
+        parameter_type_registry.define_parameter_type(ParameterType.new(
+            'color',                   # name
+            /red|blue|yellow/,         # regexp
+            Color,                     # type
+            lambda {|s| Color.new(s)}, # transform
+            true,                      # use_for_snippets
+            false                      # prefer_for_regexp_match
+        ))
+        ### [add-color-parameter-type]
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      it "throws exception for illegal character in parameter name" do
+        expect do
+          ParameterType.new(
+              '[string]',
+              /.*/,
+              String,
+              lambda {|s| s},
+              true,
+              false
+          )
+        end.to raise_error("Illegal character '[' in parameter name {[string]}")
+      end
+
+      describe CucumberExpression do
+        it "matches parameters with custom parameter type" do
+          expression = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
+          transformed_argument_value = expression.match("I have a red ball")[0].value(nil)
+          expect(transformed_argument_value).to eq(Color.new('red'))
+        end
+
+        it "matches parameters with multiple capture groups" do
+          @parameter_type_registry.define_parameter_type(ParameterType.new(
+              'coordinate',
+              /(\d+),\s*(\d+),\s*(\d+)/,
+              Coordinate,
+              lambda {|x, y, z| Coordinate.new(x.to_i, y.to_i, z.to_i)},
+              true,
+              false
+          ))
+
+          expression = CucumberExpression.new(
+              'A {int} thick line from {coordinate} to {coordinate}',
+              @parameter_type_registry
+          )
+          args = expression.match('A 5 thick line from 10,20,30 to 40,50,60')
+
+          thick = args[0].value(nil)
+          expect(thick).to eq(5)
+
+          from = args[1].value(nil)
+          expect(from).to eq(Coordinate.new(10, 20, 30))
+
+          to = args[2].value(nil)
+          expect(to).to eq(Coordinate.new(40, 50, 60))
+        end
+
+        it "matches parameters with custom parameter type using optional capture group" do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(ParameterType.new(
+              'color',
+              [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
+              Color,
+              lambda {|s| Color.new(s)},
+              true,
+              false
+          ))
+          expression = CucumberExpression.new("I have a {color} ball", parameter_type_registry)
+          transformed_argument_value = expression.match("I have a dark red ball")[0].value(nil)
+          expect(transformed_argument_value).to eq(Color.new('dark red'))
+        end
+
+        it "defers transformation until queried from argument" do
+          @parameter_type_registry.define_parameter_type(ParameterType.new(
+              'throwing',
+              /bad/,
+              CssColor,
+              lambda {|s| raise "Can't transform [#{s}]"},
+              true,
+              false
+          ))
+          expression = CucumberExpression.new("I have a {throwing} parameter", @parameter_type_registry)
+          args = expression.match("I have a bad parameter")
+          expect {args[0].value(nil)}.to raise_error("Can't transform [bad]")
+        end
+
+        describe "conflicting parameter type" do
+          it "is detected for type name" do
+            expect {
+              @parameter_type_registry.define_parameter_type(ParameterType.new(
+                  'color',
+                  /.*/,
+                  CssColor,
+                  lambda {|s| CssColor.new(s)},
+                  true,
+                  false
+              ))
+            }.to raise_error("There is already a parameter with name color")
+          end
+
+          it "is not detected for type" do
+            @parameter_type_registry.define_parameter_type(ParameterType.new(
+                'whatever',
+                /.*/,
+                Color,
+                lambda {|s| Color.new(s)},
+                false,
+                false
+            ))
+          end
+
+          it "is not detected for regexp" do
+            @parameter_type_registry.define_parameter_type(ParameterType.new(
+                'css-color',
+                /red|blue|yellow/,
+                CssColor,
+                lambda {|s| CssColor.new(s)},
+                true,
+                false
+            ))
+
+            css_color = CucumberExpression.new("I have a {css-color} ball", @parameter_type_registry)
+            css_color_value = css_color.match("I have a blue ball")[0].value(nil)
+            expect(css_color_value).to eq(CssColor.new("blue"))
+
+            color = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
+            color_value = color.match("I have a blue ball")[0].value(nil)
+            expect(color_value).to eq(Color.new("blue"))
+          end
+        end
+      end
+
+      describe RegularExpression do
+        it "matches arguments with custom parameter type without name" do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(ParameterType.new(
+              nil,
+              /red|blue|yellow/,
+              Color,
+              lambda {|s| Color.new(s)},
+              true,
+              false
+          ))
+
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
+          value = expression.match("I have a red ball")[0].value(nil)
+          expect(value).to eq(Color.new('red'))
+        end
+      end
+    end
+  end
+end