alinta-cucumber-rest-bdd 0.5.15 → 0.5.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c1c08f37c955dfab322c7f134f644e30503a01c
-  data.tar.gz: dbd38aab4b7e14cf854eb9e95c3226bd811e0abd
+  metadata.gz: 90847911531d65c3733c4d551f71f2baa423a928
+  data.tar.gz: 6c63a087ab4bc38b81ae0f116d5eecc23aca0691
 SHA512:
-  metadata.gz: 51fbffaf21822b8c00fe6ccc82c9b92338d143974ca842f58bf2bdcaecac181d1a0e9ed486fa2f7cee1a6e2002c8b42524135b2ac9ca14b4bb336f52e047b12b
-  data.tar.gz: 45ff06672c504df19e3acc5332fdefa49a45cda5fc81a94dea8fa2bdf1ea0b8f848459e551ec2e93c3ee1dc07c97bd1b87d4e25fd38845fb8123eb417712cfc5
+  metadata.gz: 49a81414220f17c4a70d3ba7748c4eff58e41679d831e01c68527041a5af8fb20b9848c4cb52cc836cf5e5a7c3bbeb586999b3cfdf125a0d00a41e1837f3fb4a
+  data.tar.gz: a6043d6bb06019ad6ccfe738cb1884f9714aa3ae359aab1d38552a874fe9346fa1a097b8c5757e3abc3fd1f026a85d7f97dbbba29af7ad3a7670dd9f703fe803

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

@@ -0,0 +1,52 @@
+require 'cucumber-rest-bdd/types'
+
+# gets the relevant key for the response based on the first key element
+def get_key(grouping)
+    errorKey = ENV['error_key']
+    if errorKey && !errorKey.empty? && grouping.count > 1 && grouping[-2][:key].singularize == errorKey then
+        return "$.#{errorKey}."
+    else
+        return get_root_data_key()
+    end
+end
+
+# top level has 2 children with an item containing at most three fish with attributes:
+#
+# nesting = [{key=fish,count=3,count_mod='<=',type=multiple},{key=item,type=single},{key=children,type=multiple,count=2,count_mod='='},{root=true,type=single}]
+#
+# returns true if the expected data is contained within the data based on the nesting information
+def nest_match_attributes(data, nesting, expected, matchValue)
+    return false if !data
+    return data.deep_include?(expected) if !matchValue && nesting.size == 0
+    return data.include?(expected) if matchValue && nesting.size == 0
+
+    local_nesting = nesting.dup
+    level = local_nesting.pop
+    child_data = get_child_data(level, data)
+
+    case level[:type]
+        when 'single' then
+            return nest_match_attributes(child_data, local_nesting, expected, matchValue)
+        when 'multiple' then
+            matched = child_data.select { |item| nest_match_attributes(item, local_nesting, expected, matchValue) }
+            return level[:comparison].compare(matched.count)
+        when 'list' then
+            return child_data.is_a?(Array) && (!level.has_key?(:comparison) || level[:comparison].compare(child_data.count))
+        else
+            raise %/Unknown nested data type: #{level[:type]}/
+    end
+end
+
+def get_child_data(level, data)
+    if (level[:root]) then
+        return data.dup
+    else
+        levelKey = case level[:type]
+            when 'single' then get_field(level[:key])
+            when 'multiple' then get_field(level[:key])
+            when 'list' then get_resource(level[:key])
+        end
+        raise %/Key not found: #{level[:key]} as #{levelKey} in #{data}/ if !data[levelKey]
+        return data[levelKey]
+    end
+end

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

@@ -1,7 +1,12 @@
 require 'cucumber-rest-bdd/types'
 require 'active_support/inflector'
 
-LEVELS = %{((?: (?:for|in|on) #{RESOURCE_NAME}(?: with (?:key|id))? "[^"]*")*)?}%
+ParameterType(
+    name: 'levels',
+    regexp: /((?: (?:for|in|on) #{RESOURCE_NAME_SYNONYM}(?: with (?:key|id))? "[^"]*")*)/,
+    transformer: -> (levels) { Level.new(levels) },
+    use_for_snippets: false
+)
 
 class Level
     @urls = []

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

@@ -0,0 +1,140 @@
+require 'cucumber-rest-bdd/types'
+
+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: 'list_has_count',
+    regexp: /a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM}|\d+)/,
+    transformer: -> (type, amount) { ListCountComparison.new(type, amount) },
+    use_for_snippets: false
+)
+
+ParameterType(
+    name: 'list_nesting',
+    regexp: %r{((?:(?:#{HAVE_ALTERNATION.split('/').join('|')})\s+(?:a list of\s+)?(?:a|an|(?:(?:#{FEWER_MORE_THAN_SYNONYM})\s+)?(?:#{INT_AS_WORDS_SYNONYM}|\d+))\s+(?:#{FIELD_NAME_SYNONYM})\s*)*)},
+    transformer: -> (match) { ListNesting.new(match) },
+    use_for_snippets: false
+)
+
+class ListNesting
+    def initialize(match)
+        @match = match
+        # gets an array in the nesting format that nest_match_attributes understands to interrogate nested object and array data
+        grouping = []
+        nesting = match
+        
+        minimalListRegex = %r{(?:#{HAVE_ALTERNATION.split('/').join('|')})\s+(?:(a list of)\s+)?(?:a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM}|\d+))\s+(#{FIELD_NAME_SYNONYM})}
+        maximalListRegex = %r{(?:#{HAVE_ALTERNATION.split('/').join('|')})\s+(?:(a list of)\s+)?(?:a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM}|\d+))\s+(#{MAXIMAL_FIELD_NAME_SYNONYM})}
+        while matches = minimalListRegex.match(nesting)
+            nextMatches = minimalListRegex.match(nesting[matches.end(0), nesting.length])
+            matches = maximalListRegex.match(nextMatches.nil? ? nesting : nesting[0, matches.end(0) + nextMatches.begin(0)])
+            nesting = nesting[matches.end(0), nesting.length]
+
+            if matches[1].nil? then
+                if matches[3].nil? then
+                    level = {
+                        type: 'single',
+                        key: matches[4],
+                        root: false
+                    }
+                else
+                    level = {
+                        type: 'multiple',
+                        key: matches[4],
+                        comparison: ListCountComparison.new(matches[2], matches[3]),
+                        root: false
+                    }
+                end
+            else
+                level = {
+                    type: 'list',
+                    key: matches[4],
+                    comparison: ListCountComparison.new(matches[2], matches[3]),
+                    root: false
+                }
+            end
+            grouping.push(level)
+        end
+        @grouping = grouping.reverse
+    end
+
+    def push(node)
+        @grouping.push(node)
+    end
+
+    def match
+        return @match
+    end
+
+    def grouping
+        @grouping
+    end
+end
+
+class ListCountComparison
+    def initialize(type, amount)
+        @type = type.nil? ? CMP_EQUALS : to_compare(type)
+        @amount = amount.nil? ? 1 : to_num(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
+
+    def type
+        return @type
+    end
+
+    def amount
+        return amount
+    end
+
+    # turn a comparison into a string
+    def compare_to_string()
+        case @type
+        when CMP_LESS_THAN then 'fewer than '
+        when CMP_MORE_THAN then 'more than '
+        when CMP_AT_LEAST then 'at least '
+        when CMP_AT_MOST then 'at most '
+        when CMP_EQUALS then 'exactly '
+        else ''
+        end
+    end
+
+    def to_string()
+        return compare_to_string() + ' ' + @amount.to_s
+    end
+end
+
+CMP_LESS_THAN = '<'
+CMP_MORE_THAN = '>'
+CMP_AT_LEAST = '>='
+CMP_AT_MOST = '<='
+CMP_EQUALS = '='
+
+# take a number modifier string (fewer than, less than, etc) and return an operator '<', etc
+def to_compare(compare)
+    return case compare
+    when 'fewer than' then CMP_LESS_THAN
+    when 'less than' then CMP_LESS_THAN
+    when 'more than' then CMP_MORE_THAN
+    when 'at least' then CMP_AT_LEAST
+    when 'at most' then CMP_AT_MOST
+    else CMP_EQUALS
+    end
+end
+
+def to_num(num)
+    if /^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/.match(num)
+        return %w(zero one two three four five six seven eight nine ten).index(num)
+    end
+    return num.to_i
+end

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

@@ -1,4 +1,4 @@
-Given(/^I retrieve the API Management subscription key secret "(.*?)" from Azure Storage Vault "(.*?)" using tenant "(.*?)" with credentials "(.*?)" and "(.*?)"$/) do |secret_name, vault_name, tenant_id, client_id, client_secret|
+Given("I retrieve the API Management subscription key secret {string} from Azure Storage Vault {string} using tenant {string} with credentials {string} and {string}") do |secret_name, vault_name, tenant_id, client_id, client_secret|
     if @apim_subscription_key.to_s.empty?
         steps %Q{
             Given I retrieve the secret "#{secret_name}" from Azure Storage Vault "#{vault_name}" using tenant "#{tenant_id}" with credentials "#{client_id}" and "#{client_secret}"
@@ -7,14 +7,14 @@ Given(/^I retrieve the API Management subscription key secret "(.*?)" from Azure
     end
 end
 
-Given(/^I add the API Management key header$/) do
+Given("I add the API Management key header") do
     steps %Q{
         And I add Headers:
         | Ocp-Apim-Subscription-Key | #{@apim_subscription_key} |
     }
 end
 
-Given(/^I retrieve the secret "(.*?)" from Azure Storage Vault "(.*?)" using tenant "(.*?)" with credentials "(.*?)" and "(.*?)"$/) do |secret_name, vault_name, tenant_id, client_id, client_secret|
+Given("I retrieve the secret {string} from Azure Storage Vault {string} using tenant {string} with credentials {string} and {string}") do |secret_name, vault_name, tenant_id, client_id, client_secret|
     steps %Q{
         Given I authenticate with Azure tenant "#{tenant_id}" using client credentials "#{client_id}" and "#{client_secret}"
     }
@@ -24,13 +24,13 @@ Given(/^I retrieve the secret "(.*?)" from Azure Storage Vault "(.*?)" using ten
     }
 end
 
-Given(/^I authenticate with Azure tenant "(.*?)" using client credentials "(.*?)" and "(.*?)"$/) do |tenant_id, client_id, client_secret|
+Given("I authenticate with Azure tenant {string} using client credentials {string} and {string}") do |tenant_id, client_id, client_secret|
     steps %Q{
         Given I authenticate with "https://login.windows.net/#{tenant_id}/oauth2/token" using client credentials "#{client_id}" and "#{client_secret}"
     }
 end
 
-Given(/^I authenticate with "(.*?)" using client credentials "(.*?)" and "(.*?)"$/) do |url, client_id, client_secret|
+Given("I authenticate with {string} using client credentials {string} and {string}") do |url, client_id, client_secret|
     steps %Q{
         Given I send "www-x-form-urlencoded" and accept JSON
         When I set form request body to:
@@ -43,7 +43,7 @@ Given(/^I authenticate with "(.*?)" using client credentials "(.*?)" and "(.*?)"
     }
 end
 
-Given(/^I retrieve the secret "([^"]*)" from Azure Storage Vault "([^"]*)" using access token "([^"]*)"$/) do |secret_name, vault_name, access_token|
+Given("I retrieve the secret {string} from Azure Storage Vault {string} using access token {string}") 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

@@ -1,8 +1,9 @@
 require 'cucumber-api/response'
 require 'cucumber-api/steps'
 require 'cucumber-rest-bdd/types'
+require 'cucumber-rest-bdd/list'
 
-Then(/^the response (?:should have|has a|has the) header "([^"]*)" with (?:a |the )?value "([^"]*)"$/) do |header, value|
+Then("the response (should )have/has (a/the )header {string} #{HAVE_ALTERNATION} (a/the )value {string}") do |header, value|
     p_value = resolve(value)
     p_header = header.parameterize
     raise %/Required header: #{header} not found\n#{@response.raw_headers.inspect}/ if !@response.raw_headers.key?(p_header)
@@ -10,23 +11,17 @@ Then(/^the response (?:should have|has a|has the) header "([^"]*)" with (?:a |th
     raise %/Expect #{p_value} in #{header} (#{p_header})\n#{@response.raw_headers.inspect}/ if !exists
 end
 
-Then(/^the JSON response should have "([^"]*)" of type array with (\d+) entr(?:y|ies)$/) do |json_path, number|
+Then("the JSON response should have {string} of type array #{HAVE_ALTERNATION} {list_has_count} entry/entries") do |json_path, list_comparison|
   list = @response.get_as_type json_path, 'array'
-  raise %/Expected #{number} items in array for path '#{json_path}', found: #{list.count}\n#{@response.to_json_s}/ if list.count != number.to_i
+  raise %/Expected #{list_comparison.to_string()} entries in array for path '#{json_path}', found: #{list.count}\n#{@response.to_json_s}/ if !list_comparison.compare(list.count)
 end
 
-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)
-end
-
-Then(/^the JSON response should have "([^"]*)" of type (.+) that matches "(.+)"$/) do |json_path, type, regex|
+Then("the JSON response should have {string} of type {word} that matches {string}") do |json_path, type, regex|
     value = @response.get_as_type json_path, type
     raise %/Expected #{json_path} value '#{value}' to match regex: #{regex}\n#{@response.to_json_s}/ if (Regexp.new(regex) =~ value).nil?
 end
 
-Then(/^the JSON response should have "([^"]*)" of type (?:nill|null|nil)$/) do |json_path|
+Then("the JSON response should have {string} of type nill/null/nil") do |json_path|
     value = @response.get_as_type_or_null json_path, 'string'
     raise %/Expected #{json_path} to be nil, was: #{value.class}\n#{@response.to_json_s}/ if !value.nil?
 end

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

@@ -10,27 +10,25 @@ require 'easy_diff'
 GET_TYPES = %{(?:an?(?! list)|the)}%
 WITH_ID = %{(?: with (?:key|id))? "([^"]*)"}%
 
-Given(/^I am a client$/) do
+Given("I am a client") do
     steps %Q{
       Given I send "application/json" and accept JSON
     }
 end
 
-Given(/^I am issuing requests for #{RESOURCE_NAME_CAPTURE}$/) do |resource|
-    @urlbasepath = get_resource(resource)
+Given("I am issuing requests for {resource_name}") do |resource|
+    @urlbasepath = resource
 end
 
 # GET
 
-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}")
+When("I request the {resource_name} (with key/id ){string}{levels}") do |resource, id, levels|
+    url = get_url("#{levels.url}#{resource}/#{id}")
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-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}")
+When("I request the {resource_name} (with key/id ){string}{levels} with:") do |resource, id, levels, params|
+    url = get_url("#{levels.url}#{resource}/#{id}")
     unless params.raw.empty?
         query = params.raw.map{|key, value| %/#{get_field(key)}=#{resolve(value)}/}.join("&")
         url = "#{url}?#{query}"
@@ -38,15 +36,13 @@ When(/^I request #{GET_TYPES} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS} with:$
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-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}")
+When("I request a list of {resource_name}{levels}") do |resource, levels|
+    url = get_url("#{levels.url}#{resource}")
     steps %Q{When I send a GET request to "#{url}"}
 end
 
-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}")
+When("I request a list of {resource_name}{levels} with:") do |resource, levels, params|
+    url = get_url("#{levels.url}#{resource}")
     unless params.raw.empty?
         query = params.raw.map{|key, value| %/#{get_field(key)}=#{resolve(value)}/}.join("&")
         url = "#{url}?#{query}"
@@ -56,19 +52,16 @@ end
 
 # DELETE
 
-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}")
+When("I request to delete/remove a/an/the {resource_name} (with key/id ){string}{levels}") do |resource, id, levels|
+    url = get_url("#{levels.url}#{resource}/#{id}")
     steps %Q{When I send a DELETE request to "#{url}"}
 end
 
 # POST
 
-When(/^I request to create #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{LEVELS}$/) do |resource, levels|
-    resource_name = get_resource(resource)
-    level = Level.new(levels)
+When("I request to create a/an/the {resource_name}{levels}") do |resource, levels|
     if ENV['set_parent_id'] == 'true'
-        json = MultiJson.dump(level.last_hash)
+        json = MultiJson.dump(levels.last_hash)
         steps %Q{
             When I set JSON request body to:
             """
@@ -76,17 +69,15 @@ When(/^I request to create #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{LEVELS}$/) do |r
             """
         }
     end
-    url = get_url("#{level.url}#{resource_name}")
+    url = get_url("#{levels.url}#{resource}")
     steps %Q{When I send a POST request to "#{url}"}
 end
 
-When(/^I request to create #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{LEVELS} with:$/) do |resource, levels, params|
-    resource_name = get_resource(resource)
+When("I request to create a/an/the {resource_name}{levels} with:") do |resource, levels, params|
     request_hash = get_attributes(params.hashes)
-    level = Level.new(levels)
-    request_hash = request_hash.merge(level.last_hash) if ENV['set_parent_id'] == 'true'
+    request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
     json = MultiJson.dump(request_hash)
-    url = get_url("#{level.url}#{resource_name}")
+    url = get_url("#{levels.url}#{resource}")
     steps %Q{
         When I set JSON request body to:
             """
@@ -98,11 +89,9 @@ end
 
 # PUT
 
-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)
+When("I request to replace/set a/an/the {resource_name} (with key/id ){string}{levels}") do |resource, id, levels|
     if ENV['set_parent_id'] == 'true'
-        json = MultiJson.dump(level.last_hash)
+        json = MultiJson.dump(levels.last_hash)
         steps %Q{
             When I set JSON request body to:
             """
@@ -110,19 +99,17 @@ When(/^I request to (?:create|replace|set) #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{
             """
         }
     end
-    url = get_url("#{level.url}#{resource_name}/#{id}")
+    url = get_url("#{levels.url}#{resource}/#{id}")
     steps %Q{
         When I send a PUT request to "#{url}"
     }
 end
 
-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)
+When("I request to replace/set a/an/the {resource_name} (with key/id ){string}{levels} with:") do |resource, id, levels, params|
     request_hash = get_attributes(params.hashes)
-    level = Level.new(levels)
-    request_hash = request_hash.merge(level.last_hash) if ENV['set_parent_id'] == 'true'
+    request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
     json = MultiJson.dump(request_hash)
-    url = get_url("#{level.url}#{resource_name}/#{id}")
+    url = get_url("#{levels.url}#{resource}/#{id}")
     steps %Q{
         When I set JSON request body to:
             """
@@ -134,11 +121,10 @@ end
 
 # PATCH
 
-When(/^I request to modify #{ARTICLE} #{RESOURCE_NAME_CAPTURE}#{WITH_ID}#{LEVELS} with:$/) do |resource, id, levels, params|
-    resource_name = get_resource(resource)
+When("I request to modify/update a/an/the {resource_name} (with key/id ){string}{levels} with:") do |resource, id, levels, params|
     request_hash = get_attributes(params.hashes)
     json = MultiJson.dump(request_hash)
-    url = get_url("#{Level.new(levels).url}#{resource_name}/#{id}")
+    url = get_url("#{levels.url}#{resource}/#{id}")
     steps %Q{
         When I set JSON request body to:
             """
@@ -150,10 +136,10 @@ end
 
 # value capture
 
-When(/^I save (?:attribute )?"([^"]+)"$/) do |attribute|
+When("I save (attribute ){string}") do |attribute|
     steps %Q{When I grab "#{get_json_path(attribute)}" as "#{attribute}"}
 end
 
-When(/^I save (?:attribute )?"([^"]+)" to "([^"]+)"$/) do |attribute, ref|
+When("I save (attribute ){string} to {string}") do |attribute, ref|
     steps %Q{When I grab "#{get_json_path(attribute)}" as "#{ref}"}
 end

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

@@ -1,237 +1,80 @@
 require 'cucumber-rest-bdd/steps/resource'
 require 'cucumber-rest-bdd/types'
+require 'cucumber-rest-bdd/list'
+require 'cucumber-rest-bdd/data'
 
-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
+Then("print the response") do
     puts %/The response:\n#{@response.to_json_s}/
 end
 
 # response interrogation
 
-Then(/^the response #{HAVE_SYNONYM} (#{FIELD_NAME_SYNONYM}) of type (datetime|guid)$/) do |names, type|
+Then("the response #{HAVE_ALTERNATION} {field_name} of type {word}") do |field, 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
-    else 'UNKNOWN'
+        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
+        else nil
     end
-    validate_value(names, 'string', regex)
-end
 
-Then(/^the response #{HAVE_SYNONYM} (#{FIELD_NAME_SYNONYM}) of type (\w+) that matches "(.+)"$/) do |names, type, regex|
-    validate_value(names, type, Regexp.new(regex))
+    type = 'string' if regex.nil?
+    field.validate_value(field.get_value(type), Regexp.new(regex))
 end
 
-def validate_value(names, type, regex)
-    json_path = get_json_path(names)
-    type = parse_type(type)
-    value = @response.get_as_type json_path, type
-    raise %/Expected #{json_path} value '#{value}' to match regex: #{regex}\n#{@response.to_json_s}/ if (regex =~ value).nil?
+Then("the response #{HAVE_ALTERNATION} {field_name} of type {word} that matches {string}") do |field, type, regex|
+    field.validate_value(field.get_value(type), Regexp.new(regex))
 end
 
 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 !list_comparison.compare(list.count)
+    raise %/Expected #{list_comparison.to_string()} 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}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data|error )?attributes:$/) do |nesting, attributes|
+Then("the response( {list_nesting}) #{HAVE_ALTERNATION} (the )(following )attributes:") do |nesting, attributes|
     expected = get_attributes(attributes.hashes)
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+    nesting.push({
         root: true,
         type: 'single'
     })
-    data = @response.get get_key(grouping)
-    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)
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected.inspect}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, false)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)*)#{HAVE_SYNONYM} (?:the )?(?:following )?value "([^"]*)"$/) do |nesting, value|
+Then("the response( {list_nesting}) #{HAVE_ALTERNATION} (the )(following )value {string}") do |nesting, value|
     expected = value
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+    nesting.push({
         root: true,
         type: 'single'
     })
-    data = @response.get get_key(grouping)
-    raise %/Could not find a match for: #{nesting}\n#{expected}\n#{@response.to_json_s}/ if data.empty? || !nest_match_value(data, grouping, expected)
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, true)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM}\s+#{LIST_HAS_SYNONYM_WITHOUT_CAPTURE}\s+)+)$/) do |nesting|
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+Then("the response {list_nesting}") do |nesting|
+    nesting.push({
         root: true,
         type: 'single'
     })
-    data = @response.get get_key(grouping)
-    raise %/Could not find a match for: #{nesting}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, grouping, {})
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, {}, false)
 end
 
-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|
+Then("{list_has_count} {field_name}( {list_nesting}) #{HAVE_ALTERNATION} (the )(following )(data )attributes:") do |list_comparison, count_item, nesting, attributes|
     expected = get_attributes(attributes.hashes)
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+    nesting.push({
         root: true,
         type: 'multiple',
-        count: to_num(count),
-        count_mod: to_compare(count_mod)
+        comparison: list_comparison
     })
-    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)
+    data = @response.get get_key(nesting.grouping)
+    raise %/Expected #{list_comparison.to_string()} items in array with attributes for: #{nesting.match}\n#{expected.inspect}\n#{@response.to_json_s}/ if !nest_match_attributes(data, nesting.grouping, expected, false)
 end
 
-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({
+Then("{list_has_count} {field_name} {list_nesting}") do |list_comparison, item, nesting|
+    nesting.push({
         root: true,
         type: 'multiple',
-        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}\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',
-        key: get_resource(item)
-    }
-    if (num) then
-        list[:count] = num.to_i
-        list[:count_mod] = num_mod
-    end
-    grouping = [list]
-    grouping.concat(get_grouping(groups))
-    grouping.push({
-        root: true,
-        type: 'single'
+        comparison: list_comparison
     })
-    data = @response.get get_key(grouping)
-    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(/^#{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',
-        key: get_resource(item)
-    }
-    if (num) then
-        list[:count] = num.to_i
-        list[:count_mod] = num_mod
-    end
-    grouping = [list]
-    grouping.concat(get_grouping(groups))
-    grouping.push({
-        root: true,
-        type: 'multiple',
-        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, {})
-end
-
-# gets the relevant key for the response based on the first key element
-def get_key(grouping)
-    if ENV['error_key'] && !ENV['error_key'].empty? && grouping.count > 1 && grouping[-2][:key].singularize == ENV['error_key'] then
-        get_root_error_key()
-    else
-        get_root_data_key()
-    end
-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 = /#{LIST_HAS_SYNONYM}/.match(nesting)
-        nesting = nesting[matches.end(0), nesting.length]
-        if matches[2].nil? then
-            level = {
-                type: 'single',
-                key: matches[3],
-                root: false
-            }
-        else
-            level = {
-                type: 'multiple',
-                key: matches[3],
-                count: to_num(matches[2]),
-                root: false,
-                count_mod: to_compare(matches[1])
-            }
-        end
-        grouping.push(level)
-    end
-    return grouping.reverse
-end
-
-# top level has 2 children with an item containing at most three fish with attributes:
-#
-# nesting = [{key=fish,count=3,count_mod='<=',type=multiple},{key=item,type=single},{key=children,type=multiple,count=2,count_mod='='},{root=true,type=single}]
-#
-# 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
-
-    local_nesting = nesting.dup
-    level = local_nesting.pop
-    case level[:type]
-    when 'single' then
-        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_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])]
-        return false if !child_data.is_a?(Array)
-        if level.has_key?(:count) then
-            return num_compare(level[:count_mod], child_data.count, level[:count])
-        end
-        return true
-    else
-        raise %/Unknown nested data type: #{level[:type]}/
-    end
-end
-
-def nest_match_value(data, nesting, expected)
-    return false if !data
-    return data.include?(expected) if nesting.size == 0
-
-    local_nesting = nesting.dup
-    level = local_nesting.pop
-    case level[:type]
-    when 'single' then
-        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_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
-        child_data = level[:root] ? data.dup : data[get_resource(level[:key])]
-        return false if !child_data.is_a?(Array)
-        if level.has_key?(:count) then
-            return num_compare(level[:count_mod], child_data.count, level[:count])
-        end
-        return true
-    else
-        raise %/Unknown nested data type: #{level[:type]}/
-    end
+    data = @response.get get_key(nesting.grouping)
+    raise %/Expected #{list_comparison.to_string()} items in array with: #{nesting.match}\n#{@response.to_json_s}/ if !nest_match_attributes(data, nesting.grouping, {}, false)
 end

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

@@ -1,63 +1,66 @@
 require 'cucumber-api/response'
 require 'cucumber-api/steps'
 
-Then(/^the request (?:is|was) successful$/) do
+ParameterType(
+    name: 'item_type',
+    regexp: /([\w\s]+)/,
+    transformer: -> (s) { s },
+    use_for_snippets: false
+)
+
+Then("the request is/was successful") do
     raise %/Expected Successful response code 2xx but was #{@response.code}/ if @response.code < 200 || @response.code >= 300
 end
 
-Then(/^the request (?:is|was) redirected$/) do
+Then("the request is/was redirected") do
     raise %/Expected redirected response code 3xx but was #{@response.code}/ if @response.code < 300 || @response.code >= 400
 end
 
-Then(/^(?:it|the request) fail(?:s|ed)$/) do
+Then("the request fail(s/ed)") do
     raise %/Expected failed response code 4xx\/5xx but was #{@response.code}/ if @response.code < 400 || @response.code >= 600
 end
 
-Then(/^the (?!request)(?:.+?) (?:is|was) created$/) do
-    steps %Q{Then the response status should be "201"}
-end
-
-Then(/^the request (?:is|was) successful and (?:a resource|.+) (?:is|was) created$/) do
+Then("the request is/was successful and a/the resource/{item_type} is/was created") do | item_type |
     steps %Q{Then the response status should be "201"}
 end
 
-Then(/^the request (?:is|was) successfully accepted$/) do
+Then("the request is/was successfully accepted") do
   steps %Q{Then the response status should be "202"}
 end
 
-Then(/^the request (?:is|was) successful and (?:no|an empty) response body is returned$/) do
+Then("the request is/was successful and (an )empty/blank/no response body is/was returned") do
   steps %Q{Then the response status should be "204"}
   raise %/Expected the request body to be empty/ if !@response.body.empty?
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because it (?:is|was) invalid$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was invalid") do | item_type |
     steps %Q{Then the response status should be "400"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because (?:.+) (?:is|was|am|are) unauthori[sz]ed$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was/am/are unauthorised/unauthorized") do | item_type |
     steps %Q{Then the response status should be "401"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because (?:.+) (?:is|was) forbidden$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was forbidden") do | item_type |
     steps %Q{Then the response status should be "403"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not found$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was not found") do | item_type |
     steps %Q{Then the response status should be "404"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because it (?:is|was) not allowed$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was not allowed") do
     steps %Q{Then the response status should be "405"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because there (?:is|was|has) a conflict(?: with .+)?$/) do
+Then("the request fail(s/ed) because there is/was/has a conflict( with {item_type})") do | item_type |
     steps %Q{Then the response status should be "409"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was|has) gone$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was/has gone") do | item_type |
     steps %Q{Then the response status should be "410"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not implemented$/) do
+Then("the request fail(s/ed) because (the )it/resource/{item_type} is/was not implemented") do | item_type |
     steps %Q{Then the response status should be "501"}
 end

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

@@ -1,90 +1,24 @@
 require 'active_support/inflector'
 
-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}
+HAVE_ALTERNATION = "has/have/having/contain/contains/containing/with"
+RESOURCE_NAME_SYNONYM = '\w+\b(?:\s+\w+\b)*?'
+FIELD_NAME_SYNONYM = "#{RESOURCE_NAME_SYNONYM}|`[^`]*`"
+MAXIMAL_FIELD_NAME_SYNONYM = '\w+\b(?:\s+\w+\b)*|`[^`]*`'
 
 ParameterType(
-    name: 'field_name',
-    regexp: /[\w\s]+|`[^`]*`/,
-    transformer: -> (s) { get_fields(s) },
+    name: 'resource_name',
+    regexp: /#{RESOURCE_NAME_SYNONYM}/,
+    transformer: -> (s) { get_resource(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)
-    },
+    name: 'field_name',
+    regexp: /#{FIELD_NAME_SYNONYM}/,
+    transformer: -> (s) { ResponseField.new(s) },
     use_for_snippets: false
 )
 
-CMP_LESS_THAN = '<'
-CMP_MORE_THAN = '>'
-CMP_AT_LEAST = '>='
-CMP_AT_MOST = '<='
-CMP_EQUALS = '='
-
-# take a number modifier string (fewer than, less than, etc) and return an operator '<', etc
-def to_compare(compare)
-    return case compare
-    when 'fewer than' then CMP_LESS_THAN
-    when 'less than' then CMP_LESS_THAN
-    when 'more than' then CMP_MORE_THAN
-    when 'at least' then CMP_AT_LEAST
-    when 'at most' then CMP_AT_MOST
-    else CMP_EQUALS
-    end
-end
-
-# turn a comparison into a string
-def compare_to_string(compare)
-    case compare
-    when CMP_LESS_THAN then 'fewer than '
-    when CMP_MORE_THAN then 'more than '
-    when CMP_AT_LEAST then 'at least '
-    when CMP_AT_MOST then 'at most '
-    when CMP_EQUALS then ''
-    else ''
-    end
-end
-
-# 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
-    when CMP_MORE_THAN then left > right
-    when CMP_AT_MOST then left <= right
-    when CMP_AT_LEAST then left >= right
-    when CMP_EQUALS then left == right
-    else left == right
-    end
-end
-
-def to_num(num)
-    if /^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/.match(num)
-        return %w(zero one two three four five six seven eight nine ten).index(num)
-    end
-    return num.to_i
-end
-
 module Boolean; end
 class TrueClass; include Boolean; end
 class FalseClass; include Boolean; end
@@ -105,21 +39,21 @@ class String
   end
 end
 
-class ListCountComparison
-    def initialize(type, amount)
-        @type = type
-        @amount = amount
+class ResponseField
+    def initialize(names)
+        @fields = get_fields(names)
     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
+    def to_json_path()
+        return "#{get_root_data_key()}#{@fields.join('.')}"
+    end
+
+    def get_value(type)
+        return @response.get_as_type to_json_path(), parse_type(type)
+    end
+
+    def validate_value(value, regex)
+        raise %/Expected #{json_path} value '#{value}' to match regex: #{regex}\n#{@response.to_json_s}/ if (regex =~ value).nil?
     end
 end
 
@@ -151,10 +85,6 @@ def get_root_data_key()
     return ENV.has_key?('data_key') && !ENV['data_key'].empty? ? "$.#{ENV['data_key']}." : "$."
 end
 
-def get_root_error_key()
-    return "$."
-end
-
 def get_json_path(names)
     return "#{get_root_data_key()}#{get_fields(names).join('.')}"
 end
@@ -200,7 +130,15 @@ def merge_arrays(a, b)
     new_length = [a.length, b.length].max
     new_array = Array.new(new_length)
     new_length.times do |n|
-        new_array[n] = b[n] == nil ? a[n] : b[n]
+        if b[n].nil? then
+            new_array[n] = a[n]
+        else
+            if a[n].nil? then
+                new_array[n] = b[n]
+            else
+                new_array[n] = a[n].merge(b[n])
+            end
+        end
     end
     return new_array
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alinta-cucumber-rest-bdd
 version: !ruby/object:Gem::Version
-  version: 0.5.15
+  version: 0.5.16
 platform: ruby
 authors:
 - Harry Bragg
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-27 00:00:00.000000000 Z
+date: 2018-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alinta-cucumber-api
@@ -62,8 +62,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cucumber-rest-bdd.rb
+- lib/cucumber-rest-bdd/data.rb
 - lib/cucumber-rest-bdd/hash.rb
 - lib/cucumber-rest-bdd/level.rb
+- lib/cucumber-rest-bdd/list.rb
 - lib/cucumber-rest-bdd/steps.rb
 - lib/cucumber-rest-bdd/steps/auth.rb
 - lib/cucumber-rest-bdd/steps/functional.rb