cucumber-rest-bdd 0.6.0 → 0.6.1

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

@@ -3,25 +3,50 @@ require 'cucumber-api/steps'
 require 'cucumber-rest-bdd/types'
 require 'cucumber-rest-bdd/list'
 
-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)
-    exists = @response.raw_headers[p_header].include? p_value
-    raise %/Expect #{p_value} in #{header} (#{p_header})\n#{@response.raw_headers.inspect}/ if !exists
+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
+  unless @response.raw_headers.key?(p_header)
+    raise %(Required header: #{header} not found
+          #{@response.raw_headers.inspect})
+  end
+  unless @response.raw_headers[p_header].include? p_value
+    raise %/Expect #{p_value} in #{header} (#{p_header})
+          #{@response.raw_headers.inspect}/
+  end
 end
 
-Then("the JSON response should have {string} of type array #{HAVE_ALTERNATION} {list_has_count} entry/entries") do |json_path, list_comparison|
+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 #{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)
+  unless list_comparison.compare(list.count)
+    raise %(Expected #{list_comparison.to_string} entries in array for path
+          '#{json_path}', found: #{list.count}
+          #{@response.to_json_s})
+  end
 end
 
-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?
+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
+  if (Regexp.new(regex) =~ value).nil?
+    raise %(Expected #{json_path} value '#{value}' to match regex: #{regex}
+          #{@response.to_json_s})
+  end
 end
 
-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?
+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'
+  unless value.nil?
+    raise %(Expected #{json_path} to be nil, was: #{value.class}
+          #{@response.to_json_s})
+  end
 end

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

@@ -7,139 +7,161 @@ require 'cucumber-rest-bdd/level'
 require 'cucumber-rest-bdd/hash'
 require 'easy_diff'
 
-GET_TYPES = %{(?:an?(?! list)|the)}%
-WITH_ID = %{(?: with (?:key|id))? "([^"]*)"}%
+GET_TYPES = '(?:an?(?! list)|the)'.freeze
+WITH_ID = '(?: with (?:key|id))? "([^"]*)"'.freeze
 
-Given("I am a client") do
-    steps %Q{
-      Given I send "application/json" and accept JSON
-    }
+Given('I am a client') do
+  steps %(Given I send "application/json" and accept JSON)
 end
 
-Given("I am issuing requests for {resource_name}") do |resource|
-    @urlbasepath = resource
+Given('I am issuing requests for {resource_name}') do |resource|
+  @urlbasepath = resource
 end
 
 # GET
 
-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}"}
+When(
+  'I request the {resource_name} (with key/id ){string}{levels}'
+) do |resource, id, levels|
+  url = get_url("#{levels.url}#{resource}/#{id}")
+  steps %(When I send a GET request to "#{url}")
 end
 
-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}"
-    end
-    steps %Q{When I send a GET request to "#{url}"}
+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 { |k, v| %(#{parse_field(k)}=#{resolve(v)}) }
+                  .join('&')
+    url = "#{url}?#{query}"
+  end
+  steps %(When I send a GET request to "#{url}")
 end
 
-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}"}
+When('I request a list of {resource_name}{levels}') do |resource, levels|
+  url = get_url("#{levels.url}#{resource}")
+  steps %(When I send a GET request to "#{url}")
 end
 
-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}"
-    end
-    steps %Q{When I send a GET request to "#{url}"}
+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 { |k, v| %(#{parse_field(k)}=#{resolve(v)}) }
+                  .join('&')
+    url = "#{url}?#{query}"
+  end
+  steps %(When I send a GET request to "#{url}")
 end
 
 # DELETE
 
-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}"}
+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 %(When I send a DELETE request to "#{url}")
 end
 
 # POST
 
-When("I request to create a/an/the {resource_name}{levels}") do |resource, levels|
-    if ENV['set_parent_id'] == 'true'
-        json = MultiJson.dump(levels.last_hash)
-        steps %Q{
-            When I set JSON request body to:
-            """
-            #{json}
-            """
-        }
-    end
-    url = get_url("#{levels.url}#{resource}")
-    steps %Q{When I send a POST request to "#{url}"}
+When(
+  'I request to create a/an/the {resource_name}{levels}'
+) do |resource, levels|
+  if ENV['set_parent_id'] == 'true'
+    json = MultiJson.dump(levels.last_hash)
+    steps %(
+          When I set JSON request body to:
+          """
+          #{json}
+          """
+    )
+  end
+  url = get_url("#{levels.url}#{resource}")
+  steps %(When I send a POST request to "#{url}")
 end
 
-When("I request to create a/an/the {resource_name}{levels} with:") do |resource, levels, params|
-    request_hash = get_attributes(params.hashes)
-    request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
-    json = MultiJson.dump(request_hash)
-    url = get_url("#{levels.url}#{resource}")
-    steps %Q{
+When(
+  'I request to create a/an/the {resource_name}{levels} with:'
+) do |resource, levels, params|
+  request_hash = parse_attributes(params.hashes)
+  request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
+  json = MultiJson.dump(request_hash)
+  url = get_url("#{levels.url}#{resource}")
+  steps %(
         When I set JSON request body to:
             """
             #{json}
             """
         And I send a POST request to "#{url}"
-    }
+  )
 end
 
 # PUT
 
-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(levels.last_hash)
-        steps %Q{
-            When I set JSON request body to:
-            """
-            #{json}
-            """
-        }
-    end
-    url = get_url("#{levels.url}#{resource}/#{id}")
-    steps %Q{
+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(levels.last_hash)
+    steps %(
+          When I set JSON request body to:
+          """
+          #{json}
+          """
+    )
+  end
+  url = get_url("#{levels.url}#{resource}/#{id}")
+  steps %(
         When I send a PUT request to "#{url}"
-    }
+  )
 end
 
-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)
-    request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
-    json = MultiJson.dump(request_hash)
-    url = get_url("#{levels.url}#{resource}/#{id}")
-    steps %Q{
+When(
+  'I request to replace/set a/an/the {resource_name} '\
+  '(with key/id ){string}{levels} with:'
+) do |resource, id, levels, params|
+  request_hash = parse_attributes(params.hashes)
+  request_hash = request_hash.merge(levels.last_hash) if ENV['set_parent_id'] == 'true'
+  json = MultiJson.dump(request_hash)
+  url = get_url("#{levels.url}#{resource}/#{id}")
+  steps %(
         When I set JSON request body to:
             """
             #{json}
             """
         And I send a PUT request to "#{url}"
-    }
+  )
 end
 
 # PATCH
 
-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("#{levels.url}#{resource}/#{id}")
-    steps %Q{
+When(
+  'I request to modify/update a/an/the {resource_name} '\
+  '(with key/id ){string}{levels} with:'
+) do |resource, id, levels, params|
+  request_hash = parse_attributes(params.hashes)
+  json = MultiJson.dump(request_hash)
+  url = get_url("#{levels.url}#{resource}/#{id}")
+  steps %(
         When I set JSON request body to:
             """
             #{json}
             """
         And I send a PATCH request to "#{url}"
-    }
+  )
 end
 
 # value capture
 
-When("I save (attribute ){string}") do |attribute|
-    steps %Q{When I grab "#{get_json_path(attribute)}" as "#{attribute}"}
+When('I save (attribute ){string}') do |attribute|
+  steps %(When I grab "#{json_path(attribute)}" as "#{attribute}")
 end
 
-When("I save (attribute ){string} to {string}") do |attribute, ref|
-    steps %Q{When I grab "#{get_json_path(attribute)}" as "#{ref}"}
+When('I save (attribute ){string} to {string}') do |attribute, ref|
+  steps %(When I grab "#{json_path(attribute)}" as "#{ref}")
 end

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

@@ -4,142 +4,185 @@ require 'cucumber-rest-bdd/list'
 require 'cucumber-rest-bdd/data'
 
 ParameterType(
-    name: 'item_name',
-    regexp: /([\w\s]+?)/,
-    transformer: -> (s) { s },
-    use_for_snippets: false
+  name: 'item_name',
+  regexp: /([\w\s]+?)/,
+  transformer: ->(s) { s },
+  use_for_snippets: false
 )
 
-Then("print the response") do
-    puts %/The response:\n#{@response.to_json_s}/
+Then('print the response') do
+  puts %(The response:\n#{@response.to_json_s})
 end
 
 # SIMPLE VALUE RESPONSE
 
 # response is a string with the specified value
-Then("the response #{HAVE_ALTERNATION} (the )(following )value {string}") do |value|
-    expected = value
-    data = @response.get get_root_data_key()
-    raise %/Response did not match: #{expected}\n#{data}/ if data.empty? || !data.include?(expected)
+Then(
+  "the response #{HAVE_ALTERNATION} (the )(following )value {string}"
+) do |value|
+  expected = value
+  data = @response.get root_data_key
+  raise %(Response did not match: #{expected}\n#{data}) if data.empty? || !data.include?(expected)
 end
 
 # OBJECT RESPONSE
 
 # response is an object with a field that is validated by a pre-defined regex
-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 nil
-    end
-
-    type = 'string' if regex.nil?
-    value = field.get_value(@response, type)
-    field.validate_value(@response, value.to_s, Regexp.new(regex))
+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
+          end
+  type = 'string' if regex.nil?
+  value = field.get_value(@response, type)
+  field.validate_value(@response, value.to_s, Regexp.new(regex))
 end
 
 # response is an object with a field that is validated by a custom regex
 Then("the response #{HAVE_ALTERNATION} {field_name} of type {word} that matches {string}") do |field, type, regex|
-    value = field.get_value(@response, type)
-    field.validate_value(@response, value.to_s, Regexp.new(regex))
+  value = field.get_value(@response, type)
+  field.validate_value(@response, value.to_s, Regexp.new(regex))
 end
 
 # response is an object with specific attributes having defined values
 Then("the response #{HAVE_ALTERNATION} (the )(following )attributes:") do |attributes|
-    expected = get_attributes(attributes.hashes)
-    data = @response.get get_root_data_key()
-    raise %/Response did not match:\n#{expected.inspect}\n#{data}/ if data.empty? || !data.deep_include?(expected)
+  expected = parse_attributes(attributes.hashes)
+  data = @response.get root_data_key
+  raise %(Response did not match:\n#{expected.inspect}\n#{data}) if data.empty? || !data.deep_include?(expected)
 end
 
 # ARRAY RESPONSE
 
 # response is an array of objects
-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 #{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)
+Then('the response is a list of/containing {list_has_count} {field_name}') do |list_comparison, _item|
+  list = @response.get_as_type root_data_key, 'array'
+  unless list_comparison.compare(list.count)
+    raise %(Expected #{list_comparison.to_string} items in array for path '#{root_data_key}', found: #{list.count}
+          #{@response.to_json_s})
+  end
 end
 
 # response is an array of objects where the specified number of entries match the defined data attributes
-Then("(the response is a list with ){list_has_count} {word} #{HAVE_ALTERNATION} (the )(following )(data )attributes:") do |list_comparison, item_name, attributes|
-    expected = get_attributes(attributes.hashes)
-    data = @response.get_as_type get_root_data_key(), 'array'
-    matched = data.select { |item| !item.empty? && item.deep_include?(expected) }
-    raise %/Expected #{list_comparison.to_string()} items in array that matched:\n#{expected.inspect}\n#{data}/ if !list_comparison.compare(matched.count)
+Then(
+  '(the response is a list with/of/containing ){list_has_count} {word} '\
+  "#{HAVE_ALTERNATION} (the )(following )(data )attributes:"
+) do |list_comparison, _item_name, attributes|
+  expected = parse_attributes(attributes.hashes)
+  data = @response.get_as_type root_data_key, 'array'
+  matched = data.select { |item| !item.empty? && item.deep_include?(expected) }
+  unless list_comparison.compare(matched.count)
+    raise %(Expected #{list_comparison.to_string} items in array that matched:\n#{expected.inspect}\n#{data})
+  end
 end
 
 # response is an array of objects where the specified number of entries match the defined data attributes
-Then("(the response is a list with ){list_has_count} {item_name} {list_nesting}") do |list_comparison, item_name, nesting|
-    nesting.push({
-        root: true,
-        type: 'multiple',
-        comparison: list_comparison
-    })
-    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)
+Then(
+  '(the response is a list with/of/containing ){list_has_count} {item_name} {list_nesting}'
+) do |list_comparison, _item_name, nesting|
+  nesting.push(
+    root: true,
+    type: 'multiple',
+    comparison: list_comparison
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, {}, false)
+    raise %(Could not find a match for: #{nesting.match}\n#{@response.to_json_s})
+  end
 end
 
 # response is an array of objects where the specified number of entries match the defined data attributes
-Then("(the response is a list with ){list_has_count} {item_name} {list_nesting} #{HAVE_ALTERNATION} (the )(following )(data )attributes:") do |list_comparison, item_name, nesting, attributes|
-    expected = get_attributes(attributes.hashes)
-    nesting.push({
-        root: true,
-        type: 'multiple',
-        comparison: list_comparison
-    })
-    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)
+Then(
+  '(the response is a list with/of/containing ){list_has_count} {item_name} {list_nesting} '\
+  "#{HAVE_ALTERNATION} (the )(following )(data )attributes:"
+) do |list_comparison, _item_name, nesting, attributes|
+  expected = parse_attributes(attributes.hashes)
+  nesting.push(
+    root: true,
+    type: 'multiple',
+    comparison: list_comparison
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, false)
+    raise %(Could not find a match for: #{nesting.match}\n#{expected.inspect}\n#{@response.to_json_s})
+  end
 end
 
 # response is an array of objects where the specified number of entries match the defined string value
-Then("(the response is a list with ){list_has_count} {item_name} having/containing/with (the )(following )value {string}") do |list_comparison, item_name, value|
-    expected = value
-    data = @response.get_as_type get_root_data_key(), 'array'
-    matched = data.select { |item| !item.empty? && item.include?(expected) }
-    raise %/Expected #{list_comparison.to_string()} items in array that matched:\n#{expected}\n#{data}/ if !list_comparison.compare(matched.count)
+Then(
+  '(the response is a list with/of/containing ){list_has_count} {item_name} '\
+  'having/containing/with (the )(following )value {string}'
+) do |list_comparison, _item_name, value|
+  expected = value
+  data = @response.get_as_type root_data_key, 'array'
+  matched = data.select { |item| !item.empty? && item.include?(expected) }
+  unless list_comparison.compare(matched.count)
+    raise %(Expected #{list_comparison.to_string} items in array that matched:\n#{expected}\n#{data})
+  end
 end
 
 # response is an array of objects where the specified number of entries match the defined string value
-Then("(the response is a list with ){list_has_count} {item_name} {list_nesting} #{HAVE_ALTERNATION} (the )(following )value {string}") do |list_comparison, item_name, nesting, value|
-    expected = value
-    nesting.push({
-        root: true,
-        type: 'multiple',
-        comparison: list_comparison
-    })
-    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)
+Then(
+  '(the response is a list with/of/containing ){list_has_count} {item_name} {list_nesting} '\
+  "#{HAVE_ALTERNATION} (the )(following )value {string}"
+) do |list_comparison, _item_name, nesting, value|
+  expected = value
+  nesting.push(
+    root: true,
+    type: 'multiple',
+    comparison: list_comparison
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, true)
+    raise %(Could not find a match for: #{nesting.match}\n#{expected}\n#{@response.to_json_s})
+  end
 end
 
 # HIERARCHICAL RESPONSE
 
-# response has the specified hierarchy of objects / lists where the specified number of leaf items match the defined data attributes
+# response has the specified hierarchy of objects / lists where the
+# specified number of leaf items match the defined data attributes
 Then("the response {list_nesting} #{HAVE_ALTERNATION} (the )(following )attributes:") do |nesting, attributes|
-    expected = get_attributes(attributes.hashes)
-    nesting.push({
-        root: true,
-        type: 'single'
-    })
-    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)
+  expected = parse_attributes(attributes.hashes)
+  nesting.push(
+    root: true,
+    type: 'single'
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, false)
+    raise %(
+      Could not find a match for: #{nesting.match}
+      with: #{expected.inspect}
+      in: #{data}
+      #{@response.to_json_s}
+    )
+  end
 end
 
-# response has the specified hierarchy of objects / lists where the specified number of leaf items match the defined string value
+# response has the specified hierarchy of objects / lists where the
+# specified number of leaf items match the defined string value
 Then("the response {list_nesting} #{HAVE_ALTERNATION} (the )(following )value {string}") do |nesting, value|
-    expected = value
-    nesting.push({
-        root: true,
-        type: 'single'
-    })
-    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)
+  expected = value
+  nesting.push(
+    root: true,
+    type: 'single'
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, true)
+    raise %(Could not find a match for: #{nesting.match}\n#{expected}\n#{@response.to_json_s})
+  end
 end
 
-# response has the specified hierarchy of objects / lists where the specified number of leaf items is as expected only (no data checked)
-Then("the response {list_nesting}") do |nesting|
-    nesting.push({
-        root: true,
-        type: 'single'
-    })
-    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)
+# response has the specified hierarchy of objects / lists where the
+# specified number of leaf items is as expected only (no data checked)
+Then('the response {list_nesting}') do |nesting|
+  nesting.push(
+    root: true,
+    type: 'single'
+  )
+  data = @response.get get_key(nesting.grouping)
+  if data.empty? || !nest_match_attributes(data, nesting.grouping, {}, false)
+    raise %(Could not find a match for: #{nesting.match}\n#{@response.to_json_s})
+  end
 end