pact-support 1.6.6 → 1.7.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '039bcfb7e385f534c0944984d075e419376bbfbf'
-  data.tar.gz: 84b10dc7ddd4ccd6d266bc2f9b7d19a605a30a33
+  metadata.gz: ad9d08da6cd0f2b5a4916c2f5c12f7749aed29c7
+  data.tar.gz: 740000cf408626229d5cfd34d445dcf9856285fe
 SHA512:
-  metadata.gz: 70d1593f05cedc8a458fd33e9b4a607d43ac63dbb54c05312472e79c39f908f0b005facc50b68e9451ac0bd6638b9be258f91de490e32d2c1bdda209cc666e46
-  data.tar.gz: a6340f39c1da805ca5512551938dea1de7a1e7505196cb7ad455fa44ca1aebcf0ab981a53740974c127d10f3c1965db0a2f76a0bb331bf759785eddd638eb50e
+  metadata.gz: 618a7e49e43b611c6b7435f94bfe6bc5dba1162d33760a2e4c6643a8b088535354b7457d41e25e292573a87d3f6d126f3ea50f0a8005f4c3a80e7b8d480b0659
+  data.tar.gz: 7ebdf91b188ca969ecd0cfaf5bb5d516714f3e2096956cfe07c7389020f678ee0d196c03f5aaa6fa6195adf9eed681ffe0c5aadd5585e61610749e9526e74b5e

data/CHANGELOG.md

@@ -1,29 +1,3 @@
-<a name="v1.6.6"></a>
-### v1.6.6 (2018-07-25)
-
-
-#### Bug Fixes
-
-* correctly handle an 'each like' inside a 'like'	 ([7dc76dc](/../../commit/7dc76dc))
-
-
-<a name="v1.6.5"></a>
-### v1.6.5 (2018-07-23)
-
-
-#### Features
-
-* use 0 as the nil pact specification version	 ([88e4750](/../../commit/88e4750))
-* reify StringWithMatchingRules to a String	 ([a025dd3](/../../commit/a025dd3))
-* parse String response and request bodies to StringWithMatchingRules to support pact-xml	 ([a9fbb58](/../../commit/a9fbb58))
-* add custom contract parsers to front of pact parsers list so that customised parsers are tried first	 ([babc319](/../../commit/babc319))
-
-
-#### Bug Fixes
-
-* show a more helpful error when attempting to parse a URI that is not a pact	 ([a8ba1ed](/../../commit/a8ba1ed))
-
-
 <a name="v1.6.4"></a>
 ### v1.6.4 (2018-07-14)
 

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -14,8 +14,6 @@ require 'pact/consumer_contract/http_consumer_contract_parser'
 
 module Pact
 
-  class UnrecognizePactFormatError < ::Pact::Error; end
-
   class ConsumerContract
 
     include SymbolizeKeys
@@ -44,7 +42,7 @@ module Pact
       parsers.each do | parser |
         return parser.call(hash) if parser.can_parse?(hash)
       end
-      raise Pact::UnrecognizePactFormatError.new("This document does not use a recognised Pact format: #{hash}")
+      raise Pact::Error.new("No consumer contract parser found for hash: #{hash}")
     end
 
     def self.from_json string
@@ -54,8 +52,6 @@ module Pact
 
     def self.from_uri uri, options = {}
       from_json(Pact::PactFile.read(uri, options))
-    rescue UnrecognizePactFormatError
-      raise Pact::UnrecognizePactFormatError.new("This document does not use a recognised Pact format. Please check that #{uri} is a valid pact file.")
     end
 
     def self.maintain_backwards_compatiblity_with_producer_keys string

data/lib/pact/consumer_contract/interaction.rb

@@ -1,71 +1,150 @@
+require 'pact/consumer_contract/request'
+require 'pact/consumer_contract/response'
+require 'pact/symbolize_keys'
 require 'pact/shared/active_support_support'
-require 'pact/consumer_contract/interaction_parser'
+require 'pact/matching_rules'
+require 'pact/errors'
+require 'pact/specification_version'
+require 'pact/consumer_contract/string_with_matching_rules'
 
 module Pact
   class Interaction
     include ActiveSupportSupport
+      include SymbolizeKeys
 
-    attr_accessor :description, :request, :response, :provider_state
-
-    def initialize attributes = {}
-      @description = attributes[:description]
-      @request = attributes[:request]
-      @response = attributes[:response]
-      @provider_state = attributes[:provider_state] || attributes[:providerState]
-    end
-
-    def self.from_hash hash, options = {}
-      InteractionParser.call(hash, options)
-    end
-
-    def to_hash
-      {
-        description: description,
-        provider_state: provider_state,
-        request: request.to_hash,
-        response: response.to_hash
-      }
-    end
-
-    def http?
-      true
-    end
-
-    def validate!
-      raise Pact::InvalidInteractionError.new(self) unless description && request && response
-    end
-
-    def matches_criteria? criteria
-      criteria.each do | key, value |
-        unless match_criterion self.send(key.to_s), value
-          return false
+      attr_accessor :description, :request, :response, :provider_state
+
+      def initialize attributes = {}
+        @description = attributes[:description]
+        @request = attributes[:request]
+        @response = attributes[:response]
+        @provider_state = attributes[:provider_state] || attributes[:providerState]
+      end
+
+      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 = parse_v2_request(hash['request'], options)
+        response = parse_v2_response(hash['response'], options)
+        new(symbolize_keys(hash).merge(request: request, response: response))
+      end
+
+      def self.parse_v3_interaction hash, options
+        request = parse_v3_request(hash['request'], options)
+        response = parse_v3_response(hash['response'], options)
+        new(symbolize_keys(hash).merge(request: request, response: response))
+      end
+
+      def self.parse_v2_request request_hash, options
+        request_hash = Pact::MatchingRules.merge(request_hash, request_hash['matchingRules'], options)
+        Pact::Request::Expected.from_hash(request_hash)
+      end
+
+      def self.parse_v2_response response_hash, options
+        response_hash = Pact::MatchingRules.merge(response_hash, response_hash['matchingRules'], options)
+        Pact::Response.from_hash(response_hash)
+      end
+
+      def self.parse_v3_request request_hash, options
+        request_matching_rules = request_hash['matchingRules'] || {}
+        if request_hash['body'].is_a?(String)
+          parse_request_with_string_body(request_hash, request_matching_rules['body'] || {}, options)
+        else
+          parse_v3_request_with_non_string_body(request_hash, request_matching_rules, options)
+        end
+      end
+
+      def self.parse_request_with_string_body request_hash, request_matching_rules, options
+        string_with_matching_rules = StringWithMatchingRules.new(request_hash['body'], options[:pact_specification_version], request_matching_rules)
+        Pact::Request::Expected.from_hash(request_hash.merge('body' => string_with_matching_rules))
+      end
+
+      def self.parse_v3_response response_hash, options
+        response_matching_rules = response_hash['matchingRules'] || {}
+        if response_hash['body'].is_a?(String)
+          parse_response_with_string_body(response_hash, response_matching_rules['body'] || {}, options)
+        else
+          parse_v3_response_with_non_string_body(response_hash, response_matching_rules, options)
+        end
+      end
+
+      def self.parse_response_with_string_body response_hash, response_matching_rules, options
+        string_with_matching_rules = StringWithMatchingRules.new(response_hash['body'], options[:pact_specification_version], response_matching_rules)
+        Pact::Response.from_hash(response_hash.merge('body' => string_with_matching_rules))
+      end
+
+      def self.parse_v3_request_with_non_string_body request_hash, request_matching_rules, options
+        request_hash = request_hash.keys.each_with_object({}) do | key, new_hash |
+          new_hash[key] = Pact::MatchingRules.merge(request_hash[key], request_matching_rules[key], options)
+        end
+        Pact::Request::Expected.from_hash(request_hash)
+      end
+
+      def self.parse_v3_response_with_non_string_body response_hash, response_matching_rules, options
+        response_hash = response_hash.keys.each_with_object({}) do | key, new_hash |
+          new_hash[key] = Pact::MatchingRules.merge(response_hash[key], response_matching_rules[key], options)
+        end
+        Pact::Response.from_hash(response_hash)
+      end
+
+      def to_hash
+        {
+          description: description,
+          provider_state: provider_state,
+          request: request.to_hash,
+          response: response.to_hash
+        }
+      end
+
+      def http?
+        true
+      end
+
+      def validate!
+        raise Pact::InvalidInteractionError.new(self) unless description && request && response
+      end
+
+      def matches_criteria? criteria
+        criteria.each do | key, value |
+          unless match_criterion self.send(key.to_s), value
+            return false
+          end
         end
+        true
       end
-      true
-    end
 
-    def match_criterion target, criterion
-      target == criterion || (criterion.is_a?(Regexp) && criterion.match(target))
-    end
+      def match_criterion target, criterion
+        target == criterion || (criterion.is_a?(Regexp) && criterion.match(target))
+      end
 
-    def == other
-      other.is_a?(Interaction) && to_hash == other.to_hash
-    end
+      def == other
+        other.is_a?(Interaction) && to_hash == other.to_hash
+      end
 
-    def eq? other
-      self == other
-    end
+      def eq? other
+        self == other
+      end
 
-    def description_with_provider_state_quoted
-      provider_state ? "\"#{description}\" given \"#{provider_state}\"" : "\"#{description}\""
-    end
+      def description_with_provider_state_quoted
+        provider_state ? "\"#{description}\" given \"#{provider_state}\"" : "\"#{description}\""
+      end
 
-    def request_modifies_resource_without_checking_response_body?
-      request.modifies_resource? && response.body_allows_any_value?
-    end
+      def request_modifies_resource_without_checking_response_body?
+        request.modifies_resource? && response.body_allows_any_value?
+      end
 
-    def to_s
-      to_hash.to_s
-    end
-  end
+      def to_s
+        to_hash.to_s
+      end
+
+      def self.is_xml? body
+        body.is_a?(String) && body.start_with?("<")
+      end
+   end
 end

data/lib/pact/consumer_contract/pact_file.rb

@@ -40,7 +40,7 @@ module Pact
     end
 
     private
-
+    
     def local? uri
       !uri.start_with?("http://", "https://")
     end
@@ -74,7 +74,7 @@ module Pact
         end
       end
     end
-
+    
     def get_remote(uri, options)
       request = Net::HTTP::Get.new(uri)
       request.basic_auth(options[:username], options[:password]) if options[:username]

data/lib/pact/matching_rules/merge.rb

@@ -92,7 +92,7 @@ module Pact
 
       def handle_match_type object, path, rules
         log_used_rule(path, 'match', 'type')
-        Pact::SomethingLike.new(recurse(object, path))
+        Pact::SomethingLike.new(object)
       end
 
       def handle_regex object, path, rules

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

@@ -18,15 +18,15 @@ module Pact
 
         def call
           return @expected if @matching_rules.nil? || @matching_rules.empty?
-          recurse(@expected, @root_path).tap { log_ignored_rules }
+          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, rules), new_matching_rules |
-            new_matching_rules[JsonPath.new(path).to_s] = Marshal.load(Marshal.dump(rules)) # simplest way to deep clone
+          matching_rules.each_with_object({}) do | (path, rule), new_matching_rules |
+            new_matching_rules[JsonPath.new(path).to_s] = rule
           end
         end
 
@@ -47,14 +47,14 @@ module Pact
         end
 
         def recurse_array array, path
-
-          parent_match_rule = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first.delete('match')
           array_like_children_path = "#{path}[*]*"
-          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.delete('match')
-          min = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first && @matching_rules[path]['matchers'].first.delete('min')
+          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 = []
@@ -82,46 +82,30 @@ module Pact
           elsif rules['regex']
             handle_regex(object, path, rules)
           else
-            #log_ignored_rules(path, rules, {})
+            log_ignored_rules(path, rules, {})
             object
           end
         end
 
         def handle_match_type object, path, rules
-          rules.delete('match')
-          Pact::SomethingLike.new(recurse(object, path))
+          log_ignored_rules(path, rules, {'match' => 'type'})
+          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))
+          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
-          @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
+        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 @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
+          if dup_rules.any?
+            $stderr.puts "WARN: Ignoring unsupported matching rules #{dup_rules} for path #{path}"
           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/specification_version.rb

@@ -14,5 +14,5 @@ module Pact
     end
   end
 
-  SpecificationVersion::NIL_VERSION = Pact::SpecificationVersion.new('0')
+  SpecificationVersion::NIL_VERSION = Pact::SpecificationVersion.new('')
 end

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "1.6.6"
+    VERSION = "1.7.0.alpha.1"
   end
 end

data/spec/integration/matching_rules_extract_and_merge_spec.rb

@@ -1,9 +1,7 @@
 require 'pact/term'
 require 'pact/something_like'
 require 'pact/matching_rules/extract'
-require 'pact/matching_rules/v3/extract'
 require 'pact/matching_rules/merge'
-require 'pact/matching_rules/v3/merge'
 require 'pact/reification'
 
 describe "converting Pact::Term and Pact::SomethingLike to matching rules and back again" do
@@ -12,9 +10,6 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
   let(:matching_rules) { Pact::MatchingRules::Extract.(expected) }
   let(:recreated_expected) { Pact::MatchingRules::Merge.(example, matching_rules)}
 
-  let(:recreated_expected_v3) { Pact::MatchingRules::V3::Merge.(example, matching_rules_v3) }
-  let(:matching_rules_v3) { Pact::MatchingRules::V3::Extract.(expected) }
-
   context "with a Pact::Term" do
     let(:expected) do
       {
@@ -26,29 +21,9 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy with v2 matching" do
-      expect(recreated_expected).to eq expected
-    end
-
-    it "recreates the same object hierarchy with v3 matching" do
-      expect(recreated_expected_v3).to eq expected
-    end
-  end
-
-  context "with a Pact::SomethingLike containing a Pact::ArrayLike" do
-    let(:expected) do
-      {
-        body: Pact::SomethingLike.new(children: Pact::ArrayLike.new("foo", min: 2))
-      }
-    end
-
-    it "recreates the same object hierarchy with v2 matching" do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates the same object hierarchy with v3 matching" do
-      expect(recreated_expected_v3).to eq expected
-    end
   end
 
   context "with a Pact::SomethingLike" do
@@ -62,13 +37,9 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy with v2 matching" do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates the same object hierarchy with v3 matching" do
-      expect(recreated_expected_v3).to eq expected
-    end
   end
 
   context "with a Pact::SomethingLike containing a Hash" do
@@ -90,13 +61,9 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy with v2 matching" do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates the same object hierarchy with v3 matching" do
-      expect(recreated_expected_v3).to eq expected
-    end
   end
 
   context "with a Pact::SomethingLike containing an Array" do
@@ -116,12 +83,8 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy with v2 matching" do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates the same object hierarchy with v3 matching" do
-      expect(recreated_expected_v3).to eq expected
-    end
   end
 end

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

@@ -3,26 +3,6 @@ require 'pact/consumer_contract'
 
 module Pact
   describe ConsumerContract do
-    describe "from_uri" do
-      context "when the URL does not point to a valid pact" do
-        subject { ConsumerContract.from_uri('spec/fixtures/not-a-pact.json') }
-
-        it "raises a helpful error" do
-          expect { subject }.to raise_error UnrecognizePactFormatError, /Please check that spec/
-        end
-      end
-    end
-
-    describe "from_hash" do
-      context "when the hash is not a valid pact" do
-        subject { ConsumerContract.from_hash({'foo' => 'bar'}) }
-
-        it "raises a helpful error" do
-          expect { subject }.to raise_error UnrecognizePactFormatError, 'This document does not use a recognised Pact format: {"foo"=>"bar"}'
-        end
-      end
-    end
-
     describe ".from_json" do
 
       let(:loaded_pact) { ConsumerContract.from_json(string) }

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

@@ -52,7 +52,58 @@ module Pact
         end
       end
 
+      describe "from_hash" do
+        context "when providerState has been used instead of provider_state" do
 
+          subject { Interaction.from_hash('response' => response, 'request' => request, 'providerState' => 'some state') }
+
+          it "recognises the provider state" do
+            expect(subject.provider_state).to eq 'some state'
+          end
+        end
+
+        context "when there are matching rules" do
+          let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
+
+          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)
+          end
+
+          it "merges the rules with the example for the response" do
+            expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
+          end
+        end
+
+        context "when the request body is a String" do
+          let(:hash) { { 'request' => request, 'response' => response } }
+          subject { Interaction.from_hash hash, pact_specification_version: Pact::SpecificationVersion.new("3") }
+
+          let(:request) { { 'method' => 'get', 'path' => 'path' , 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
+
+          it "returns an interaction with an StringWithMatchingRules in the request" do
+            expect(subject.request.body).to be_a(Pact::StringWithMatchingRules)
+            expect(subject.request.body).to eq "<xml></xml>"
+            expect(subject.request.body.matching_rules).to eq "foo" => "bar"
+            expect(subject.request.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
+          end
+        end
+
+        context "when the response body is a String" do
+          let(:hash) { { 'request' => request, 'response' => response } }
+          subject { Interaction.from_hash hash, pact_specification_version: Pact::SpecificationVersion.new("3") }
+
+          let(:response) { { 'status' => '200', 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
+
+          it "returns an interaction with an StringWithMatchingRules in the response" do
+            expect(subject.response.body).to be_a(Pact::StringWithMatchingRules)
+            expect(subject.response.body).to eq "<xml></xml>"
+            expect(subject.response.body.matching_rules).to eq "foo" => "bar"
+            expect(subject.response.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
+          end
+        end
+      end
 
       describe "request_modifies_resource_without_checking_response_body?" do
 

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

@@ -7,16 +7,10 @@ module Pact
         subject { Merge.(expected, matching_rules) }
 
         before do
-          allow($stderr).to receive(:puts) do | message |
-            raise "Was not expecting stderr to receive #{message.inspect} in this spec. This may be because of a missed rule deletion in Merge."
-          end
+          allow($stderr).to receive(:puts)
         end
 
         describe "no recognised rules" do
-          before do
-            allow($stderr).to receive(:puts)
-          end
-
           let(:expected) do
             {
               "_links" => {
@@ -71,10 +65,6 @@ module Pact
         end
 
         describe "type based matching" do
-          before do
-            allow($stderr).to receive(:puts)
-          end
-
           let(:expected) do
             {
               "name" => "Mary"
@@ -98,19 +88,11 @@ module Pact
             subject
           end
 
-          it "does not alter the passed in rules hash" do
-            original_matching_rules = JSON.parse(matching_rules.to_json)
-            subject
-            expect(matching_rules).to eq original_matching_rules
-          end
         end
 
         describe "regular expressions" do
-          describe "in a hash" do
-            before do
-              allow($stderr).to receive(:puts)
-            end
 
+          describe "in a hash" do
             let(:expected) do
               {
                 "_links" => {
@@ -293,10 +275,6 @@ module Pact
           end
 
           describe "with an example array with more than one item" do
-            before do
-              allow($stderr).to receive(:puts)
-            end
-
             let(:expected) do
               {
 
@@ -314,7 +292,7 @@ module Pact
               }
             end
 
-            it "doesn't warn about the min size being ignored" do
+            xit "doesn't warn about the min size being ignored" do
               expect(Pact.configuration.error_stream).to receive(:puts).once
               subject
             end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 1.6.6
+  version: 1.7.0.alpha.1
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-25 00:00:00.000000000 Z
+date: 2018-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -270,9 +270,6 @@ files:
 - 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/interaction_parser.rb
-- lib/pact/consumer_contract/interaction_v2_parser.rb
-- lib/pact/consumer_contract/interaction_v3_parser.rb
 - lib/pact/consumer_contract/pact_file.rb
 - lib/pact/consumer_contract/query.rb
 - lib/pact/consumer_contract/query_hash.rb
@@ -331,7 +328,6 @@ files:
 - script/release.sh
 - script/update-pact-specification-v2
 - spec/fixtures/interaction-with-matching-rules.json
-- spec/fixtures/not-a-pact.json
 - spec/fixtures/pact-http-v2.json
 - spec/fixtures/pact-http-v3.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
@@ -343,7 +339,6 @@ files:
 - 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_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
@@ -425,9 +420,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.11
@@ -436,7 +431,6 @@ specification_version: 4
 summary: Shared code for Pact gems
 test_files:
 - spec/fixtures/interaction-with-matching-rules.json
-- spec/fixtures/not-a-pact.json
 - spec/fixtures/pact-http-v2.json
 - spec/fixtures/pact-http-v3.json
 - spec/integration/matching_rules_extract_and_merge_spec.rb
@@ -448,7 +442,6 @@ test_files:
 - 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_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

data/lib/pact/consumer_contract/interaction_parser.rb

@@ -1,23 +0,0 @@
-require 'pact/specification_version'
-require 'pact/consumer_contract/interaction_v2_parser'
-require 'pact/consumer_contract/interaction_v3_parser'
-
-module Pact
-  class InteractionParser
-    def self.call 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
-      InteractionV2Parser.call(hash, options)
-    end
-
-    def self.parse_v3_interaction hash, options
-      InteractionV3Parser.call(hash, options)
-    end
-  end
-end

data/lib/pact/consumer_contract/interaction_v2_parser.rb

@@ -1,28 +0,0 @@
-require 'pact/consumer_contract/request'
-require 'pact/consumer_contract/response'
-require 'pact/symbolize_keys'
-require 'pact/matching_rules'
-require 'pact/errors'
-
-module Pact
-  class InteractionV2Parser
-
-    include SymbolizeKeys
-
-    def self.call hash, options
-      request = parse_request(hash['request'], options)
-      response = parse_response(hash['response'], options)
-      Interaction.new(symbolize_keys(hash).merge(request: request, response: response))
-    end
-
-    def self.parse_request request_hash, options
-      request_hash = Pact::MatchingRules.merge(request_hash, request_hash['matchingRules'], options)
-      Pact::Request::Expected.from_hash(request_hash)
-    end
-
-    def self.parse_response response_hash, options
-      response_hash = Pact::MatchingRules.merge(response_hash, response_hash['matchingRules'], options)
-      Pact::Response.from_hash(response_hash)
-    end
-  end
-end

data/lib/pact/consumer_contract/interaction_v3_parser.rb

@@ -1,61 +0,0 @@
-require 'pact/consumer_contract/request'
-require 'pact/consumer_contract/response'
-require 'pact/symbolize_keys'
-require 'pact/matching_rules'
-require 'pact/errors'
-require 'pact/consumer_contract/string_with_matching_rules'
-
-module Pact
-  class InteractionV3Parser
-
-    include SymbolizeKeys
-
-    def self.call hash, options
-      request = parse_request(hash['request'], options)
-      response = parse_response(hash['response'], options)
-      Interaction.new(symbolize_keys(hash).merge(request: request, response: response))
-    end
-
-    def self.parse_request request_hash, options
-      request_matching_rules = request_hash['matchingRules'] || {}
-      if request_hash['body'].is_a?(String)
-        parse_request_with_string_body(request_hash, request_matching_rules['body'] || {}, options)
-      else
-        parse_request_with_non_string_body(request_hash, request_matching_rules, options)
-      end
-    end
-
-    def self.parse_response response_hash, options
-      response_matching_rules = response_hash['matchingRules'] || {}
-      if response_hash['body'].is_a?(String)
-        parse_response_with_string_body(response_hash, response_matching_rules['body'] || {}, options)
-      else
-        parse_response_with_non_string_body(response_hash, response_matching_rules, options)
-      end
-    end
-
-    def self.parse_request_with_non_string_body request_hash, request_matching_rules, options
-      request_hash = request_hash.keys.each_with_object({}) do | key, new_hash |
-        new_hash[key] = Pact::MatchingRules.merge(request_hash[key], request_matching_rules[key], options)
-      end
-      Pact::Request::Expected.from_hash(request_hash)
-    end
-
-    def self.parse_response_with_non_string_body response_hash, response_matching_rules, options
-      response_hash = response_hash.keys.each_with_object({}) do | key, new_hash |
-        new_hash[key] = Pact::MatchingRules.merge(response_hash[key], response_matching_rules[key], options)
-      end
-      Pact::Response.from_hash(response_hash)
-    end
-
-    def self.parse_request_with_string_body request_hash, request_matching_rules, options
-      string_with_matching_rules = StringWithMatchingRules.new(request_hash['body'], options[:pact_specification_version], request_matching_rules)
-      Pact::Request::Expected.from_hash(request_hash.merge('body' => string_with_matching_rules))
-    end
-
-    def self.parse_response_with_string_body response_hash, response_matching_rules, options
-      string_with_matching_rules = StringWithMatchingRules.new(response_hash['body'], options[:pact_specification_version], response_matching_rules)
-      Pact::Response.from_hash(response_hash.merge('body' => string_with_matching_rules))
-    end
-  end
-end

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

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

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

@@ -1,62 +0,0 @@
-require 'pact/consumer_contract/interaction_parser'
-
-module Pact
-  describe InteractionParser do
-    describe ".call" do
-
-      let(:request) { {method: 'get', path: 'path'} }
-      let(:response) { {} }
-
-      context "when providerState has been used instead of provider_state" do
-
-        subject { InteractionParser.call('response' => response, 'request' => request, 'providerState' => 'some state') }
-
-        it "recognises the provider state" do
-          expect(subject.provider_state).to eq 'some state'
-        end
-      end
-
-      context "when there are matching rules" do
-        let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
-
-        subject { InteractionParser.call(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)
-        end
-
-        it "merges the rules with the example for the response" do
-          expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
-        end
-      end
-
-      context "when the request body is a String" do
-        let(:hash) { { 'request' => request, 'response' => response } }
-        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
-
-        let(:request) { { 'method' => 'get', 'path' => 'path' , 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
-
-        it "returns an interaction with an StringWithMatchingRules in the request" do
-          expect(subject.request.body).to be_a(Pact::StringWithMatchingRules)
-          expect(subject.request.body).to eq "<xml></xml>"
-          expect(subject.request.body.matching_rules).to eq "foo" => "bar"
-          expect(subject.request.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
-        end
-      end
-
-      context "when the response body is a String" do
-        let(:hash) { { 'request' => request, 'response' => response } }
-        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
-
-        let(:response) { { 'status' => '200', 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
-
-        it "returns an interaction with an StringWithMatchingRules in the response" do
-          expect(subject.response.body).to be_a(Pact::StringWithMatchingRules)
-          expect(subject.response.body).to eq "<xml></xml>"
-          expect(subject.response.body.matching_rules).to eq "foo" => "bar"
-          expect(subject.response.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
-        end
-      end
-    end
-  end
-end