cucumber-rest-bdd 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d93393a0b495acb4bed9d413ce6025fad8a6df7985d63045ef5f47c5b6090aa4
-  data.tar.gz: 5739f55f3e47882cccd85430578441789b019e2e5a9119ec95882db47396041f
+  metadata.gz: 51002c5c754272c8adb1452953d14ffba1a92141d11cf07b3a817c098b82bf7d
+  data.tar.gz: 519573e43b60171abb392429f9872e32c9377b66470dc51043ea7af6fbb1c068
 SHA512:
-  metadata.gz: fc4804e246337e0f8c943e4bba0cab89b9dcfd02833a893e1723644521b729024cc39ef1393ef6a06c5aca2ff0b4585f010ec005fbbc02aa20bd47adebb22282
-  data.tar.gz: 769fcc221501222f5af0b240193ba70c20c882976fe11f366a72c6d81b0525362ec7bcf4ae1bfce459f5413e6fb6bc2ca28b17bd1e0f69ae5ade5e13a8d7fa5f
+  metadata.gz: 179a7d97d8cf964fbc123ab72eb71e12111054e1bde7f9c05a443b3a191beb61d4142447980307400eea099f2140db3a10fd91105c650a0c0a0811cd5854c6f7
+  data.tar.gz: 48a01c37577e37bf9992bbadef807e10982ddfcc21b204278b11d9d9d5c8592bfd7a85fc27d41e757a2ab2cc50de3ead89ba9e491b7205a720cd531554996fd1

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

@@ -2,51 +2,77 @@ 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
+  error_key = ENV['error_key']
+  if error_key && !error_key.empty? && grouping.count > 1 && grouping[-2][:key].singularize == error_key
+    '$.'
+  else
+    root_data_key
+  end
 end
 
-# top level has 2 children with an item containing at most three fish with attributes:
+# 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}]
+# 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
+# returns true if the expected data is contained within the data based on the
+# nesting information
+def nest_match_attributes(data, nesting, expected, match_value)
+  # puts data.inspect, nesting.inspect, expected.inspect, match_value.inspect
+  return false unless data
+  return data.deep_include?(expected) if !match_value && nesting.empty?
+  return data.include?(expected) if match_value && nesting.empty?
+
+  local_nesting = nesting.dup
+  level = local_nesting.pop
+  child_data = get_child_data(level, data)
+
+  nest_get_match(level, child_data, local_nesting, expected, match_value)
+end
+
+# nest_get_match returns true if the child data matches the expected data
+def nest_get_match(level, child_data, local_nesting, expected, match_value)
+  case level[:type]
+  when 'single' then
+    nest_match_attributes(child_data, local_nesting, expected, match_value)
+  when 'multiple' then
+    child_check(level, child_data, local_nesting, expected, match_value)
+  when 'list' then
+    child_is_list(level, child_data)
+  else
+    raise %(Unknown nested data type: #{level[:type]})
+  end
+end
+
+# check that all the children in child_data match the expected values
+def child_check(level, child_data, local_nesting, expected, match_value)
+  matched = child_data.select do |item|
+    nest_match_attributes(item, local_nesting, expected, match_value)
+  end
+  level[:comparison].compare(matched.count)
+end
+
+# is the child a list, and does it match the comparison?
+def child_is_list(level, child_data)
+  child_data.is_a?(Array) \
+  && (!level.key?(:comparison) \
+    || level[:comparison].compare(child_data.count))
 end
 
+# parse the field and get the data for a given child
 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
+  return data.dup if level[:root]
+  level_key = case level[:type]
+              when 'single' then parse_field(level[:key])
+              when 'multiple', 'list' then parse_list_field(level[:key])
+              end
+  raise %(Key not found: #{level[:key]} as #{level_key} in #{data}) \
+    if data.is_a?(Array) || !data[level_key]
+  data[level_key]
 end

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

@@ -1,9 +1,10 @@
 require 'easy_diff'
 
+# Adds deep_include? to the Hash class
 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
+  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

@@ -2,51 +2,52 @@ require 'cucumber-rest-bdd/types'
 require 'active_support/inflector'
 
 ParameterType(
-    name: 'levels',
-    regexp: /((?: (?:for|in|on) (?:#{RESOURCE_NAME_SYNONYM})(?: with (?:key|id))? "[^"]*")*)/,
-    transformer: -> (levels) { Level.new(levels) },
-    use_for_snippets: false
+  name: 'levels',
+  regexp: /((?: (?:for|in|on) (?:#{RESOURCE_NAME_SYNONYM})(?: with (?:key|id))? "[^"]*")*)/,
+  transformer: ->(levels) { Level.new(levels) },
+  use_for_snippets: false
 )
 
+# Helper class when creating nested resources
 class Level
-    @urls = []
+  @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
+  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] =~ /^\d+$/
+      arr.append(item)
     end
+    @urls = arr.reverse
+  end
 
-    def url
-        @urls.map{ |l| "#{l[:resource]}/#{l[:id]}/"}.join()
-    end
+  def url
+    @urls.map { |l| "#{l[:resource]}/#{l[:id]}/" }.join
+  end
 
-    def hash
-        hash = {}
-        @urls.each{ |l| hash[get_field("#{get_field(l[:resource]).singularize}_id")] = l[:id] }
-        hash
+  def hash
+    hash = {}
+    @urls.each do |l|
+      hash[parse_field("#{parse_field(l[:resource]).singularize}_id")] = l[:id]
     end
+    hash
+  end
 
-    def last_hash
-        last = @urls.last
-        if !last.nil?
-            key = get_field("#{get_field(last[:resource]).singularize}_id")
-            return {
-                key => last[:id]
-            }
-        end
-        return {}
+  def last_hash
+    last = @urls.last
+    unless last.nil?
+      key = parse_field("#{parse_field(last[:resource]).singularize}_id")
+      return {
+        key => last[:id]
+      }
     end
+    {}
+  end
 
-    def to_s
-        self.url
-    end
+  def to_s
+    url
+  end
 end

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

@@ -1,144 +1,156 @@
 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}
+FEWER_MORE_THAN_SYNONYM = '(?:fewer|less|more)\sthan|at\s(?:least|most)'.freeze
+INT_AS_WORDS_SYNONYM = 'zero|one|two|three|four|five|six|seven|eight|nine|ten'
+                       .freeze
 
 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
+  name: 'list_has_count',
+  regexp: /a|an|(?:(?:#{FEWER_MORE_THAN_SYNONYM})\s+)?(?:#{INT_AS_WORDS_SYNONYM}|\d+)/,
+  transformer: lambda { |match|
+    matches = /(?:(#{FEWER_MORE_THAN_SYNONYM})\s+)?
+              (#{INT_AS_WORDS_SYNONYM}|\d+)/x.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
+  name: 'list_nesting',
+  # rubocop:disable Metrics/LineLength
+  regexp: /(?:(?:#{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*)+/,
+  # rubocop:enable Metrics/LineLength
+  transformer: ->(match) { ListNesting.new(match) },
+  use_for_snippets: false
 )
 
+# Handle many children within objects or lists
 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
-                    }
+  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
+
+    minimal_list = /(?:#{HAVE_ALTERNATION.split('/').join('|')})?\s*
+                   (?:(a\slist\sof)\s+)?(?:a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})
+                   \s+)?(#{INT_AS_WORDS_SYNONYM}|\d+))\s+
+                   (#{FIELD_NAME_SYNONYM})/x
+    maximal_list = /(?:#{HAVE_ALTERNATION.split('/').join('|')})?\s*
+                   (?:(a\slist\sof)\s+)?(?:a|an|(?:(#{FEWER_MORE_THAN_SYNONYM})
+                   \s+)?(#{INT_AS_WORDS_SYNONYM}|\d+))\s+
+                   (#{MAXIMAL_FIELD_NAME_SYNONYM})/x
+    while (matches = minimal_list.match(nesting))
+      next_matches = minimal_list.match(nesting[matches.end(0), nesting.length])
+      to_match = if next_matches.nil?
+                   nesting
+                 else
+                   nesting[0, matches.end(0) + next_matches.begin(0)]
+                 end
+      matches = maximal_list.match(to_match)
+      nesting = nesting[matches.end(0), nesting.length]
+
+      level = if matches[1].nil?
+                if matches[3].nil?
+                  {
+                    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',
+                  {
+                    type: 'multiple',
                     key: matches[4],
                     comparison: ListCountComparison.new(matches[2], matches[3]),
                     root: false
+                  }
+                end
+              else
+                {
+                  type: 'list',
+                  key: matches[4],
+                  comparison: ListCountComparison.new(matches[2], matches[3]),
+                  root: false
                 }
-            end
-            grouping.push(level)
-        end
-        @grouping = grouping.reverse
+              end
+      grouping.push(level)
     end
+    @grouping = grouping.reverse
+  end
 
-    def push(node)
-        @grouping.push(node)
-    end
+  def push(node)
+    @grouping.push(node)
+  end
 
-    def match
-        return @match
-    end
+  attr_reader :match
 
-    def grouping
-        @grouping
-    end
+  attr_reader :grouping
 end
 
+# Store a value and a comparison operator to determine if a provided number
+# validates against it
 class ListCountComparison
-
-    def initialize(type, amount)
-        @type = type.nil? ? CMP_EQUALS : to_compare(type)
-        @amount = amount.nil? ? 1 : to_num(amount)
+  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
-
-    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
+
+  attr_reader :type
+
+  def amount
+    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 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
+  def to_string
+    compare_to_string + ' ' + @amount.to_s
+  end
 end
 
-CMP_LESS_THAN = '<'
-CMP_MORE_THAN = '>'
-CMP_AT_LEAST = '>='
-CMP_AT_MOST = '<='
-CMP_EQUALS = '='
+CMP_LESS_THAN = '<'.freeze
+CMP_MORE_THAN = '>'.freeze
+CMP_AT_LEAST = '>='.freeze
+CMP_AT_MOST = '<='.freeze
+CMP_EQUALS = '='.freeze
 
-# take a number modifier string (fewer than, less than, etc) and return an operator '<', etc
+# 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
+  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
+  if num =~ /^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/
+    return %w[zero one two three four five six seven eight nine ten].index(num)
+  end
+  num.to_i
 end