pact-support 1.4.0 → 1.8.0

data/lib/pact/consumer_contract/query_hash.rb

@@ -47,6 +47,10 @@ module Pact
       @hash && @hash.empty?
     end
 
+    def to_hash
+      @hash
+    end
+
     private
 
     def convert_to_hash_of_arrays(query)
@@ -56,6 +60,8 @@ module Pact
     def insert(hash, k, v)
       if Hash === v
         v.each {|k2, v2| insert(hash, :"#{k}[#{k2}]", v2) }
+      elsif Pact::ArrayLike === v
+        hash[k.to_sym] = v
       else
         hash[k.to_sym] = [*v]
       end

data/lib/pact/consumer_contract/query_string.rb

@@ -4,7 +4,6 @@ module Pact
   class QueryString
 
     include ActiveSupportSupport
-    include Pact::Matchers
 
     def initialize query
       @query = query.nil? ? query : query.dup
@@ -27,7 +26,8 @@ module Pact
     end
 
     def difference(other)
-      diff(query, other.query)
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      Pact::Matchers.diff(query, other.query)
     end
 
     def query

data/lib/pact/consumer_contract/request.rb

@@ -2,9 +2,7 @@ require 'pact/shared/request'
 require 'pact/shared/null_expectation'
 
 module Pact
-
   module Request
-
     class Expected < Pact::Request::Base
 
       DEFAULT_OPTIONS = {:allow_unexpected_keys => false}.freeze
@@ -80,8 +78,6 @@ module Pact
       def body_differ
         Pact.configuration.body_differ_for_content_type content_type
       end
-
     end
-
   end
-end
+end

data/lib/pact/consumer_contract/string_with_matching_rules.rb

@@ -0,0 +1,17 @@
+module Pact
+  class StringWithMatchingRules < String
+    attr_reader :matching_rules
+    attr_reader :pact_specification_version
+
+    def initialize string, pact_specification_version, matching_rules = {}
+      super(string)
+      @matching_rules = matching_rules
+      @pact_specification_version = pact_specification_version
+    end
+
+    # How can we show the matching rules too?
+    def to_s
+      super
+    end
+  end
+end

data/lib/pact/matchers/multipart_form_diff_formatter.rb

@@ -0,0 +1,41 @@
+require 'pact/matchers/unix_diff_formatter'
+require 'pact/matchers/differ'
+
+module Pact
+  module Matchers
+    class MultipartFormDiffFormatter
+
+      def initialize diff, options = {}
+        @options = options
+        @body_diff = diff[:body]
+        @non_body_diff = diff.reject{ |k, v| k == :body }
+        @colour = options.fetch(:colour, false)
+        @differ = Pact::Matchers::Differ.new(@colour)
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def call
+        Pact::Matchers::UnixDiffFormatter::MESSAGES_TITLE + "\n" + non_body_diff_string + "\n" + body_diff_string
+      end
+
+      def non_body_diff_string
+        if @non_body_diff.any?
+          Pact::Matchers::ExtractDiffMessages.call(@non_body_diff).collect{ | message| "* #{message}" }.join("\n")
+        else
+          ""
+        end
+      end
+
+      def body_diff_string
+        if @body_diff
+          @differ.diff_as_string(@body_diff.expected, @body_diff.actual)
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/merge.rb

@@ -13,11 +13,12 @@ module Pact
         @expected = expected
         @matching_rules = standardise_paths(matching_rules)
         @root_path = JsonPath.new(root_path).to_s
+        @used_rules = []
       end
 
       def call
         return @expected if @matching_rules.nil? || @matching_rules.empty?
-        recurse @expected, @root_path
+        recurse(@expected, @root_path).tap { log_ignored_rules }
       end
 
       private
@@ -30,36 +31,42 @@ module Pact
       end
 
       def recurse expected, path
-        case expected
+        recursed = case expected
         when Hash then recurse_hash(expected, path)
         when Array then recurse_array(expected, path)
         else
           expected
         end
+
+        wrap(recursed, path)
       end
 
       def recurse_hash hash, path
-        hash.each_with_object({}) do | (k, v), new_hash |
+        recursed =  hash.each_with_object({}) do | (k, v), new_hash |
           new_path = path + "['#{k}']"
-          new_hash[k] = recurse(wrap(v, new_path), new_path)
+          new_hash[k] = recurse(v, new_path)
         end
       end
 
       def recurse_array array, path
+        parent_match_rule = find_rule(path, 'match')
+        log_used_rule(path, 'match', parent_match_rule) if parent_match_rule
+
         array_like_children_path = "#{path}[*]*"
-        parent_match_rule = @matching_rules[path] && @matching_rules[path]['match']
-        children_match_rule = @matching_rules[array_like_children_path] && @matching_rules[array_like_children_path]['match']
-        min = @matching_rules[path] && @matching_rules[path]['min']
+        children_match_rule = find_rule(array_like_children_path, 'match')
+        log_used_rule(array_like_children_path, 'match', children_match_rule) if children_match_rule
+
+        min = find_rule(path, 'min')
+        log_used_rule(path, 'min', min) if min
 
         if min && (children_match_rule == 'type' || (children_match_rule.nil? && parent_match_rule == 'type'))
           warn_when_not_one_example_item(array, path)
-          # log_ignored_rules(path, @matching_rules[path], {'min' => min})
           Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
         else
           new_array = []
           array.each_with_index do | item, index |
             new_path = path + "[#{index}]"
-            new_array << recurse(wrap(item, new_path), new_path)
+            new_array << recurse(item, new_path)
           end
           new_array
         end
@@ -72,39 +79,47 @@ module Pact
       end
 
       def wrap object, path
-        rules = @matching_rules[path]
-        array_rules = @matching_rules["#{path}[*]*"]
-        return object unless rules || array_rules
-
-        if rules['match'] == 'type' && !rules.has_key?('min')
-          handle_match_type(object, path, rules)
-        elsif rules['regex']
-          handle_regex(object, path, rules)
+        if find_rule(path, 'match') == 'type' && !find_rule(path, 'min')
+          handle_match_type(object, path)
+        elsif find_rule(path, 'regex')
+          handle_regex(object, path)
         else
-          log_ignored_rules(path, rules, {})
           object
         end
       end
 
-      def handle_match_type object, path, rules
-        log_ignored_rules(path, rules, {'match' => 'type'})
+      def handle_match_type object, path
+        log_used_rule(path, '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']))
+      def handle_regex object, path
+        regex = find_rule(path, 'regex')
+        log_used_rule(path, 'match', 'regex') # assumed to be present
+        log_used_rule(path, 'regex', regex)
+        Pact::Term.new(generate: object, matcher: Regexp.new(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
+      def log_ignored_rules
+        dup_rules = @matching_rules.dup
+        @used_rules.each do | (path, key, value) |
+          dup_rules[path].delete(key) if dup_rules[path][key] == value
         end
+
         if dup_rules.any?
-          $stderr.puts "WARN: Ignoring unsupported matching rules #{dup_rules} for path #{path}"
+          dup_rules.each do | path, rules |
+            $stderr.puts "WARN: Ignoring unsupported matching rules #{rules} for path #{path}" if rules.any?
+          end
         end
       end
+
+      def find_rule(path, key)
+        @matching_rules[path] && @matching_rules[path][key]
+      end
+
+      def log_used_rule path, key, value
+        @used_rules << [path, key, value]
+      end
     end
   end
 end

data/lib/pact/matching_rules/v3/extract.rb

@@ -0,0 +1,94 @@
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/term'
+
+module Pact
+  module MatchingRules::V3
+    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 handle_something_like(object, path, match_type)
+        when Pact::ArrayLike then handle_array_like(object, path, match_type)
+        when Pact::Term then record_regex_rule object, path
+        when Pact::QueryString then recurse(object.query, path, match_type)
+        when Pact::QueryHash then recurse_hash(object.query, path, match_type)
+        end
+      end
+
+      def recurse_hash hash, path, match_type
+        hash.each do | (key, value) |
+          recurse value, "#{path}#{next_path_part(key)}", 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 handle_something_like something_like, path, match_type
+        record_match_type_rule path, "type"
+        recurse something_like.contents, path, "type"
+      end
+
+      def handle_array_like array_like, path, match_type
+        record_rule "#{path}", 'min' => array_like.min
+        record_match_type_rule "#{path}[*].*", 'type'
+        recurse array_like.contents, "#{path}[*]", :array_like
+      end
+
+      def record_rule path, rule
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rules[path]['matchers'] << rule
+      end
+
+      def record_regex_rule term, path
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rule = { 'match' => 'regex', 'regex' => term.matcher.inspect[1..-2]}
+        rules[path]['matchers'] << rule
+      end
+
+      def record_match_type_rule path, match_type
+        unless match_type == :array_like || match_type.nil?
+          rules[path] ||= {}
+          rules[path]['matchers'] ||= []
+          rules[path]['matchers'] << { 'match' => match_type }
+        end
+      end
+
+      # Beth: there's a potential bug if the key contains a dot and a single quote.
+      # Not sure what to do then.
+      def next_path_part key
+        if key.to_s.include?('.')
+          "['#{key}']"
+        else
+          ".#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/v3/merge.rb

@@ -0,0 +1,135 @@
+require 'pact/array_like'
+require 'pact/matching_rules/jsonpath'
+
+module Pact
+  module MatchingRules
+    module V3
+      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 = standardise_paths(matching_rules)
+          @root_path = JsonPath.new(root_path).to_s
+        end
+
+        def call
+          return @expected if @matching_rules.nil? || @matching_rules.empty?
+          recurse(@expected, @root_path).tap { log_ignored_rules }
+        end
+
+        private
+
+        def standardise_paths matching_rules
+          return matching_rules if matching_rules.nil? || matching_rules.empty?
+          matching_rules.each_with_object({}) do | (path, rules), new_matching_rules |
+            new_matching_rules[JsonPath.new(path).to_s] = Marshal.load(Marshal.dump(rules)) # simplest way to deep clone
+          end
+        end
+
+        def recurse expected, path
+          recursed = case expected
+          when Hash then recurse_hash(expected, path)
+          when Array then recurse_array(expected, path)
+          else
+            expected
+          end
+          wrap(recursed, path)
+        end
+
+        def recurse_hash hash, path
+          hash.each_with_object({}) do | (k, v), new_hash |
+            new_path = path + "['#{k}']"
+            new_hash[k] = recurse(v, new_path)
+          end
+        end
+
+        def recurse_array array, path
+          # This assumes there is only one rule! TODO make this find the appropriate rule.
+          parent_match_rule = @matching_rules[path]['matchers'].first['match'] rescue nil
+          array_like_children_path = "#{path}[*]*"
+          children_match_rule = @matching_rules[array_like_children_path]['matchers'].first['match'] rescue nil
+          min = @matching_rules[path]['matchers'].first['min'] rescue nil
+
+          if min && children_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[array_like_children_path]['matchers'].first.delete('match')
+            warn_when_not_one_example_item(array, path)
+            Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+          elsif min && parent_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[path]['matchers'].first.delete('match')
+            warn_when_not_one_example_item(array, path)
+            Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+          else
+            new_array = []
+            array.each_with_index do | item, index |
+              new_path = path + "[#{index}]"
+              new_array << recurse(item, new_path)
+            end
+            new_array
+          end
+        end
+
+        def warn_when_not_one_example_item array, path
+          unless array.size == 1
+            Pact.configuration.error_stream.puts "WARN: Only the first item will be used to match the items in the array at #{path}"
+          end
+        end
+
+        def wrap object, path
+          rules = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first
+          array_rules = @matching_rules["#{path}[*]*"] && @matching_rules["#{path}[*]*"]['matchers'] && @matching_rules["#{path}[*]*"]['matchers'].first
+          return object unless rules || array_rules
+
+          if rules['match'] == 'type' && !rules.has_key?('min')
+            handle_match_type(object, path, rules)
+          elsif rules['regex']
+            handle_regex(object, path, rules)
+          else
+            object
+          end
+        end
+
+        def handle_match_type object, path, rules
+          rules.delete('match')
+          Pact::SomethingLike.new(object)
+        end
+
+        def handle_regex object, path, rules
+          rules.delete('match')
+          regex = rules.delete('regex')
+          Pact::Term.new(generate: object, matcher: Regexp.new(regex))
+        end
+
+        def log_ignored_rules
+          @matching_rules.each do | jsonpath, rules_hash |
+            rules_array = rules_hash["matchers"]
+            ((rules_array.length - 1)..0).each do | index |
+              rules_array.delete_at(index) if rules_array[index].empty?
+            end
+          end
+
+          if @matching_rules.any?
+            @matching_rules.each do | path, rules_hash |
+              rules_hash.each do | key, value |
+                $stderr.puts "WARN: Ignoring unsupported #{key} #{value} for path #{path}" if value.any?
+              end
+            end
+          end
+        end
+
+        def find_rule(path, key)
+          @matching_rules[path] && @matching_rules[path][key]
+        end
+
+        def log_used_rule path, key, value
+          @used_rules << [path, key, value]
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules.rb

@@ -1,17 +1,30 @@
 require 'pact/matching_rules/extract'
+require 'pact/matching_rules/v3/extract'
 require 'pact/matching_rules/merge'
+require 'pact/matching_rules/v3/merge'
 
 module Pact
   module MatchingRules
 
     # @api public Used by pact-mock_service
-    def self.extract object_graph
-      Extract.(object_graph)
+    def self.extract object_graph, options = {}
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
+      when nil, 0, 1, 2
+        Extract.(object_graph)
+      else
+        V3::Extract.(object_graph)
+      end
     end
 
-    def self.merge object_graph, matching_rules
-      Merge.(object_graph, matching_rules)
+    def self.merge object_graph, matching_rules, options = {}
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
+      when nil, 0, 1, 2
+        Merge.(object_graph, matching_rules)
+      else
+        V3::Merge.(object_graph, matching_rules)
+      end
     end
-
   end
-end
+end

data/lib/pact/reification.rb

@@ -5,6 +5,7 @@ require 'pact/array_like'
 require 'pact/shared/request'
 require 'pact/consumer_contract/query_hash'
 require 'pact/consumer_contract/query_string'
+require 'pact/consumer_contract/string_with_matching_rules'
 
 module Pact
   module Reification
@@ -26,15 +27,17 @@ module Pact
       when Pact::QueryString
         from_term(term.query)
       when Pact::QueryHash
-        term.query.map { |k, v|
+        from_term(term.query).map { |k, v|
           if v.nil?
             k
           elsif v.is_a?(Array) #For cases where there are multiple instance of the same parameter
-            v.map { |x| "#{k}=#{escape(from_term(x))}"}.join('&')
+            v.map { |x| "#{k}=#{escape(x)}"}.join('&')
           else
-            "#{k}=#{escape(from_term(v))}"
+            "#{k}=#{escape(v)}"
           end
         }.join('&')
+      when Pact::StringWithMatchingRules
+        String.new(term)
       else
         term
       end

data/lib/pact/shared/multipart_form_differ.rb

@@ -0,0 +1,14 @@
+require 'uri'
+require 'pact/shared/text_differ'
+
+module Pact
+  class MultipartFormDiffer
+    def self.call expected, actual, options = {}
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      expected_boundary = expected.split.first
+      actual_boundary = actual.split.first
+      actual_with_hardcoded_boundary = actual.gsub(actual_boundary, expected_boundary)
+      TextDiffer.call(expected, actual_with_hardcoded_boundary, options)
+    end
+  end
+end

data/lib/pact/specification_version.rb

@@ -0,0 +1,18 @@
+module Pact
+  class SpecificationVersion < Gem::Version
+
+    def major
+      segments.first
+    end
+
+    def === other
+      major && major == other
+    end
+
+    def after? other
+      major && other < major
+    end
+  end
+
+  SpecificationVersion::NIL_VERSION = Pact::SpecificationVersion.new('0')
+end

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "1.4.0"
+    VERSION = "1.8.0"
   end
 end

data/script/release.sh

@@ -5,5 +5,5 @@ git checkout -- lib/pact/support/version.rb
 bundle exec bump ${1:-minor} --no-commit
 bundle exec rake generate_changelog
 git add CHANGELOG.md lib/pact/support/version.rb
-git commit -m "Releasing version $(ruby -r ./lib/pact/support/version.rb -e "puts Pact::Support::VERSION")"
+git commit -m "chore(release): version $(ruby -r ./lib/pact/support/version.rb -e "puts Pact::Support::VERSION")"
 bundle exec rake release

data/spec/fixtures/multipart-form-diff.txt

@@ -0,0 +1,9 @@
+
+
+Description of differences
+--------------------------------------
+* Wrong header
+
+@@ -1,2 +1,2 @@
+-bar
++foo

data/spec/fixtures/not-a-pact.json

@@ -0,0 +1,3 @@
+{
+  "foo": "bar"
+}

data/spec/fixtures/pact-http-v2.json

@@ -0,0 +1,36 @@
+{
+  "consumer": {
+    "name": "some-test-consumer"
+  },
+  "provider": {
+    "name": "an unknown provider"
+  },
+  "interactions": [
+    {
+      "description": "a test request",
+      "request": {
+        "method": "get",
+        "path": "/weather",
+        "query": ""
+      },
+      "response": {
+        "matchingRules": {
+          "$.headers.Content-Type" : {
+            "match": "regex", "regex": "json"
+          },
+          "$.body.message" : {
+            "match": "regex", "regex": "sun"
+          }
+        },
+        "status": 200,
+        "headers" : {
+          "Content-Type": "foo/json"
+        },
+        "body": {
+          "message" : "sunful"
+        }
+      },
+      "provider_state": "the weather is sunny"
+    }
+  ]
+}