pact-support 1.4.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d63ce6f1b637b9ec8c1aa7c097631c13134c8085
-  data.tar.gz: e7f099a1364dd8e6ea4da06c5e6c15e6d1b83b38
+  metadata.gz: 2bbba1bbc7c4a2bf0c9bf83c335bca49f3911b33
+  data.tar.gz: 074b3a5fbf4ea09514e9a58d6af2d42d22739942
 SHA512:
-  metadata.gz: 6fab573b4105cb73ab146e406cfddbb56508160324e639b35a287f823a1b8c1570347768ef0198dbcf7454ea9dbfef7f0a53f9e3b48c9e22f430c5cd4d45548e
-  data.tar.gz: 424fdc09077746fda17301499934ef326c6f1af664baac0cc08e5f3d3c318d1047a3a7a95db7b90cf82d6139da774cb579fedb0a56929aba6fdc66dbaf15ca0d
+  metadata.gz: d15ba35784d2b6a93feeae4f77fd43f32ae2b07d3ece6b1b1a0367d9d05702a6a6dca9696e65287ba782c2ccfc495fc7fb3c8e8a34c57f525ddaf0702acdf6b2
+  data.tar.gz: 58ebf78d2b351442c2d3ac0ce8a2874949939acb51ca94b5aa7f0b261b1674da0ddd73db983e643267e9dd3b8c0117a80277090ac36690ff71ece9fbb694c118

data/CHANGELOG.md

@@ -1,3 +1,118 @@
+<a name="v1.7.0"></a>
+### v1.7.0 (2018-08-07)
+
+
+#### Features
+
+* add support for multipart/form	 ([8ed4332](/../../commit/8ed4332))
+
+
+<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)
+
+
+#### Bug Fixes
+
+* correctly serialize query params that use a Pact.each_like in pact file	 ([b3414dd](/../../commit/b3414dd))
+
+
+<a name="v1.6.3"></a>
+### v1.6.3 (2018-07-12)
+
+
+#### Bug Fixes
+
+* remove incorrect warning about ignoring unsupported matching rules for min => x	 ([50d5f6d](/../../commit/50d5f6d))
+* serialize ArrayLike in query params without wrapping another array around it	 ([b4a9ec7](/../../commit/b4a9ec7))
+
+
+<a name="v1.6.2"></a>
+### v1.6.2 (2018-05-31)
+
+
+#### Bug Fixes
+
+* **windows-path**
+  * prevent locale file paths to be parsed by URI to stop errors in windows paths like spaces in paths	 ([ecf64d6](/../../commit/ecf64d6))
+
+
+<a name="v1.6.1"></a>
+### v1.6.1 (2018-05-21)
+
+
+#### Bug Fixes
+
+* correctly read local windows pact file paths with backslashes	 ([e27bd38](/../../commit/e27bd38))
+
+
+<a name="v1.6.0"></a>
+### v1.6.0 (2018-04-03)
+
+
+#### Features
+
+* add support for writing v3 matching rules	 ([fc89696](/../../commit/fc89696))
+
+
+<a name="v1.5.2"></a>
+### v1.5.2 (2018-03-23)
+
+#### Bug Fixes
+
+* remove include of pact matchers in query string	 ([c478dff](/../../commit/c478dff))
+
+
+<a name="v1.5.1"></a>
+### v1.5.1 (2018-03-23)
+
+#### Bug Fixes
+
+* add missing require for pact matchers in query	 ([927d3b9](/../../commit/927d3b9))
+
+
+<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/configuration.rb

@@ -1,9 +1,11 @@
 require 'pact/matchers/embedded_diff_formatter'
 require 'pact/matchers/unix_diff_formatter'
 require 'pact/matchers/list_diff_formatter'
+require 'pact/matchers/multipart_form_diff_formatter'
 require 'pact/shared/json_differ'
 require 'pact/shared/text_differ'
 require 'pact/shared/form_differ'
+require 'pact/shared/multipart_form_differ'
 
 
 module Pact
@@ -24,6 +26,7 @@ module Pact
     end
 
     DIFF_FORMATTER_REGISTRATIONS = [
+      [/multipart\/form-data/, Pact::Matchers::MultipartFormDiffFormatter],
       [/.*/, Pact::Matchers::UnixDiffFormatter],
       [NilMatcher, Pact::Matchers::UnixDiffFormatter]
     ]
@@ -31,6 +34,7 @@ module Pact
     DIFFERS = [
       [/json/, Pact::JsonDiffer],
       [/application\/x\-www\-form\-urlencoded/, Pact::FormDiffer],
+      [/multipart\/form-data/, Pact::MultipartFormDiffer],
       [NilMatcher, Pact::TextDiffer],
       [/.*/, Pact::TextDiffer]
     ]

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -10,9 +10,12 @@ 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 UnrecognizePactFormatError < ::Pact::Error; end
+
   class ConsumerContract
 
     include SymbolizeKeys
@@ -29,13 +32,19 @@ module Pact
       @provider = attributes[:provider]
     end
 
+    def self.add_parser consumer_contract_parser
+      parsers.unshift(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::UnrecognizePactFormatError.new("This document does not use a recognised Pact format: #{hash}")
     end
 
     def self.from_json string
@@ -45,6 +54,8 @@ 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
@@ -54,9 +65,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

@@ -1,76 +1,71 @@
-require 'pact/consumer_contract/request'
-require 'pact/consumer_contract/response'
-require 'pact/symbolize_keys'
 require 'pact/shared/active_support_support'
-require 'pact/matching_rules'
-require 'pact/errors'
+require 'pact/consumer_contract/interaction_parser'
 
 module Pact
-   class Interaction
+  class Interaction
     include ActiveSupportSupport
-      include SymbolizeKeys
 
-      attr_accessor :description, :request, :response, :provider_state
+    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 initialize attributes = {}
+      @description = attributes[:description]
+      @request = attributes[:request]
+      @response = attributes[:response]
+      @provider_state = attributes[:provider_state] || attributes[:providerState]
+    end
 
-      def self.from_hash hash
-        request_hash = Pact::MatchingRules.merge(hash['request'], hash['request']['matchingRules'])
-        request = Pact::Request::Expected.from_hash(request_hash)
-        response_hash = Pact::MatchingRules.merge(hash['response'], hash['response']['matchingRules'])
-        response = Pact::Response.from_hash(response_hash)
-        new(symbolize_keys(hash).merge(request: request, response: response))
-      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 to_hash
+      {
+        description: description,
+        provider_state: provider_state,
+        request: request.to_hash,
+        response: response.to_hash
+      }
+    end
 
-      def validate!
-        raise Pact::InvalidInteractionError.new(self) unless description && request && response
-      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
+    def matches_criteria? criteria
+      criteria.each do | key, value |
+        unless match_criterion self.send(key.to_s), value
+          return false
         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
+  end
 end

data/lib/pact/consumer_contract/interaction_parser.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,61 @@
+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/lib/pact/consumer_contract/pact_file.rb

@@ -36,39 +36,25 @@ module Pact
     end
 
     def render_pact(uri_string, options)
-      uri_obj = URI(uri_string)
-      if uri_obj.userinfo
-        options[:username] = uri_obj.user unless options[:username]
-        options[:password] = uri_obj.password unless options[:password]
-      end
-      get(uri_obj, options)
+      local?(uri_string) ? get_local(uri_string, options) : get_remote_with_retry(uri_string, options)
     end
 
     private
 
-    def get(uri, options)
-      local?(uri) ?  get_local(uri, options) : get_remote_with_retry(uri, options)
-    end
-
     def local? uri
-      !uri.host
+      !uri.start_with?("http://", "https://")
     end
 
-    def get_local(uri, _)
-      File.read uri.to_s
-    end
-
-    def get_remote(uri, options)
-      request = Net::HTTP::Get.new(uri)
-      request.basic_auth(options[:username], options[:password]) if options[:username]
-      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
-        http.open_timeout = options[:open_timeout] || OPEN_TIMEOUT
-        http.read_timeout = options[:read_timeout] || READ_TIMEOUT
-        http.request(request)
-      end
+    def get_local(filepath, _)
+      File.read windows_safe(filepath)
     end
 
-    def get_remote_with_retry(uri, options)
+    def get_remote_with_retry(uri_string, options)
+      uri = URI(uri_string)
+      if uri.userinfo
+		options[:username] = uri.user unless options[:username]
+		options[:password] = uri.password unless options[:password]
+	  end
       ((options[:retry_limit] || RETRY_LIMIT) + 1).times do |i|
         begin
           response = get_remote(uri, options)
@@ -89,6 +75,16 @@ module Pact
       end
     end
 
+    def get_remote(uri, options)
+      request = Net::HTTP::Get.new(uri)
+      request.basic_auth(options[:username], options[:password]) if options[:username]
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.open_timeout = options[:open_timeout] || OPEN_TIMEOUT
+        http.read_timeout = options[:read_timeout] || READ_TIMEOUT
+        http.request(request)
+      end
+    end
+
     def success?(response)
       response.code.to_i == 200
     end
@@ -104,5 +100,9 @@ module Pact
     def delay_retry(count)
       Kernel.sleep(2 ** count * 0.3)
     end
+
+    def windows_safe(uri)
+      uri.start_with?("http") ? uri : uri.gsub("\\", File::SEPARATOR)
+    end
   end
 end

data/lib/pact/consumer_contract/query_hash.rb

@@ -56,6 +56,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