pact-support 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d63ce6f1b637b9ec8c1aa7c097631c13134c8085
-  data.tar.gz: e7f099a1364dd8e6ea4da06c5e6c15e6d1b83b38
+  metadata.gz: bbfe3583ddef289cebbe55fdfe7319853eb2c88b
+  data.tar.gz: cacbf113d031f4af3552ca441d12b1f47c1decf4
 SHA512:
-  metadata.gz: 6fab573b4105cb73ab146e406cfddbb56508160324e639b35a287f823a1b8c1570347768ef0198dbcf7454ea9dbfef7f0a53f9e3b48c9e22f430c5cd4d45548e
-  data.tar.gz: 424fdc09077746fda17301499934ef326c6f1af664baac0cc08e5f3d3c318d1047a3a7a95db7b90cf82d6139da774cb579fedb0a56929aba6fdc66dbaf15ca0d
+  metadata.gz: f100ad0607607f0ef0de629774b4f8fa4eb6a66ff0b556335a510111fa64c0f494cc86c7f8e52d455ceedb683263c57b00b669ee51029c8ce32e97ebabb7a67b
+  data.tar.gz: 50691e89980a9fb1af2b38ac5f9b1c1b50d31e0476816ea36cda7715cf9b797bb0230713f837356dd3f6414b0b948a9ac2a9be111cb8587f29b47cf7f17b6f77

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+<a name="v1.5.0"></a>
+### v1.5.0 (2018-03-23)
+
+#### Features
+
+* parse pacts without a specification version as v2	 ([a69b5e6](/../../commit/a69b5e6))
+* locate matching rules correctly for v3 pacts	 ([0f22db2](/../../commit/0f22db2))
+* read matching rules from v3 format	 ([07013de](/../../commit/07013de))
+* allow different consumer contract parsers to be registered	 ([531ab3a](/../../commit/531ab3a))
+* update message classes to support pact-message	 ([2e48892](/../../commit/2e48892))
+* add request and response to message	 ([93839cf](/../../commit/93839cf))
+
+* **message contracts**
+  * dynamically mix in new and from_hash into Pact::Message	 ([c0c3ad5](/../../commit/c0c3ad5))
+  * read message pact into Ruby object	 ([6573bd4](/../../commit/6573bd4))
+
+
 <a name="v1.3.1"></a>
 ### v1.3.1 (2018-03-19)
 

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -10,9 +10,9 @@ require 'pact/consumer_contract/service_consumer'
 require 'pact/consumer_contract/service_provider'
 require 'pact/consumer_contract/interaction'
 require 'pact/consumer_contract/pact_file'
+require 'pact/consumer_contract/http_consumer_contract_parser'
 
 module Pact
-
   class ConsumerContract
 
     include SymbolizeKeys
@@ -29,13 +29,19 @@ module Pact
       @provider = attributes[:provider]
     end
 
+    def self.add_parser consumer_contract_parser
+      parsers << consumer_contract_parser
+    end
+
+    def self.parsers
+      @parsers ||= [Pact::HttpConsumerContractParser.new]
+    end
+
     def self.from_hash(hash)
-      hash = symbolize_keys(hash)
-      new(
-        :consumer => ServiceConsumer.from_hash(hash[:consumer]),
-        :provider => ServiceProvider.from_hash(hash[:provider]),
-        :interactions => hash[:interactions].collect { |h| Interaction.from_hash(h)}
-      )
+      parsers.each do | parser |
+        return parser.call(hash) if parser.can_parse?(hash)
+      end
+      raise Pact::Error.new("No consumer contract parser found for hash: #{hash}")
     end
 
     def self.from_json string
@@ -54,9 +60,9 @@ module Pact
     def find_interaction criteria
       interactions = find_interactions criteria
       if interactions.size == 0
-        raise "Could not find interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}."
+        raise Pact::Error.new("Could not find interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}.")
       elsif interactions.size > 1
-        raise "Found more than 1 interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}."
+        raise Pact::Error.new("Found more than 1 interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}.")
       end
       interactions.first
     end

data/lib/pact/consumer_contract/http_consumer_contract_parser.rb

@@ -0,0 +1,37 @@
+require 'pact/specification_version'
+
+module Pact
+  class HttpConsumerContractParser
+    include SymbolizeKeys
+
+    def call(hash)
+      hash = symbolize_keys(hash)
+      v = pact_specification_version(hash)
+      options = { pact_specification_version: v }
+
+      if v.after? 3
+        Pact.configuration.error_stream.puts "WARN: This code only knows how to parse v3 pacts, attempting to parse v#{options[:pact_specification_version]} pact using v3 code."
+      end
+
+      interactions = hash[:interactions].collect { |hash| Interaction.from_hash(hash, options) }
+      ConsumerContract.new(
+        :consumer => ServiceConsumer.from_hash(hash[:consumer]),
+        :provider => ServiceProvider.from_hash(hash[:provider]),
+        :interactions => interactions
+      )
+    end
+
+    def pact_specification_version hash
+      # TODO handle all 3 ways of defining this...
+      # metadata.pactSpecificationVersion
+      maybe_pact_specification_version_1 = hash[:metadata] && hash[:metadata]['pactSpecification'] && hash[:metadata]['pactSpecification']['version']
+      maybe_pact_specification_version_2 = hash[:metadata] && hash[:metadata]['pactSpecificationVersion']
+      pact_specification_version = maybe_pact_specification_version_1 || maybe_pact_specification_version_2
+      pact_specification_version ? Pact::SpecificationVersion.new(pact_specification_version) : Pact::SpecificationVersion::NIL_VERSION
+    end
+
+    def can_parse?(hash)
+      hash.key?('interactions') || hash.key?(:interactions)
+    end
+  end
+end

data/lib/pact/consumer_contract/interaction.rb

@@ -4,9 +4,10 @@ require 'pact/symbolize_keys'
 require 'pact/shared/active_support_support'
 require 'pact/matching_rules'
 require 'pact/errors'
+require 'pact/specification_version'
 
 module Pact
-   class Interaction
+  class Interaction
     include ActiveSupportSupport
       include SymbolizeKeys
 
@@ -19,10 +20,33 @@ module Pact
         @provider_state = attributes[:provider_state] || attributes[:providerState]
       end
 
-      def self.from_hash hash
-        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['matchingRules'])
+      def self.from_hash hash, options = {}
+        pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+        case pact_specification_version.major
+        when nil, 0, 1, 2 then parse_v2_interaction(hash, pact_specification_version: pact_specification_version)
+        else parse_v3_interaction(hash, pact_specification_version: pact_specification_version)
+        end
+      end
+
+      def self.parse_v2_interaction hash, options
+        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['matchingRules'], options)
+        request = Pact::Request::Expected.from_hash(request_hash)
+        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['matchingRules'], options)
+        response = Pact::Response.from_hash(response_hash)
+        new(symbolize_keys(hash).merge(request: request, response: response))
+      end
+
+      def self.parse_v3_interaction hash, options
+
+        request_hash = hash['request'].keys.each_with_object({}) do | key, new_hash |
+          new_hash[key] = Pact::MatchingRules.merge(hash['request'][key], hash['request'].fetch('matchingRules', {})[key], options)
+        end
         request = Pact::Request::Expected.from_hash(request_hash)
-        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['matchingRules'])
+
+        response_hash = hash['response'].keys.each_with_object({}) do | key, new_hash |
+          new_hash[key] = Pact::MatchingRules.merge(hash['response'][key], hash['response'].fetch('matchingRules', {})[key], options)
+        end
+
         response = Pact::Response.from_hash(response_hash)
         new(symbolize_keys(hash).merge(request: request, response: response))
       end
@@ -36,6 +60,10 @@ module Pact
         }
       end
 
+      def http?
+        true
+      end
+
       def validate!
         raise Pact::InvalidInteractionError.new(self) unless description && request && response
       end

data/lib/pact/matching_rules.rb

@@ -1,17 +1,22 @@
 require 'pact/matching_rules/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
+    def self.extract object_graph, options = {}
       Extract.(object_graph)
     end
 
-    def self.merge object_graph, matching_rules
-      Merge.(object_graph, matching_rules)
+    def self.merge object_graph, matching_rules, options = {}
+      case options[: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/matching_rules/v3/merge.rb

@@ -0,0 +1,112 @@
+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
+        end
+
+        private
+
+        def standardise_paths matching_rules
+          return matching_rules if matching_rules.nil? || matching_rules.empty?
+          matching_rules.each_with_object({}) do | (path, rule), new_matching_rules |
+            new_matching_rules[JsonPath.new(path).to_s] = rule
+          end
+        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}']"
+            new_hash[k] = recurse(wrap(v, new_path), new_path)
+          end
+        end
+
+        def recurse_array array, path
+          array_like_children_path = "#{path}[*]*"
+          parent_match_rule = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first['match']
+          children_match_rule = @matching_rules[array_like_children_path] && @matching_rules[array_like_children_path]['matchers'] && @matching_rules[array_like_children_path]['matchers'].first && @matching_rules[array_like_children_path]['matchers'].first['match']
+          min = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first['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)
+            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
+            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
+end

data/lib/pact/specification_version.rb

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

data/lib/pact/support/version.rb

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

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"
+    }
+  ]
+}

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

@@ -0,0 +1,36 @@
+{
+  "consumer": {
+    "name": "consumer"
+  },
+  "interactions": [
+    {
+      "description": "a test request",
+      "providerState": "the weather is sunny",
+      "request": {
+        "method": "get",
+        "path": "/foo"
+      },
+      "response": {
+        "body": {
+          "foo": "bar"
+        },
+        "matchingRules": {
+          "body": {
+            "$.foo": {
+              "matchers": [{ "match": "type" }]
+            }
+          }
+        },
+        "status": 200
+      }
+    }
+  ],
+  "provider": {
+    "name": "provider"
+  },
+  "metadata": {
+    "pactSpecification": {
+      "version": "3.0"
+    }
+  }
+}

data/spec/lib/pact/consumer_contract/consumer_contract_spec.rb

@@ -3,50 +3,53 @@ require 'pact/consumer_contract'
 
 module Pact
   describe ConsumerContract do
-
     describe ".from_json" do
+
       let(:loaded_pact) { ConsumerContract.from_json(string) }
-      context "when the top level object is a ConsumerContract" do
-        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
 
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
+      context "with an HTTP contract" do
+        context "when the top level object is a ConsumerContract" do
+          let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
 
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
+          it "should create a Pact" do
+            expect(loaded_pact).to be_instance_of ConsumerContract
+          end
 
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
+          it "should have interactions" do
+            expect(loaded_pact.interactions).to be_instance_of Array
+          end
 
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-        end
-      end
+          it "should have a consumer" do
+            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+          end
 
-      context "with old 'producer' key" do
-        let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
+          it "should have a provider" do
+            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+          end
         end
 
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
+        context "with old 'producer' key" do
+          let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
+          it "should create a Pact" do
+            expect(loaded_pact).to be_instance_of ConsumerContract
+          end
 
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
+          it "should have interactions" do
+            expect(loaded_pact.interactions).to be_instance_of Array
+          end
 
-        it "should have a provider" do
-          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-          expect(loaded_pact.provider.name).to eq "an old producer"
-        end
+          it "should have a consumer" do
+            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
+          end
 
-        it "should have a provider_state" do
-          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+          it "should have a provider" do
+            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+            expect(loaded_pact.provider.name).to eq "an old producer"
+          end
+
+          it "should have a provider_state" do
+            expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
+          end
         end
       end
     end

data/spec/lib/pact/consumer_contract/http_consumer_contract_parser_spec.rb

@@ -0,0 +1,25 @@
+require 'pact/consumer_contract/http_consumer_contract_parser'
+
+module Pact
+  describe HttpConsumerContractParser do
+    describe "#call integration test" do
+      subject { HttpConsumerContractParser.new.call(pact_hash) }
+
+      context "with a v2 pact" do
+        let(:pact_hash) { load_json_fixture('pact-http-v2.json') }
+
+        it "correctly parses the pact" do
+          expect(subject.interactions.first.response.headers['Content-Type']).to be_a(Pact::Term)
+        end
+      end
+
+      context "with a v3 pact" do
+        let(:pact_hash) { load_json_fixture('pact-http-v3.json') }
+
+        it "correctly parses the pact" do
+          expect(subject.interactions.first.response.body['foo']).to be_a(Pact::SomethingLike)
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer_contract/interaction_spec.rb

@@ -65,7 +65,7 @@ module Pact
         context "when there are matching rules" do
           let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
 
-          subject { Interaction.from_hash hash }
+          subject { Interaction.from_hash hash, pact_specification_version: Pact::SpecificationVersion.new("2") }
 
           it "merges the rules with the example for the request" do
             expect(subject.request.body['name']).to be_instance_of(Pact::Term)

data/spec/lib/pact/matching_rules/v3/merge_spec.rb

@@ -0,0 +1,364 @@
+require 'pact/matching_rules/v3/merge'
+
+module Pact
+  module MatchingRules
+    module V3
+      describe Merge do
+        subject { Merge.(expected, matching_rules) }
+
+        before do
+          allow($stderr).to receive(:puts)
+        end
+
+        describe "no recognised rules" do
+          let(:expected) do
+            {
+              "_links" => {
+                "self" => {
+                  "href" => "http://localhost:1234/thing"
+                }
+              }
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$._links.self.href" => {
+                "matchers" => [{ "type" => "unknown" }]
+              }
+            }
+          end
+
+          it "returns the object at that path unaltered" do
+            expect(subject["_links"]["self"]["href"]).to eq "http://localhost:1234/thing"
+          end
+
+          it "it logs the rules it has ignored" do
+            expect($stderr).to receive(:puts) do | message |
+              expect(message).to include("WARN")
+              expect(message).to include("type")
+              expect(message).to include("unknown")
+              expect(message).to include("$['_links']")
+            end
+            subject
+          end
+
+        end
+
+        describe "with nil rules" do
+          let(:expected) do
+            {
+              "_links" => {
+                "self" => {
+                  "href" => "http://localhost:1234/thing"
+                }
+              }
+            }
+          end
+
+          let(:matching_rules) { nil }
+
+          it "returns the example unaltered" do
+            expect(subject["_links"]["self"]["href"]).to eq "http://localhost:1234/thing"
+          end
+
+        end
+
+        describe "type based matching" do
+          let(:expected) do
+            {
+              "name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$.name" => {
+                "matchers" => [{ "match" => "type", "ignored" => "matchingrule" }]
+              }
+            }
+          end
+
+          it "creates a SomethingLike at the appropriate path" do
+            expect(subject['name']).to be_instance_of(Pact::SomethingLike)
+          end
+
+          it "it logs the rules it has ignored" do
+            expect($stderr).to receive(:puts).with(/ignored.*matchingrule/)
+            subject
+          end
+
+        end
+
+        describe "regular expressions" do
+
+          describe "in a hash" do
+            let(:expected) do
+              {
+                "_links" => {
+                  "self" => {
+                    "href" => "http://localhost:1234/thing"
+                  }
+                }
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$._links.self.href" => {
+                  "matchers" => [{ "regex" => "http:\\/\\/.*\\/thing", "match" => "regex", "ignored" => "somerule" }]
+                }
+              }
+            end
+
+            it "creates a Pact::Term at the appropriate path" do
+              expect(subject["_links"]["self"]["href"]).to be_instance_of(Pact::Term)
+              expect(subject["_links"]["self"]["href"].generate).to eq "http://localhost:1234/thing"
+              expect(subject["_links"]["self"]["href"].matcher.inspect).to eq "/http:\\/\\/.*\\/thing/"
+            end
+
+            it "it logs the rules it has ignored" do
+              expect($stderr).to receive(:puts) do | message |
+                expect(message).to match /ignored.*"somerule"/
+                expect(message).to_not match /regex/
+                expect(message).to_not match /"match"/
+              end
+              subject
+            end
+          end
+
+          describe "with an array" do
+
+            let(:expected) do
+              {
+                "_links" => {
+                  "self" => [{
+                      "href" => "http://localhost:1234/thing"
+                  }]
+                }
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$._links.self[0].href" => {
+                  "matchers" => [{ "regex" => "http:\\/\\/.*\\/thing" }]
+                }
+              }
+            end
+
+            it "creates a Pact::Term at the appropriate path" do
+              expect(subject["_links"]["self"][0]["href"]).to be_instance_of(Pact::Term)
+              expect(subject["_links"]["self"][0]["href"].generate).to eq "http://localhost:1234/thing"
+              expect(subject["_links"]["self"][0]["href"].matcher.inspect).to eq "/http:\\/\\/.*\\/thing/"
+            end
+          end
+
+          describe "with an array where all elements should match by type and the rule is specified on the parent element and there is no min specified" do
+            let(:expected) do
+              {
+                'alligators' => [{'name' => 'Mary'}]
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => {
+                  "matchers" => [{ 'match' => 'type' }]
+                }
+              }
+            end
+
+            it "creates a Pact::SomethingLike at the appropriate path" do
+              expect(subject["alligators"]).to be_instance_of(Pact::SomethingLike)
+              expect(subject["alligators"].contents).to eq ['name' => 'Mary']
+            end
+          end
+
+          describe "with an array where all elements should match by type and the rule is specified on the child elements" do
+            let(:expected) do
+              {
+                'alligators' => [{'name' => 'Mary'}]
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => {
+                  "matchers" => [{ 'min' => 2, 'match' => 'type' }]
+                },
+                "$.alligators[*].*" => {
+                  "matchers" => [{ 'match' => 'type'}]
+                }
+              }
+            end
+            it "creates a Pact::ArrayLike at the appropriate path" do
+              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+              expect(subject["alligators"].min).to eq 2
+            end
+          end
+
+          describe "with an array where all elements should match by type and the rule is specified on both the parent element and the child elements" do
+            let(:expected) do
+              {
+                'alligators' => [{'name' => 'Mary'}]
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => {
+                  "matchers" => [{ 'min' => 2, 'match' => 'type' }]
+                },
+                "$.alligators[*].*" => {
+                  "matchers" => [{ 'match' => 'type' }]
+                }
+              }
+            end
+
+            it "creates a Pact::ArrayLike at the appropriate path" do
+              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+              expect(subject["alligators"].min).to eq 2
+            end
+          end
+
+          describe "with an array where all elements should match by type and there is only a match:type on the parent element" do
+            let(:expected) do
+              {
+                'alligators' => [{'name' => 'Mary'}]
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => { 'matchers' => [{'min' => 2, 'match' => 'type'}] },
+              }
+            end
+
+            it "creates a Pact::ArrayLike at the appropriate path" do
+              expect(subject["alligators"]).to be_instance_of(Pact::ArrayLike)
+              expect(subject["alligators"].contents).to eq 'name' => 'Mary'
+              expect(subject["alligators"].min).to eq 2
+            end
+          end
+
+          describe "with an array where all elements should match by type nested inside another array where all elements should match by type" do
+            let(:expected) do
+              {
+
+                'alligators' => [
+                  {
+                    'name' => 'Mary',
+                    'children' => [
+                      'age' => 9
+                    ]
+                  }
+                ]
+
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => { "matchers" => [{ 'min' => 2, 'match' => 'type' }] },
+                "$.alligators[*].children" => { "matchers" => [{ 'min' => 1, 'match' => 'type' }]},
+              }
+            end
+
+            it "creates a Pact::ArrayLike at the appropriate path" do
+              expect(subject["alligators"].contents['children']).to be_instance_of(Pact::ArrayLike)
+              expect(subject["alligators"].contents['children'].contents).to eq 'age' => 9
+              expect(subject["alligators"].contents['children'].min).to eq 1
+            end
+          end
+
+          describe "with an example array with more than one item" do
+            let(:expected) do
+              {
+
+                'alligators' => [
+                  {'name' => 'Mary'},
+                  {'name' => 'Joe'}
+                ]
+
+              }
+            end
+
+            let(:matching_rules) do
+              {
+                "$.alligators" => { "matchers" => [{'min' => 2, 'match' => 'type'}] }
+              }
+            end
+
+            xit "doesn't warn about the min size being ignored" do
+              expect(Pact.configuration.error_stream).to receive(:puts).once
+              subject
+            end
+
+            it "warns that the other items will be ignored" do
+              allow(Pact.configuration.error_stream).to receive(:puts)
+              expect(Pact.configuration.error_stream).to receive(:puts).with(/WARN: Only the first item/)
+              subject
+            end
+          end
+        end
+
+        describe "using bracket notation for a Hash" do
+          let(:expected) do
+            {
+              "name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['name']" => { "matchers" => [{"match" => "type"}] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+
+        describe "with a dot in the path" do
+          let(:expected) do
+            {
+              "first.name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['first.name']" => { "matchers" => [{ "match" => "type" }] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['first.name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+
+        describe "with an @ in the path" do
+          let(:expected) do
+            {
+              "@name" => "Mary"
+            }
+          end
+
+          let(:matching_rules) do
+            {
+              "$['@name']" => { "matchers" => [ { "match" => "type" }] }
+            }
+          end
+
+          it "applies the rule" do
+            expect(subject['@name']).to be_instance_of(Pact::SomethingLike)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/matching_rules_spec.rb

@@ -0,0 +1,82 @@
+require 'pact/matching_rules'
+
+module Pact
+  module MatchingRules
+    describe ".merge" do
+      before do
+        allow(V3::Merge).to receive(:call)
+        allow(Merge).to receive(:call)
+        allow(Pact.configuration.error_stream).to receive(:puts)
+      end
+
+      let(:object) { double('object') }
+      let(:rules) { double('rules') }
+      let(:options) { { pact_specification_version: Pact::SpecificationVersion.new(pact_specification_version) } }
+
+      subject { MatchingRules.merge(object, rules, options)}
+
+      context "when the pact_specification_version is nil" do
+        let(:pact_specification_version) { nil }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '1.'" do
+        let(:pact_specification_version) { "1.0" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version is with '1'" do
+        let(:pact_specification_version) { "1" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '2.'" do
+        let(:pact_specification_version) { "2.0" }
+
+        it "calls Merge" do
+          expect(Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '3.'" do
+        let(:pact_specification_version) { "3.0" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version starts with '4.'" do
+        let(:pact_specification_version) { "4.0" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+
+      context "when the pact_specification_version is with '11'" do
+        let(:pact_specification_version) { "11" }
+
+        it "calls V3::Merge" do
+          expect(V3::Merge).to receive(:call)
+          subject
+        end
+      end
+    end
+  end
+end

data/tasks/spec.rake

@@ -12,4 +12,3 @@ task :spec_with_active_support => [:set_active_support_on] do
 end
 
 task :default => [:spec, :spec_with_active_support]
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-21 00:00:00.000000000 Z
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -268,6 +268,7 @@ files:
 - lib/pact/consumer_contract/consumer_contract.rb
 - lib/pact/consumer_contract/file_name.rb
 - lib/pact/consumer_contract/headers.rb
+- lib/pact/consumer_contract/http_consumer_contract_parser.rb
 - lib/pact/consumer_contract/interaction.rb
 - lib/pact/consumer_contract/pact_file.rb
 - lib/pact/consumer_contract/query.rb
@@ -302,6 +303,7 @@ files:
 - lib/pact/matching_rules/extract.rb
 - lib/pact/matching_rules/jsonpath.rb
 - lib/pact/matching_rules/merge.rb
+- lib/pact/matching_rules/v3/merge.rb
 - lib/pact/reification.rb
 - lib/pact/rspec.rb
 - lib/pact/shared/active_support_support.rb
@@ -314,6 +316,7 @@ files:
 - lib/pact/shared/request.rb
 - lib/pact/shared/text_differ.rb
 - lib/pact/something_like.rb
+- lib/pact/specification_version.rb
 - lib/pact/support.rb
 - lib/pact/support/version.rb
 - lib/pact/symbolize_keys.rb
@@ -323,6 +326,8 @@ files:
 - script/release.sh
 - script/update-pact-specification-v2
 - spec/fixtures/interaction-with-matching-rules.json
+- spec/fixtures/pact-http-v2.json
+- spec/fixtures/pact-http-v3.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
 - spec/lib/pact/array_like_spec.rb
 - spec/lib/pact/configuration_spec.rb
@@ -331,6 +336,7 @@ files:
 - spec/lib/pact/consumer_contract/consumer_contract_spec.rb
 - spec/lib/pact/consumer_contract/file_name_spec.rb
 - spec/lib/pact/consumer_contract/headers_spec.rb
+- spec/lib/pact/consumer_contract/http_consumer_contract_parser_spec.rb
 - spec/lib/pact/consumer_contract/interaction_spec.rb
 - spec/lib/pact/consumer_contract/pact_file_spec.rb
 - spec/lib/pact/consumer_contract/query_hash_spec.rb
@@ -357,6 +363,8 @@ files:
 - spec/lib/pact/matchers/unix_diff_formatter_spec.rb
 - spec/lib/pact/matching_rules/extract_spec.rb
 - spec/lib/pact/matching_rules/merge_spec.rb
+- spec/lib/pact/matching_rules/v3/merge_spec.rb
+- spec/lib/pact/matching_rules_spec.rb
 - spec/lib/pact/reification_spec.rb
 - spec/lib/pact/shared/dsl_spec.rb
 - spec/lib/pact/shared/form_differ_spec.rb
@@ -420,6 +428,8 @@ specification_version: 4
 summary: Shared code for Pact gems
 test_files:
 - spec/fixtures/interaction-with-matching-rules.json
+- spec/fixtures/pact-http-v2.json
+- spec/fixtures/pact-http-v3.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
 - spec/lib/pact/array_like_spec.rb
 - spec/lib/pact/configuration_spec.rb
@@ -428,6 +438,7 @@ test_files:
 - spec/lib/pact/consumer_contract/consumer_contract_spec.rb
 - spec/lib/pact/consumer_contract/file_name_spec.rb
 - spec/lib/pact/consumer_contract/headers_spec.rb
+- spec/lib/pact/consumer_contract/http_consumer_contract_parser_spec.rb
 - spec/lib/pact/consumer_contract/interaction_spec.rb
 - spec/lib/pact/consumer_contract/pact_file_spec.rb
 - spec/lib/pact/consumer_contract/query_hash_spec.rb
@@ -454,6 +465,8 @@ test_files:
 - spec/lib/pact/matchers/unix_diff_formatter_spec.rb
 - spec/lib/pact/matching_rules/extract_spec.rb
 - spec/lib/pact/matching_rules/merge_spec.rb
+- spec/lib/pact/matching_rules/v3/merge_spec.rb
+- spec/lib/pact/matching_rules_spec.rb
 - spec/lib/pact/reification_spec.rb
 - spec/lib/pact/shared/dsl_spec.rb
 - spec/lib/pact/shared/form_differ_spec.rb