cucumber-rest-bdd 0.5.3 → 0.6.0.pre.183

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2547016607fa79d879dbb328aaf2e022d1ac0fd6
-  data.tar.gz: 7776a33cd86d41035071c0eeae544a801263dc17
+SHA256:
+  metadata.gz: 2ace80d0cd81cb18bfbb26e4dc2dfe20ee084cd95408382020d8030f9b9a574b
+  data.tar.gz: 86de8eb49558ed6688b5326571eb8440966a565adca95024e72c432e327f1b95
 SHA512:
-  metadata.gz: 97acb7ee3d866afd73c1aa28bb54dd8a39f5e5b3eab5c0ba7b6d21418d841dc8024102f6d760435d24cc0da84844d9025a6c3c2ade32e8e504ddb6774b8bde27
-  data.tar.gz: a8e3153c7afa81a77ce5f326bc8a9f3c7b5ea27a0ea83a42df24603599c00c044efc99b609187eb83df1b1f46520e78c8fc3fa09964294231ac9cd06e32c36f0
+  metadata.gz: c36991b0161ea4f86cade6e3aa163b5996feca2990114ca69ca54756c1763087fcf7fc50f0893fc4f1e05ca4062412d048a9d7fe8fb9610812c6cd91582a5677
+  data.tar.gz: 286eeddd1565590b32fd528e8e40b0c4ad183bdb78eccee72fa3af9c6e53fc67e5b2db848c2f7406a2869dc8b22a7fc62ecac76195e9b4683bda4367f7a2dcd9

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 "$."
+    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_list_field(level[:key])
+            when 'list' then get_list_field(level[:key])
+        end
+        raise %/Key not found: #{level[:key]} as #{levelKey} in #{data}/ if data.is_a?(Array) || !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) [^"]+?(?: 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 = []
@@ -26,14 +31,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/list.rb

@@ -0,0 +1,144 @@
+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: -> (match) {
+        matches = /(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?(#{INT_AS_WORDS_SYNONYM}|\d+)/.match(match)
+        return ListCountComparison.new(matches[1], matches[2])
+    },
+    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/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

@@ -7,41 +7,44 @@ require 'cucumber-rest-bdd/level'
 require 'cucumber-rest-bdd/hash'
 require 'easy_diff'
 
-Given(/^I am a client$/) do
+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 {resource_name}") do |resource|
+    @urlbasepath = resource
+end
+
 # GET
 
-When(/^I request (?:an?(?! list)|the) ([^"]+?)(?: with (?:key|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 (?:an?(?! list)|the) (.+?)(?: with (?:key|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_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|
-    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 (.+?)(#{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_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}"}
@@ -49,19 +52,16 @@ end
 
 # DELETE
 
-When(/^I request to (?:delete|remove) the ([^"]+?) "([^"]*)"(#{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 an? ([^:]+?)(#{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:
             """
@@ -69,17 +69,15 @@ When(/^I request to create an? ([^:]+?)(#{LEVELS})?$/) do |resource, levels|
             """
         }
     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 an? ((?!<.+?(?: for | in | on ))[^"]+?)(#{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:
             """
@@ -91,11 +89,9 @@ end
 
 # PUT
 
-When(/^I request to (?:create|replace|set) (?:an?|the) ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|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:
             """
@@ -103,19 +99,17 @@ When(/^I request to (?:create|replace|set) (?:an?|the) ((?![^"]+?(?: for | in |
             """
         }
     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) (?:an?|the) ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|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:
             """
@@ -127,11 +121,10 @@ end
 
 # PATCH
 
-When(/^I request to modify the ((?![^"]+?(?: for | in | on ))[^"]+?)(?: with (?:key|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:
             """
@@ -143,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