alinta-cucumber-rest-bdd 0.5.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6a3128ba01da04df49abe07ca69add1a49e180d
+  data.tar.gz: '0590435deb022044b88e96c93cbddff01bd04017'
+SHA512:
+  metadata.gz: 14163134b5325de4b1fd3e65133cd4796109dd959a8d811af2385c1acdc6517e9268486b73487e52ca13d007775ea408cf58bd445246baffb060c184642adf39
+  data.tar.gz: 533e16434ca8ab1df0978982e6422f00339744e2a76f57ca5e8065d49443823148238dbeabe2d62d16da9cd2c60bb933329b0ca94b9f04f0b1df3b6248841d2c

data/lib/cucumber-rest-bdd.rb

@@ -0,0 +1 @@
+require 'cucumber-rest-bdd/steps'

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

@@ -0,0 +1,9 @@
+require 'easy_diff'
+
+class Hash
+    def deep_include?(other)
+        diff = other.easy_diff(self)
+        diff[0].delete_if { |k, v| v.empty? if v.is_a?(::Hash) }
+        diff[0].empty?
+    end
+end

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

@@ -0,0 +1,47 @@
+require 'cucumber-rest-bdd/types'
+require 'active_support/inflector'
+
+LEVELS = %{(?: (?:for|in|on) [^"]+?(?: with (?:key|id))? "[^"]+")*}%
+
+class Level
+    @urls = []
+
+    def initialize(levels)
+        arr = []
+        while matches = /^ (?:for|in|on) ([^"]+?)(?: with (?:key|id))? "([^"]*)"/.match(levels)
+            levels = levels[matches[0].length, levels.length]
+            item = {
+                resource: get_resource(matches[1]),
+                id: matches[2]
+            }
+            item[:id] = item[:id].to_i if item[:id].match(/^\d+$/)
+            arr.append(item)
+        end
+        @urls = arr.reverse
+    end
+
+    def url
+        @urls.map{ |l| "#{l[:resource]}/#{l[:id]}/"}.join()
+    end
+
+    def hash
+        hash = {}
+        @urls.each{ |l| hash[get_parameter("#{get_parameter(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")
+            return {
+                key => last[:id]
+            }
+        end
+        return {}
+    end
+
+    def to_s
+        self.url
+    end
+end

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

@@ -0,0 +1,4 @@
+require 'cucumber-rest-bdd/steps/functional'
+require 'cucumber-rest-bdd/steps/response'
+require 'cucumber-rest-bdd/steps/resource'
+require 'cucumber-rest-bdd/steps/status'

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

@@ -0,0 +1,32 @@
+require 'cucumber-api/response'
+require 'cucumber-api/steps'
+require 'cucumber-rest-bdd/types'
+
+Then(/^the response (?:should have|has a|has the) header "([^"]*)" with (?:a |the )?value "([^"]*)"$/) 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)
+    exists = @response.raw_headers[p_header].include? p_value
+    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|
+  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
+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|
+    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|
+    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

@@ -0,0 +1,152 @@
+require 'cucumber-api/response'
+require 'cucumber-api/steps'
+require 'active_support/inflector'
+require 'cucumber-rest-bdd/url'
+require 'cucumber-rest-bdd/types'
+require 'cucumber-rest-bdd/level'
+require 'cucumber-rest-bdd/hash'
+require 'easy_diff'
+
+Given(/^I am a client$/) do
+    steps %Q{
+      Given I send "application/json" and accept JSON
+    }
+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}")
+    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}")
+    unless params.raw.empty?
+        query = params.raw.map{|key, value| %/#{get_parameter(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}")
+    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}")
+    unless params.raw.empty?
+        query = params.raw.map{|key, value| %/#{get_parameter(key)}=#{resolve(value)}/}.join("&")
+        url = "#{url}?#{query}"
+    end
+    steps %Q{When I send a GET request to "#{url}"}
+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}")
+    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)
+    if ENV['set_parent_id'] == 'true'
+        json = MultiJson.dump(level.last_hash)
+        steps %Q{
+            When I set JSON request body to:
+            """
+            #{json}
+            """
+        }
+    end
+    url = get_url("#{level.url}#{resource_name}")
+    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)
+    request_hash = get_attributes(params.hashes)
+    level = Level.new(levels)
+    request_hash = request_hash.merge(level.last_hash) if ENV['set_parent_id'] == 'true'
+    json = MultiJson.dump(request_hash)
+    url = get_url("#{level.url}#{resource_name}")
+    steps %Q{
+        When I set JSON request body to:
+            """
+            #{json}
+            """
+        And I send a POST request to "#{url}"
+    }
+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)
+    if ENV['set_parent_id'] == 'true'
+        json = MultiJson.dump(level.last_hash)
+        steps %Q{
+            When I set JSON request body to:
+            """
+            #{json}
+            """
+        }
+    end
+    url = get_url("#{level.url}#{resource_name}/#{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)
+    request_hash = get_attributes(params.hashes)
+    level = Level.new(levels)
+    request_hash = request_hash.merge(level.last_hash) if ENV['set_parent_id'] == 'true'
+    json = MultiJson.dump(request_hash)
+    url = get_url("#{level.url}#{resource_name}/#{id}")
+    steps %Q{
+        When I set JSON request body to:
+            """
+            #{json}
+            """
+        And I send a PUT request to "#{url}"
+    }
+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)
+    request_hash = get_attributes(params.hashes)
+    json = MultiJson.dump(request_hash)
+    url = get_url("#{Level.new(levels).url}#{resource_name}/#{id}")
+    steps %Q{
+        When I set JSON request body to:
+            """
+            #{json}
+            """
+        And I send a PATCH request to "#{url}"
+    }
+end
+
+# value capture
+
+When(/^I save (?:attribute )?"([^"]+)"$/) do |attribute|
+    steps %Q{When I grab "#{get_json_path(attribute)}" as "#{attribute}"}
+end
+
+When(/^I save (?:attribute )?"([^"]+)" to "([^"]+)"$/) do |attribute, ref|
+    steps %Q{When I grab "#{get_json_path(attribute)}" as "#{ref}"}
+end

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

@@ -0,0 +1,229 @@
+require 'cucumber-rest-bdd/steps/resource'
+require 'cucumber-rest-bdd/types'
+
+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|
+    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'
+    end
+    validate_value(names, 'string', regex)
+end
+
+Then(/^the response #{HAVE_SYNONYM} ([\w\s]+|`[^`]*`) of type (\w+) that matches "(.+)"$/) do |names, type, regex|
+    validate_value(names, 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?
+end
+
+Then(/^the response is a list (?:of|containing) (#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) .*?$/) do |count_mod, count|
+    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)
+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|
+    expected = get_attributes(attributes.hashes)
+    groups = nesting
+    grouping = get_grouping(groups)
+    grouping.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)
+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|
+    expected = value
+    groups = nesting
+    grouping = get_grouping(groups)
+    grouping.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)
+end
+
+Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:[\w\s]+|`[^`]*`)\s?)+)$/) do |nesting|
+    groups = nesting
+    grouping = get_grouping(groups)
+    grouping.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, {})
+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|
+    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
+    })
+    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|
+    groups = nesting
+    grouping = get_grouping(groups)
+    grouping.push({
+        root: true,
+        type: 'multiple',
+        count: count.to_i,
+        count_mod: 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|
+    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'
+    })
+    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(/^(#{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|
+    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: count.to_i,
+        count_mod: 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 = /^#{HAVE_SYNONYM} (?:a|an|(?:(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+))) ([\w\s]+|`[^`]*`)\s?+/.match(nesting)
+        nesting = nesting[matches[0].length, 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)
+    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_parameter(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])]
+        matched = child_data.select { |item| nest_match_attributes(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
+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_parameter(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
+        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
+end

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

@@ -0,0 +1,63 @@
+require 'cucumber-api/response'
+require 'cucumber-api/steps'
+
+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
+    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
+    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
+    steps %Q{Then the response status should be "201"}
+end
+
+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
+  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
+    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
+    steps %Q{Then the response status should be "401"}
+end
+
+Then(/^(?:it|the request) fail(?:s|ed) because (?:.+) (?:is|was) forbidden$/) do
+    steps %Q{Then the response status should be "403"}
+end
+
+Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not found$/) do
+    steps %Q{Then the response status should be "404"}
+end
+
+Then(/^(?:it|the request) fail(?:s|ed) because it (?: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
+    steps %Q{Then the response status should be "409"}
+end
+
+Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was|has) gone$/) do
+    steps %Q{Then the response status should be "410"}
+end
+
+Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not implemented$/) do
+    steps %Q{Then the response status should be "501"}
+end

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

@@ -0,0 +1,143 @@
+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)}
+
+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
+
+module Enum; end
+class String; include Enum; end
+
+class String
+  def to_type(type)
+    # cannot use 'case type' which checks for instances of a type rather than type equality
+    if type == Boolean then !(self =~ /true|yes/i).nil?
+    elsif type == Enum then self.upcase.tr(" ", "_")
+    elsif type == Float then self.to_f
+    elsif type == Integer then self.to_i
+    elsif type == NilClass then nil
+    else self
+    end
+  end
+end
+
+def parse_type(type)
+    replacements = {
+        /^numeric$/i => 'integer',
+        /^int$/i => 'integer',
+        /^long$/i => 'integer',
+        /^number$/i => 'integer',
+        /^decimal$/i => 'float',
+        /^double$/i => 'float',
+        /^bool$/i => 'boolean',
+        /^null$/i => 'nil_class',
+        /^nil$/i => 'nil_class',
+        /^text$/i => 'string'
+    }
+    type.tr(' ', '_')
+    replacements.each { |k,v| type.gsub!(k, v) }
+    type
+end
+
+def get_resource(name)
+    name = name.parameterize
+    name = (ENV.has_key?('resource_single') && ENV['resource_single'] == 'true') ? name.singularize : name.pluralize
+    return name
+end
+
+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_parameters(names).join('.')}"
+end
+
+def get_parameters(names)
+    return names.split(':').map { |n| get_parameter(n) }
+end
+
+def get_parameter(name)
+    if name[0] == '`' && name[-1] == '`'
+        name = name[1..-2]
+    else
+        separator = ENV.has_key?('field_separator') ? ENV['field_separator'] : '_'
+        name = name.parameterize(separator: separator)
+        name = name.camelize(:lower) if (ENV.has_key?('field_camel') && ENV['field_camel'] == 'true')
+    end
+    return name
+end
+
+def get_attributes(hashes)
+    attributes = hashes.each_with_object({}) do |row, hash|
+      name, value, type = row["attribute"], row["value"], row["type"]
+      value = resolve(value)
+      value.gsub!(/\\n/, "\n")
+      type = parse_type(type)
+      names = get_parameters(name)
+      new_hash = names.reverse.inject(value.to_type(type.camelize.constantize)) { |a, n| { n => a } }
+      hash.deep_merge!(new_hash)
+    end
+end

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

@@ -0,0 +1,4 @@
+def get_url(path)
+    raise %/Please set an 'endpoint' environment variable provided with the url of the api/ if !ENV.has_key?('endpoint')
+    url = %/#{ENV['endpoint']}#{path}/
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: alinta-cucumber-rest-bdd
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+platform: ruby
+authors:
+- Harry Bragg
+- Matt Hosking
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: easy_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Series of BDD cucumber rules for testing API endpoints
+email:
+- harry.bragg@graze.com
+- Matt.Hosking@alintaenergy.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cucumber-rest-bdd.rb
+- lib/cucumber-rest-bdd/hash.rb
+- lib/cucumber-rest-bdd/level.rb
+- lib/cucumber-rest-bdd/steps.rb
+- lib/cucumber-rest-bdd/steps/functional.rb
+- lib/cucumber-rest-bdd/steps/resource.rb
+- lib/cucumber-rest-bdd/steps/response.rb
+- lib/cucumber-rest-bdd/steps/status.rb
+- lib/cucumber-rest-bdd/types.rb
+- lib/cucumber-rest-bdd/url.rb
+homepage: https://github.com/AlintaEnergy/cucumber-rest-bdd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: BDD Rest API specifics for cucumber
+test_files: []