pact-support 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e910cf32ae5812de2e20eb59b3e5ca000f4bb993
-  data.tar.gz: c075489026ea2c5b501c673d085bf0ffe27434a1
+  metadata.gz: d30e4cc422b899773c2917361c59ad211792f922
+  data.tar.gz: e20e3a998c5ba7f018b615567718193e009bcd26
 SHA512:
-  metadata.gz: 06989f174ace83fa1ccccf4ea8bdad96d188a0899706aef0f7bed147eb86682644ed08457f6974a01e2e5abfd425c01f0787d2bbd4f73e9d9258cea1a3c1d7b7
-  data.tar.gz: 7d3bb57ae30029fd219bf1f54fc1fe7f471940365f4431f5f11b20d18ae67470729a648a41191d1daf799f63b78485ce913d22497a776b8a799fdbecc4823739
+  metadata.gz: 3e8e7a5188f514b4c5b47de5e3a5005f863544b1625a8bf932a84ac6a700b8d5926ef87c7bfd35dbe56b7c3579ba7793d9704a64f8eae4592c73b2408696316c
+  data.tar.gz: 095ec74b09b3ffa4bce8212d495eb88d93ee69723997d58c2d836be356493fed9bf1b17f0a4e5150f81845cdc67fdf8639598ca5ea9c1e0f9e982bfd5627bfde

data/CHANGELOG.md

@@ -2,6 +2,18 @@ Do this to generate your change history
 
   git log --pretty=format:'  * %h - %s (%an, %ad)'
 
+### 0.3.0 (13 Februrary 2015)
+
+* 4e29277 - Create a public API for extracting matching rules for pact-mock_service to use. (Beth Skurrie, Fri Feb 13 15:35:14 2015 +1100)
+* 17ffb7e - Improve Pact::Term error message when value does not match regexp. (Beth Skurrie, Thu Feb 12 15:35:28 2015 +1100)
+* ad0b37b - Added logic to convert Term and SomethingLike to v2 matching rules (Beth Skurrie, Thu Feb 12 14:55:34 2015 +1100)
+* cc15c4d - Renamed <index not found> to <item not found>, and <index not to exist> to <item not to exist> (Beth Skurrie, Thu Feb 12 11:47:53 2015 +1100)
+* 1b65c46 - Change "no difference here" to ... in unix diff output (Beth Skurrie, Thu Feb 12 11:43:58 2015 +1100)
+* 3cb5b30 - Fix duplicate "no difference here!" in diff when actual array has more items than the expected (Beth Skurrie, Thu Feb 12 11:30:58 2015 +1100)
+* a9da567 - Changed display of NoDiffAtIndex (Beth Skurrie, Tue Dec 23 15:16:49 2014 +1100)
+* f9619e6 - Log warning message when unsupported rules are detected (Beth Skurrie, Tue Dec 23 14:42:22 2014 +1100)
+* 9875bef - Added support for v2 regular expression matching in provider (Beth Skurrie, Tue Dec 23 14:15:00 2014 +1100)
+
 ### 0.2.1 (21 January 2015)
 
 * 4e26c75 - Ignore HTTP method case when determining if routes match. https://github.com/bethesque/pact-support/issues/3 (Beth, Tue Jan 20 20:15:20 2015 +1100)

data/lib/pact/consumer_contract/interaction.rb

@@ -2,6 +2,7 @@ require 'pact/consumer_contract/request'
 require 'pact/consumer_contract/response'
 require 'pact/symbolize_keys'
 require 'pact/shared/active_support_support'
+require 'pact/matching_rules'
 
 module Pact
    class Interaction
@@ -18,9 +19,11 @@ module Pact
       end
 
       def self.from_hash hash
-        request = Pact::Request::Expected.from_hash(hash['request'])
-        response = Pact::Response.from_hash(hash['response'])
-        new(symbolize_keys(hash).merge({request: request, response: response}))
+        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['requestMatchingRules'])
+        request = Pact::Request::Expected.from_hash(request_hash)
+        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['responseMatchingRules'])
+        response = Pact::Response.from_hash(response_hash)
+        new(symbolize_keys(hash).merge(request: request, response: response))
       end
 
       def to_hash

data/lib/pact/matchers/index_not_found.rb

@@ -4,7 +4,7 @@ module Pact
   class IndexNotFound < Pact::DifferenceIndicator
 
     def to_s
-      "<index not found>"
+      "<item not found>"
     end
 
     def empty?

data/lib/pact/matchers/list_diff_formatter.rb

@@ -31,9 +31,9 @@ module Pact
         when Difference then handle_difference obj, path, descriptions
         when TypeDifference then handle_mismatched_type obj, path, descriptions
         when RegexpDifference then handle_mismatched_regexp obj, path, descriptions
-        when NoDiffIndicator then nil
+        when NoDiffAtIndex then nil
         else
-          raise "Invalid diff, expected Hash, Array, NoDiffIndicator or Difference, found #{obj.class}"
+          raise "Invalid diff, expected Hash, Array, NoDiffAtIndex or Difference, found #{obj.class}"
         end
         descriptions
       end

data/lib/pact/matchers/matchers.rb

@@ -11,13 +11,14 @@ require 'pact/matchers/regexp_difference'
 require 'pact/matchers/type_difference'
 require 'pact/matchers/expected_type'
 require 'pact/matchers/actual_type'
-require 'pact/matchers/no_diff_indicator'
+require 'pact/matchers/no_diff_at_index'
 
 module Pact
   module Matchers
 
-    NO_DIFF_INDICATOR = NoDiffIndicator.new
+    NO_DIFF_AT_INDEX = NoDiffAtIndex.new
     DEFAULT_OPTIONS = {allow_unexpected_keys: true, type: false}.freeze
+    NO_DIFF = {}.freeze
 
     def diff expected, actual, opts = {}
       calculate_diff(Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts))
@@ -44,7 +45,7 @@ module Pact
 
     def regexp_diff regexp, actual, options
       if actual.is_a?(String) && regexp.match(actual)
-        {}
+        NO_DIFF
       else
         RegexpDifference.new regexp, actual
       end
@@ -69,71 +70,78 @@ module Pact
           diff_found = true
           difference << item_diff
         else
-          difference << NO_DIFF_INDICATOR
+          difference << NO_DIFF_AT_INDEX
         end
       end
-      diff_found ? difference : {}
+      diff_found ? difference : NO_DIFF
+    end
+
+    def hash_diff expected, actual, options
+      if actual.is_a? Hash
+        actual_hash_diff expected, actual, options
+      else
+        Difference.new expected, actual
+      end
     end
 
     def actual_hash_diff expected, actual, options
-      difference = expected.keys.inject({}) do |calculate_diff, key|
-        if (diff_at_key = calculate_diff(expected[key], actual.fetch(key, Pact::KeyNotFound.new), options)).any?
-          calculate_diff[key] = diff_at_key
-        end
-        calculate_diff
+      hash_diff = expected.each_with_object({}) do |(key, value), difference|
+        diff_at_key = calculate_diff(value, actual.fetch(key, Pact::KeyNotFound.new), options)
+        difference[key] = diff_at_key if diff_at_key.any?
       end
-      difference.merge(check_for_unexpected_keys(expected, actual, options))
+      hash_diff.merge(check_for_unexpected_keys(expected, actual, options))
     end
 
     def check_for_unexpected_keys expected, actual, options
       if options[:allow_unexpected_keys]
-        {}
+        NO_DIFF
       else
-        (actual.keys - expected.keys).inject({}) do | calculate_diff, key |
-          calculate_diff[key] = Difference.new(UnexpectedKey.new, actual[key])
-          calculate_diff
+        (actual.keys - expected.keys).each_with_object({}) do | key, running_diff |
+          running_diff[key] = Difference.new(UnexpectedKey.new, actual[key])
         end
       end
     end
 
-    def hash_diff expected, actual, options
-      if actual.is_a? Hash
-        actual_hash_diff expected, actual, options
+    def object_diff expected, actual, options
+      if options[:type]
+        type_difference expected, actual
       else
+        exact_value_diff expected, actual, options
+      end
+    end
+
+    def exact_value_diff expected, actual, options
+      if expected != actual
         Difference.new expected, actual
+      else
+        NO_DIFF
       end
     end
 
     def type_difference expected, actual
       if types_match? expected, actual
-        {}
+        NO_DIFF
       else
         TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual)
       end
     end
 
-    def type_diff_actual_display actual
-      actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
-    end
-
     def type_diff_expected_display expected
       ExpectedType.new(expected)
     end
 
+    def type_diff_actual_display actual
+      actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
+    end
+
     def types_match? expected, actual
-      #There must be a more elegant way to do this
-      expected.class == actual.class ||
-        (expected.is_a?(TrueClass) && actual.is_a?(FalseClass)) ||
-          (expected.is_a?(FalseClass) && actual.is_a?(TrueClass))
+      expected.class == actual.class || (is_boolean(expected) && is_boolean(actual))
     end
 
-    def object_diff expected, actual, options
-      return type_difference(expected, actual) if options[:type]
-      if expected != actual
-        Difference.new expected, actual
-      else
-        {}
-      end
+    def is_boolean object
+      object == true || object == false
     end
+
+
   end
 end

data/lib/pact/matchers/{no_diff_indicator.rb → no_diff_at_index.rb}

@@ -1,17 +1,17 @@
 module Pact
   module Matchers
-    class NoDiffIndicator
+    class NoDiffAtIndex
 
       def to_json options = {}
         to_s.inspect
       end
 
       def to_s
-        'no difference here!'
+        '<no difference at this index>'
       end
 
       def == other
-        other.is_a? NoDiffIndicator
+        other.is_a? NoDiffAtIndex
       end
     end
   end

data/lib/pact/matchers/unexpected_index.rb

@@ -4,7 +4,7 @@ module Pact
   class UnexpectedIndex < Pact::DifferenceIndicator
 
     def to_s
-      '<index not to exist>'
+      '<item not to exist>'
     end
 
   end

data/lib/pact/matchers/unix_diff_formatter.rb

@@ -27,7 +27,8 @@ module Pact
         expected = generate_string(diff, :expected)
         actual = generate_string(diff, :actual)
         suffix = @include_explanation ?  "\n" + key : ''
-        @differ.diff_as_string(actual, expected).lstrip + suffix
+        string_diff = remove_comma_from_end_of_arrays(@differ.diff_as_string(actual, expected).lstrip)
+        string_diff + suffix
       end
 
       private
@@ -39,7 +40,7 @@ module Pact
         when Difference then copy_diff(thing, target)
         when TypeDifference then copy_diff(thing, target)
         when RegexpDifference then copy_diff(thing, target)
-        when NoDiffIndicator then copy_no_diff(thing, target)
+        when NoDiffAtIndex then copy_no_diff(thing, target)
         else copy_object(thing, target)
         end
       end
@@ -48,7 +49,8 @@ module Pact
         comparable = handle(diff, target)
         begin
           # Can't think of an elegant way to check if we can pretty generate other than to try it and maybe fail
-          fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
+          json = fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
+          add_comma_to_end_of_arrays json
         rescue JSON::GeneratorError
           comparable.to_s
         end
@@ -69,7 +71,7 @@ module Pact
       end
 
       def copy_no_diff(thing, target)
-        thing
+        NoDifferenceDecorator.new
       end
 
       def copy_diff difference, target
@@ -94,13 +96,29 @@ module Pact
         "     Values where the expected matches the actual are not shown.\n"
       end
 
+      def add_comma_to_end_of_arrays string
+        string.gsub(/(\n\s*\])/, ',\1')
+      end
+
+      def remove_comma_from_end_of_arrays string
+        string.gsub(/,(\n\s*\])/, '\1')
+      end
+
+      class NoDifferenceDecorator
+
+        def to_json options = {}
+          "... "
+        end
+
+      end
+
       class RegexpDecorator
 
         def initialize regexp
           @regexp = regexp
         end
 
-        def to_json options={}
+        def to_json options = {}
           @regexp.inspect
         end
 

data/lib/pact/matching_rules.rb

@@ -0,0 +1,17 @@
+require 'pact/matching_rules/extract'
+require 'pact/matching_rules/merge'
+
+module Pact
+  module MatchingRules
+
+    # @api public Used by pact-mock_service
+    def self.extract object_graph
+      Extract.(object_graph)
+    end
+
+    def self.merge object_graph, matching_rules
+      Merge.(object_graph, matching_rules)
+    end
+
+  end
+end

data/lib/pact/matching_rules/extract.rb

@@ -0,0 +1,64 @@
+module Pact
+  module MatchingRules
+    class Extract
+
+      def self.call matchable
+        new(matchable).call
+      end
+
+      def initialize matchable
+        @matchable = matchable
+        @rules = Hash.new
+      end
+
+      def call
+        recurse matchable, "$", nil
+        rules
+      end
+
+      private
+
+      attr_reader :matchable, :rules
+
+      def recurse object, path, match_type
+
+        case object
+        when Hash then recurse_hash(object, path, match_type)
+        when Array then recurse_array(object, path, match_type)
+        when Pact::SomethingLike then recurse_something_like(object, path, match_type)
+        when Pact::Term then record_regex_rule object, path
+        else
+          record_rule object, path, match_type
+        end
+
+      end
+
+      def recurse_hash hash, path, match_type
+        hash.each do | (key, value) |
+          recurse value, "#{path}.#{key.to_s}", match_type
+        end
+      end
+
+      def recurse_array new_array, path, match_type
+        new_array.each_with_index do | value, index |
+          recurse value, "#{path}[#{index}]", match_type
+        end
+      end
+
+      def recurse_something_like something_like, path, match_type
+        recurse something_like.contents, path, "type"
+      end
+
+      def record_regex_rule term, path
+        rules[path] ||= {}
+        rules[path]['match'] = 'regex'
+        rules[path]['regex'] = term.matcher.inspect[1..-2]
+      end
+
+      def record_rule object, path, match_type
+        rules[path] ||= {}
+        rules[path]['match'] = 'type'
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/merge.rb

@@ -0,0 +1,80 @@
+module Pact
+  module MatchingRules
+    class Merge
+
+      def self.call expected, matching_rules, root_path = '$'
+        new(expected, matching_rules, root_path).call
+      end
+
+      def initialize expected, matching_rules, root_path
+        @expected = expected
+        @matching_rules = matching_rules
+        @root_path = root_path
+      end
+
+      def call
+        return @expected if @matching_rules.nil? || @matching_rules.empty?
+        recurse @expected, @root_path
+      end
+
+      def recurse expected, path
+        case expected
+        when Hash then recurse_hash(expected, path)
+        when Array then recurse_array(expected, path)
+        else
+          expected
+        end
+      end
+
+      def recurse_hash hash, path
+        hash.each_with_object({}) do | (k, v), new_hash |
+          new_path = path + ".#{k.to_s}"
+          new_hash[k] = recurse(wrap(v, new_path), new_path)
+        end
+      end
+
+      def recurse_array array, path
+        new_array = []
+        array.each_with_index do | item, index |
+          new_path = path + "[#{index}]"
+          new_array << recurse(wrap(item, new_path), new_path)
+        end
+        new_array
+      end
+
+      def wrap object, path
+        rules = @matching_rules[path]
+        return object unless rules
+
+        if rules['match'] == 'type'
+          handle_match_type(object, path, rules)
+        elsif rules['regex']
+          handle_regex(object, path, rules)
+        else
+          log_ignored_rules(path, rules, {})
+          object
+        end
+      end
+
+      def handle_match_type object, path, rules
+        log_ignored_rules(path, rules, {'match' => 'type'})
+        Pact::SomethingLike.new(object)
+      end
+
+      def handle_regex object, path, rules
+        log_ignored_rules(path, rules, {'match' => 'regex', 'regex' => rules['regex']})
+        Pact::Term.new(generate: object, matcher: Regexp.new(rules['regex']))
+      end
+
+      def log_ignored_rules path, rules, used_rules
+        dup_rules = rules.dup
+        used_rules.each_pair do | used_key, used_value |
+          dup_rules.delete(used_key) if dup_rules[used_key] == used_value
+        end
+        if dup_rules.any?
+          $stderr.puts "WARN: Ignoring unsupported matching rules #{dup_rules} for path #{path}"
+        end
+      end
+    end
+  end
+end