alinta-cucumber-rest-bdd 0.5.14 → 0.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 354c46fe9607db986dffbed0a48e9f2758e8a77e
-  data.tar.gz: f29e45217a0bf112a9eadacba17dc6c3f0fdb4cd
+  metadata.gz: 6c1c08f37c955dfab322c7f134f644e30503a01c
+  data.tar.gz: dbd38aab4b7e14cf854eb9e95c3226bd811e0abd
 SHA512:
-  metadata.gz: dcf73bf5d3bb13ba6f313ee4a56458e1110edd97b98103f630623ec2a85214975a3779413f935512b1793aa59f8793e7a68cc43ae97c7280ef76788c4f55c4e1
-  data.tar.gz: 0cabb8f56aa36905668f02924f2d733fd597f3dc41a7c607ef832dcbbe57ba3b2132421d6a61f4b420a72be6d961abb099299a87e96a9476c4ca0d4fbedeee90
+  metadata.gz: 51fbffaf21822b8c00fe6ccc82c9b92338d143974ca842f58bf2bdcaecac181d1a0e9ed486fa2f7cee1a6e2002c8b42524135b2ac9ca14b4bb336f52e047b12b
+  data.tar.gz: 45ff06672c504df19e3acc5332fdefa49a45cda5fc81a94dea8fa2bdf1ea0b8f848459e551ec2e93c3ee1dc07c97bd1b87d4e25fd38845fb8123eb417712cfc5

data/lib/cucumber-rest-bdd/level.rb

@@ -1,7 +1,7 @@
 require 'cucumber-rest-bdd/types'
 require 'active_support/inflector'
 
-LEVELS = %{(?: (?:for|in|on) [^"]+?(?: with (?:key|id))? "[^"]+")*}%
+LEVELS = %{((?: (?:for|in|on) #{RESOURCE_NAME}(?: with (?:key|id))? "[^"]*")*)?}%
 
 class Level
     @urls = []
@@ -26,14 +26,14 @@ class Level
 
     def hash
         hash = {}
-        @urls.each{ |l| hash[get_parameter("#{get_parameter(l[:resource]).singularize}_id")] = l[:id] }
+        @urls.each{ |l| hash[get_field("#{get_field(l[:resource]).singularize}_id")] = l[:id] }
         hash
     end
 
     def last_hash
         last = @urls.last
         if !last.nil?
-            key = get_parameter("#{get_parameter(last[:resource]).singularize}_id")
+            key = get_field("#{get_field(last[:resource]).singularize}_id")
             return {
                 key => last[:id]
             }

data/lib/cucumber-rest-bdd/steps/auth.rb

@@ -20,7 +20,7 @@ Given(/^I retrieve the secret "(.*?)" from Azure Storage Vault "(.*?)" using ten
     }
     access_token = @response.get_as_type "$..access_token", "string"
     steps %Q{
-        And I request the secret "#{secret_name}" from Azure Storage Vault "#{vault_name}" using token "#{access_token}"
+        Given I retrieve the secret "#{secret_name}" from Azure Storage Vault "#{vault_name}" using access token "#{access_token}"
     }
 end
 
@@ -33,13 +33,17 @@ end
 Given(/^I authenticate with "(.*?)" using client credentials "(.*?)" and "(.*?)"$/) do |url, client_id, client_secret|
     steps %Q{
         Given I send "www-x-form-urlencoded" and accept JSON
-        When I set JSON request body to '{"grant_type": "client_credentials", "client_id": "#{client_id}", "client_secret": "#{client_secret}", "resource": "https://vault.azure.net"}'
+        When I set form request body to:
+        | grant_type    | client_credentials      |
+        | client_id     | #{client_id}            |
+        | client_secret | #{client_secret}        |
+        | resource      | https://vault.azure.net |
         And I send a POST request to "#{url}"
         Then the request was successful
     }
 end
 
-Given(/^I request the secret "(.*?)" from Azure Storage Vault "(.*?)" using token "(.*?)"$/) do |secret_name, vault_name, access_token|
+Given(/^I retrieve the secret "([^"]*)" from Azure Storage Vault "([^"]*)" using access token "([^"]*)"$/) do |secret_name, vault_name, access_token|
     api_version = '2015-06-01'
     url = "https://#{vault_name}.vault.azure.net/secrets/#{secret_name}?api-version=#{api_version}"
     steps %Q{

data/lib/cucumber-rest-bdd/steps/functional.rb

@@ -15,7 +15,7 @@ Then(/^the JSON response should have "([^"]*)" of type array with (\d+) entr(?:y
   raise %/Expected #{number} items in array for path '#{json_path}', found: #{list.count}\n#{@response.to_json_s}/ if list.count != number.to_i
 end
 
-Then(/^the JSON response should have "([^"]*)" of type array with (#{FEWER_MORE_THAN}) (\d+) entr(?:y|ies)$/) do |json_path, count_mod, number|
+Then(/^the JSON response should have "([^"]*)" of type array with ({fewer_more_than}) (\d+) entr(?:y|ies)$/) do |json_path, count_mod, number|
   list = @response.get_as_type json_path, 'array'
   raise %/Expected #{count_mod} #{number} items in array for path '#{json_path}', found: #{list.count}\n#{@response.to_json_s}/ \
 	if !num_compare(count_mod, list.count, number.to_i)

data/lib/cucumber-rest-bdd/steps/resource.rb

@@ -7,45 +7,48 @@ require 'cucumber-rest-bdd/level'
 require 'cucumber-rest-bdd/hash'
 require 'easy_diff'
 
+GET_TYPES = %{(?:an?(?! list)|the)}%
+WITH_ID = %{(?: with (?:key|id))? "([^"]*)"}%
+
 Given(/^I am a client$/) do
     steps %Q{
       Given I send "application/json" and accept JSON
     }
 end
 
-Given(/^I am issuing requests for (.+?)$/) do |resource|
+Given(/^I am issuing requests for #{RESOURCE_NAME_CAPTURE}$/) do |resource|
     @urlbasepath = get_resource(resource)
 end
 
 # GET
 
-When(/^I request (?:an?(?! list)|the) ([^"]+?)(?: with (?:key|id))? "([^"]*)"(#{LEVELS})?$/) do |resource, id, levels|
+When(/^I request #{GET_TYPES} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS}$/) do |resource, id, levels|
     resource_name = get_resource(resource)
     url = get_url("#{Level.new(levels).url}#{resource_name}/#{id}")
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-When(/^I request (?:an?(?! list)|the) (.+?)(?: with (?:key|id))? "([^"]*)"(#{LEVELS})? with:$/) do |resource, id, levels, params|
+When(/^I request #{GET_TYPES} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS} with:$/) do |resource, id, levels, params|
     resource_name = get_resource(resource)
     url = get_url("#{Level.new(levels).url}#{resource_name}/#{id}")
     unless params.raw.empty?
-        query = params.raw.map{|key, value| %/#{get_parameter(key)}=#{resolve(value)}/}.join("&")
+        query = params.raw.map{|key, value| %/#{get_field(key)}=#{resolve(value)}/}.join("&")
         url = "#{url}?#{query}"
     end
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-When(/^I request a list of ([^:]+?)(#{LEVELS})?$/) do |resource, levels|
+When(/^I request a list of #{RESOURCE_NAME_CAPTURE}#{LEVELS}$/) do |resource, levels|
     resource_name = get_resource(resource)
     url = get_url("#{Level.new(levels).url}#{resource_name}")
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-When(/^I request a list of (.+?)(#{LEVELS})? with:$/) do |resource, levels, params|
+When(/^I request a list of #{RESOURCE_NAME_CAPTURE}#{LEVELS} with:$/) do |resource, levels, params|
     resource_name = get_resource(resource)
     url = get_url("#{Level.new(levels).url}#{resource_name}")
     unless params.raw.empty?
-        query = params.raw.map{|key, value| %/#{get_parameter(key)}=#{resolve(value)}/}.join("&")
+        query = params.raw.map{|key, value| %/#{get_field(key)}=#{resolve(value)}/}.join("&")
         url = "#{url}?#{query}"
     end
     steps %Q{When I send a GET request to "#{url}"}
@@ -53,7 +56,7 @@ end
 
 # DELETE
 
-When(/^I request to (?:delete|remove) the ([^"]+?) "([^"]*)"(#{LEVELS})?$/) do |resource, id, levels|
+When(/^I request to (?:delete|remove) #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS}$/) do |resource, id, levels|
     resource_name = get_resource(resource)
     url = get_url("#{Level.new(levels).url}#{resource_name}/#{id}")
     steps %Q{When I send a DELETE request to "#{url}"}
@@ -61,7 +64,7 @@ end
 
 # POST
 
-When(/^I request to create an? ([^:]+?)(#{LEVELS})?$/) do |resource, levels|
+When(/^I request to create #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{LEVELS}$/) do |resource, levels|
     resource_name = get_resource(resource)
     level = Level.new(levels)
     if ENV['set_parent_id'] == 'true'
@@ -77,7 +80,7 @@ When(/^I request to create an? ([^:]+?)(#{LEVELS})?$/) do |resource, levels|
     steps %Q{When I send a POST request to "#{url}"}
 end
 
-When(/^I request to create an? ((?!<.+?(?: for | in | on ))[^"]+?)(#{LEVELS})? with:$/) do |resource, levels, params|
+When(/^I request to create #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{LEVELS} with:$/) do |resource, levels, params|
     resource_name = get_resource(resource)
     request_hash = get_attributes(params.hashes)
     level = Level.new(levels)
@@ -95,7 +98,7 @@ end
 
 # PUT
 
-When(/^I request to (?:create|replace|set) (?:an?|the) ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|id))? "([^"]+)"(#{LEVELS})?$/) do |resource, id, levels|
+When(/^I request to (?:create|replace|set) #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS}$/) do |resource, id, levels|
     resource_name = get_resource(resource)
     level = Level.new(levels)
     if ENV['set_parent_id'] == 'true'
@@ -113,7 +116,7 @@ When(/^I request to (?:create|replace|set) (?:an?|the) ((?![^"]+?(?: for | in |
     }
 end
 
-When(/^I request to (?:create|replace|set) (?:an?|the) ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|id))? "([^"]+)"(#{LEVELS})? (?:with|to):$/) do |resource, id, levels, params|
+When(/^I request to (?:create|replace|set) #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS} (?:with|to):$/) do |resource, id, levels, params|
     resource_name = get_resource(resource)
     request_hash = get_attributes(params.hashes)
     level = Level.new(levels)
@@ -131,7 +134,7 @@ end
 
 # PATCH
 
-When(/^I request to modify the ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|id))? "([^"]+)"(#{LEVELS})? with:$/) do |resource, id, levels, params|
+When(/^I request to modify #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS} with:$/) do |resource, id, levels, params|
     resource_name = get_resource(resource)
     request_hash = get_attributes(params.hashes)
     json = MultiJson.dump(request_hash)

data/lib/cucumber-rest-bdd/steps/response.rb

@@ -1,13 +1,16 @@
 require 'cucumber-rest-bdd/steps/resource'
 require 'cucumber-rest-bdd/types'
 
+LIST_HAS_SYNONYM = %r{(?:a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM}|\d+))\s+(#{FIELD_NAME_SYNONYM})}
+LIST_HAS_SYNONYM_WITHOUT_CAPTURE = %r{(?:a|an|(?:(?:#{FEWER_MORE_THAN_SYNONYM})\s+)?(?:#{INT_AS_WORDS_SYNONYM}|\d+))\s+(?:#{FIELD_NAME_SYNONYM})}
+
 Then(/^print the response$/) do
     puts %/The response:\n#{@response.to_json_s}/
 end
 
 # response interrogation
 
-Then(/^the response #{HAVE_SYNONYM} ([\w\s]+|`[^`]*`) of type (datetime|guid)$/) do |names, type|
+Then(/^the response #{HAVE_SYNONYM} (#{FIELD_NAME_SYNONYM}) of type (datetime|guid)$/) do |names, type|
     regex = case type
     when 'datetime' then /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:[+|-]\d{2}:\d{2})?$/i
     when 'guid' then /^[{(]?[0-9A-F]{8}[-]?([0-9A-F]{4}[-]?){3}[0-9A-F]{12}[)}]?$/i
@@ -16,7 +19,7 @@ Then(/^the response #{HAVE_SYNONYM} ([\w\s]+|`[^`]*`) of type (datetime|guid)$/)
     validate_value(names, 'string', regex)
 end
 
-Then(/^the response #{HAVE_SYNONYM} ([\w\s]+|`[^`]*`) of type (\w+) that matches "(.+)"$/) do |names, type, regex|
+Then(/^the response #{HAVE_SYNONYM} (#{FIELD_NAME_SYNONYM}) of type (\w+) that matches "(.+)"$/) do |names, type, regex|
     validate_value(names, type, Regexp.new(regex))
 end
 
@@ -27,12 +30,12 @@ def validate_value(names, type, regex)
     raise %/Expected #{json_path} value '#{value}' to match regex: #{regex}\n#{@response.to_json_s}/ if (regex =~ value).nil?
 end
 
-Then(/^the response is a list (?:of|containing) (#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) .*?$/) do |count_mod, count|
+Then("the response is a list of/containing {list_has_count} {field_name}") do |list_comparison, item|
     list = @response.get_as_type get_root_data_key(), 'array'
-    raise %/Expected at least #{count} items in array for path '#{get_root_data_key()}', found: #{list.count}\n#{@response.to_json_s}/ if !num_compare(count_mod, list.count, count.to_i)
+    raise %/Expected at least #{count} items in array for path '#{get_root_data_key()}', found: #{list.count}\n#{@response.to_json_s}/ if !list_comparison.compare(list.count)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`) )*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data|error )?attributes:$/) do |nesting, attributes|
+Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data|error )?attributes:$/) do |nesting, attributes|
     expected = get_attributes(attributes.hashes)
     groups = nesting
     grouping = get_grouping(groups)
@@ -44,7 +47,7 @@ Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{C
     raise %/Could not find a match for: #{nesting}\n#{expected.inspect}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, grouping, expected)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`) )*)#{HAVE_SYNONYM} (?:the )?(?:following )?value "([^"]*)"$/) do |nesting, value|
+Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} (?:the )?(?:following )?value "([^"]*)"$/) do |nesting, value|
     expected = value
     groups = nesting
     grouping = get_grouping(groups)
@@ -56,7 +59,7 @@ Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{C
     raise %/Could not find a match for: #{nesting}\n#{expected}\n#{@response.to_json_s}/ if data.empty? || !nest_match_value(data, grouping, expected)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`)\s?)+)$/) do |nesting|
+Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)+)$/) do |nesting|
     groups = nesting
     grouping = get_grouping(groups)
     grouping.push({
@@ -67,34 +70,34 @@ Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{C
     raise %/Could not find a match for: #{nesting}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, grouping, {})
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`) )*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data )?attributes:$/) do |count_mod, count, nesting, attributes|
+Then(/^#{LIST_HAS_SYNONYM} ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data )?attributes:$/) do |count_mod, count, count_item, nesting, attributes|
     expected = get_attributes(attributes.hashes)
     groups = nesting
     grouping = get_grouping(groups)
     grouping.push({
         root: true,
         type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        count: to_num(count),
+        count_mod: to_compare(count_mod)
     })
     data = @response.get get_key(grouping)
     raise %/Expected #{compare_to_string(count_mod)}#{count} items in array with attributes for: #{nesting}\n#{expected.inspect}\n#{@response.to_json_s}/ if !nest_match_attributes(data, grouping, expected)
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`)\s?)+)$/) do |count_mod, count, nesting|
+Then(/^#{LIST_HAS_SYNONYM} ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)+)$/) do |count_mod, count, count_item, nesting|
     groups = nesting
     grouping = get_grouping(groups)
     grouping.push({
         root: true,
         type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        count: to_num(count),
+        count_mod: to_compare(count_mod)
     })
     data = @response.get get_key(grouping)
     raise %/Expected #{compare_to_string(count_mod)}#{count} items in array with: #{nesting}\n#{@response.to_json_s}/ if !nest_match_attributes(data, grouping, {})
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`) )*)#{HAVE_SYNONYM} a list of (#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT} |\d+ )?(\w+)$/) do |nesting, num_mod, num, item|
+Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} a list of #{LIST_HAS_SYNONYM}$/) do |nesting, num_mod, num, item|
     groups = nesting
     list = {
         type: 'list',
@@ -114,7 +117,7 @@ Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{C
     raise %/Could not find a match for #{nesting}#{compare_to_string(num_mod)}#{num} #{item}\n#{@response.to_json_s}/ if !nest_match_attributes(data, grouping, {})
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`) )*)#{HAVE_SYNONYM} a list of (#{FEWER_MORE_THAN})?\s*(?:(#{CAPTURE_INT}|\d+) )?(\w+)$/) do |count_mod, count, nesting, num_mod, num, item|
+Then(/^#{LIST_HAS_SYNONYM} ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} a list of #{LIST_HAS_SYNONYM}$/) do |count_mod, count, count_item, nesting, num_mod, num, item|
     groups = nesting
     list = {
         type: 'list',
@@ -129,8 +132,8 @@ Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM}
     grouping.push({
         root: true,
         type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        count: to_num(count),
+        count_mod: to_compare(count_mod)
     })
     data = @response.get get_key(grouping)
     raise %/Expected #{compare_to_string(count_mod)}#{count} items with #{nesting}#{compare_to_string(num_mod)}#{num}#{item}\n#{@response.to_json_s}/ if !nest_match_attributes(data, grouping, {})
@@ -148,8 +151,8 @@ end
 # gets an array in the nesting format that nest_match_attributes understands to interrogate nested object and array data
 def get_grouping(nesting)
     grouping = []
-    while matches = /^#{HAVE_SYNONYM} (?:a|an|(?:(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+))) ([\w\s]+|`[^`]*`)\s?+/.match(nesting)
-        nesting = nesting[matches[0].length, nesting.length]
+    while matches = /#{LIST_HAS_SYNONYM}/.match(nesting)
+        nesting = nesting[matches.end(0), nesting.length]
         if matches[2].nil? then
             level = {
                 type: 'single',
@@ -176,6 +179,10 @@ end
 #
 # returns true if the expected data is contained within the data based on the nesting information
 def nest_match_attributes(data, nesting, expected)
+    print 'data:' + data.to_s
+    print 'nesting:' + nesting.to_s
+    print 'expected:' + expected.to_s
+
     return false if !data
     return data.deep_include?(expected) if nesting.size == 0
 
@@ -183,11 +190,12 @@ def nest_match_attributes(data, nesting, expected)
     level = local_nesting.pop
     case level[:type]
     when 'single' then
-        child_data = level[:root] ? data.dup : data[get_parameter(level[:key])]
+        child_data = level[:root] ? data.dup : data[get_field(level[:key])]
         return nest_match_attributes(child_data, local_nesting, expected)
     when 'multiple' then
-        child_data = level[:root] ? data.dup : data[get_parameter(level[:key])]
+        child_data = level[:root] ? data.dup : data[get_field(level[:key])]
         matched = child_data.select { |item| nest_match_attributes(item, local_nesting, expected) }
+        print 'matched:' + matched.count.to_s
         return num_compare(level[:count_mod], matched.count, level[:count])
     when 'list' then
         child_data = level[:root] ? data.dup : data[get_resource(level[:key])]
@@ -209,11 +217,11 @@ def nest_match_value(data, nesting, expected)
     level = local_nesting.pop
     case level[:type]
     when 'single' then
-        child_data = level[:root] ? data.dup : data[get_parameter(level[:key])]
+        child_data = level[:root] ? data.dup : data[get_field(level[:key])]
         return nest_match_value(child_data, local_nesting, expected)
     when 'multiple' then
-        child_data = level[:root] ? data.dup : data[get_parameter(level[:key])]
-        raise %/Key not found: #{level[:key]} as #{get_parameter(level[:key])} in #{data}/ if !child_data
+        child_data = level[:root] ? data.dup : data[get_field(level[:key])]
+        raise %/Key not found: #{level[:key]} as #{get_field(level[:key])} in #{data}/ if !child_data
         matched = child_data.select { |item| nest_match_value(item, local_nesting, expected) }
         return num_compare(level[:count_mod], matched.count, level[:count])
     when 'list' then

data/lib/cucumber-rest-bdd/types.rb

@@ -1,14 +1,40 @@
 require 'active_support/inflector'
 
-CAPTURE_INT = Transform(/^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/) do |v|
-    %w(zero one two three four five six seven eight nine ten).index(v)
-end
-
-FEWER_MORE_THAN = Transform(/^(?:(?:fewer|less|more) than|at (?:least|most))$/) do |v|
-    to_compare(v)
-end
-
 HAVE_SYNONYM = %{(?:has|have|having|contain|contains|containing|with)}
+RESOURCE_NAME = '[\w\s]+'
+RESOURCE_NAME_CAPTURE = /([\w\s]+)/
+ARTICLE = %{(?:an?|the)}
+FIELD_NAME_SYNONYM = %q{[\w\s]+|`[^`]*`}
+FEWER_MORE_THAN_SYNONYM = %q{(?:fewer|less|more) than|at (?:least|most)}
+INT_AS_WORDS_SYNONYM = %q{zero|one|two|three|four|five|six|seven|eight|nine|ten}
+
+ParameterType(
+    name: 'field_name',
+    regexp: /[\w\s]+|`[^`]*`/,
+    transformer: -> (s) { get_fields(s) },
+    use_for_snippets: false
+)
+
+ParameterType(
+  name: 'int_as_words',
+  regexp: /#{INT_AS_WORDS_SYNONYM}/,
+  transformer: -> (s) { to_num(s) }
+)
+
+ParameterType(
+  name: 'fewer_more_than',
+  regexp: /#{FEWER_MORE_THAN_SYNONYM}/,
+  transformer: -> (s) { to_compare(s) }
+)
+
+ParameterType(
+    name: 'list_has_count',
+    regexp: /a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM})/,
+    transformer: -> (count_mod, count) {
+        ListCountComparison.new(count_mod.nil? ? to_compare(count_mod) : CMP_EQUALS, count.nil? ? to_num(count) : 1)
+    },
+    use_for_snippets: false
+)
 
 CMP_LESS_THAN = '<'
 CMP_MORE_THAN = '>'
@@ -40,7 +66,7 @@ def compare_to_string(compare)
     end
 end
 
-# compare two numbers using the FEWER_MORE_THAN optional modifier
+# compare two numbers using the fewer_more_than optional modifier
 def num_compare(type, left, right)
     case type
     when CMP_LESS_THAN then left < right
@@ -79,6 +105,24 @@ class String
   end
 end
 
+class ListCountComparison
+    def initialize(type, amount)
+        @type = type
+        @amount = amount
+    end
+
+    def compare(actual)
+        case @type
+            when CMP_LESS_THAN then actual < @amount
+            when CMP_MORE_THAN then actual > @amount
+            when CMP_AT_MOST then actual <= @amount
+            when CMP_AT_LEAST then actual >= @amount
+            when CMP_EQUALS then actual == @amount
+            else actual == @amount
+        end
+    end
+end
+
 def parse_type(type)
     replacements = {
         /^numeric$/i => 'integer',
@@ -112,14 +156,14 @@ def get_root_error_key()
 end
 
 def get_json_path(names)
-    return "#{get_root_data_key()}#{get_parameters(names).join('.')}"
+    return "#{get_root_data_key()}#{get_fields(names).join('.')}"
 end
 
-def get_parameters(names)
-    return names.split(':').map { |n| get_parameter(n.strip) }
+def get_fields(names)
+    return names.split(':').map { |n| get_field(n.strip) }
 end
 
-def get_parameter(name)
+def get_field(name)
     if name[0] == '`' && name[-1] == '`'
         name = name[1..-2]
     elsif name[0] != '[' || name[-1] != ']'
@@ -136,7 +180,7 @@ def get_attributes(hashes)
       value = resolve(value)
       value.gsub!(/\\n/, "\n")
       type = parse_type(type)
-      names = get_parameters(name)
+      names = get_fields(name)
       new_hash = names.reverse.inject(value.to_type(type.camelize.constantize)) { |a, n| add_to_hash(a, n) }
       hash.deep_merge!(new_hash) { |key, old, new| new.kind_of?(Array) ? merge_arrays(old, new) : new }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alinta-cucumber-rest-bdd
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.5.15
 platform: ruby
 authors:
 - Harry Bragg
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: BDD Rest API specifics for cucumber