pact-support 1.9.0 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2184e9575553c8a69f05b2a7665f5c70948b06a8
-  data.tar.gz: 896248de0a0c7c6d19d4ae7dfec15587929db2a8
+SHA256:
+  metadata.gz: f2ee65cf7dfde0e38da424b8c462877550c73d8eb4a32d141979e3571dd5b68b
+  data.tar.gz: 156429a88a8fa6e2af7650a4ab82541a375e81a7d7613f8c1fc35d21a0f0c18f
 SHA512:
-  metadata.gz: 890f78b04b7778391c0c2c7536c1ec153e080a48c4724f01be27ed77373e2fd472b8aed151e7420b4ccf9b4d453a6bb1907c1525c4295f8464eacccb1939684f
-  data.tar.gz: 43688a515f9719b74666fb584fa9b80ed1b0d4951d64a0b75964710373bbd089bced0962201dfc627288e9e26d761d58628fedb9fa8dd3b15bc77914c48450d1
+  metadata.gz: 3d14e51c30179bae9db88aa6b9dfc4c6780a9fb5aafd446e5e7b0914ccc1421f9d508a19d744864756b4a6b3809cc1579f0d344a169b1837f28ef6705f4b0448
+  data.tar.gz: 1e072929086a22a1e8a6ed2bc07e6a4d46fed8f666f177971596249357c641d1fc976c2751f73c03324963b81227bc0afa9324db905308cc8aabb4914c9d9b0a

data/CHANGELOG.md

@@ -1,3 +1,127 @@
+<a name="v1.15.0"></a>
+### v1.15.0 (2020-04-30)
+
+
+#### Bug Fixes
+
+* follow first redirect when fetching remote pact artifacts. (#80)	 ([c1df6dd](/../../commit/c1df6dd))
+
+
+<a name="v1.14.3"></a>
+### v1.14.3 (2020-04-06)
+
+
+#### Bug Fixes
+
+* do not blow up when there are no matchers	 ([ac70846](/../../commit/ac70846))
+
+
+<a name="v1.14.2"></a>
+### v1.14.2 (2020-03-25)
+
+
+#### Bug Fixes
+
+* don't blow up when there is a term inside an each like	 ([a565a56](/../../commit/a565a56))
+
+
+<a name="v1.14.1"></a>
+### v1.14.1 (2020-02-27)
+
+
+#### Bug Fixes
+
+* correctly parse matching rules for request paths	 ([cc15a72](/../../commit/cc15a72))
+
+
+<a name="v1.14.0"></a>
+### v1.14.0 (2020-02-13)
+
+
+#### Features
+
+* use certificates from SSL_CERT_FILE and SSL_CERT_DIR environment variables in HTTP connections	 ([bf1333d](/../../commit/bf1333d))
+
+
+<a name="v1.13.0"></a>
+### v1.13.0 (2020-01-24)
+
+
+#### Features
+
+* give each interaction an index when parsing the contract	 ([74e9568](/../../commit/74e9568))
+
+
+<a name="v1.12.1"></a>
+### v1.12.1 (2020-01-22)
+
+
+#### Bug Fixes
+
+* add missing require for pact/configuration	 ([bc4bbb5](/../../commit/bc4bbb5))
+
+
+<a name="v1.12.0"></a>
+### v1.12.0 (2019-09-26)
+
+
+#### Features
+
+* parse interaction _id from Pact Broker	 ([8d66a84](/../../commit/8d66a84))
+* support marking an interaction as writable/not writable (#75)	 ([e1fc347](/../../commit/e1fc347))
+* modernise gemspec	 ([c941d02](/../../commit/c941d02))
+
+
+#### Bug Fixes
+
+* add CHANGELOG to gem distribution	 ([35c9c48](/../../commit/35c9c48))
+
+
+<a name="v1.11.0"></a>
+### v1.11.0 (2019-06-18)
+
+
+#### Features
+
+* allow Integers and Floats to be considered equivalent when using type based matching.	 ([d8a70a1](/../../commit/d8a70a1))
+
+
+<a name="v1.10.3"></a>
+### v1.10.3 (2019-06-07)
+
+
+#### Bug Fixes
+
+* gracefully handle diff between an expected multipart form request and an actual application/json request	 ([8577d52](/../../commit/8577d52))
+
+
+<a name="v1.10.2"></a>
+### v1.10.2 (2019-05-20)
+
+
+#### Bug Fixes
+
+* allow proxy env var to be used when fetching pacts	 ([ebce481](/../../commit/ebce481))
+
+
+<a name="v1.10.1"></a>
+### v1.10.1 (2019-04-26)
+
+
+#### Bug Fixes
+
+* gracefully handle read only file system (eg RunKit)	 ([eeee528](/../../commit/eeee528))
+
+
+<a name="v1.10.0"></a>
+### v1.10.0 (2019-03-15)
+
+
+#### Bug Fixes
+
+* don't try and fix producer keys for a nil string	 ([94245c7](/../../commit/94245c7))
+
+
 <a name="v1.9.0"></a>
 ### v1.9.0 (2019-02-22)
 

data/lib/pact/configuration.rb

@@ -51,6 +51,7 @@ module Pact
     attr_accessor :error_stream
     attr_accessor :output_stream
     attr_accessor :pactfile_write_order
+    attr_accessor :treat_all_number_classes_as_equivalent # when using type based matching
 
     def self.default_configuration
       c = Configuration.new
@@ -61,6 +62,7 @@ module Pact
       c.output_stream = $stdout
       c.error_stream = $stderr
       c.pactfile_write_order = :chronological
+      c.treat_all_number_classes_as_equivalent = true
 
       c
     end
@@ -169,6 +171,11 @@ module Pact
       logger = ::Logger.new(log_path)
       logger.level = ::Logger::DEBUG
       logger
+    rescue Errno::EROFS
+      # So we can run on RunKit
+      logger = ::Logger.new($stdout)
+      logger.level = ::Logger::DEBUG
+      logger
     end
   end
 

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -59,7 +59,7 @@ module Pact
     end
 
     def self.maintain_backwards_compatiblity_with_producer_keys string
-      string.gsub('"producer":', '"provider":').gsub('"producer_state":', '"provider_state":')
+      string.gsub('"producer":', '"provider":').gsub('"producer_state":', '"provider_state":') if string
     end
 
     def find_interaction criteria
@@ -82,5 +82,16 @@ module Pact
       end
     end
 
+    def writable_interactions
+      interactions.reject do |interaction|
+        # For the sake of backwards compatibility, only reject interactions where 
+        # write_to_pact is explicitly set to false
+        interaction.respond_to?(:metadata) && 
+          !interaction.metadata.nil? && 
+          interaction.metadata.key?(:write_to_pact) &&
+          interaction.metadata[:write_to_pact] == false
+      end
+    end
+
   end
 end

data/lib/pact/consumer_contract/http_consumer_contract_parser.rb

@@ -13,7 +13,7 @@ module Pact
         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) }
+      interactions = hash[:interactions].each_with_index.collect { |hash, index| Interaction.from_hash({ index: index }.merge(hash), options) }
       ConsumerContract.new(
         :consumer => ServiceConsumer.from_hash(hash[:consumer]),
         :provider => ServiceProvider.from_hash(hash[:provider]),

data/lib/pact/consumer_contract/interaction.rb

@@ -5,7 +5,7 @@ module Pact
   class Interaction
     include ActiveSupportSupport
 
-    attr_accessor :description, :request, :response, :provider_state, :provider_states
+    attr_accessor :description, :request, :response, :provider_state, :provider_states, :metadata, :_id, :index
 
     def initialize attributes = {}
       @description = attributes[:description]
@@ -13,6 +13,9 @@ module Pact
       @response = attributes[:response]
       @provider_state = attributes[:provider_state] || attributes[:providerState]
       @provider_states = attributes[:provider_states]
+      @metadata = attributes[:metadata]
+      @_id = attributes[:_id]
+      @index = attributes[:index]
     end
 
     def self.from_hash hash, options = {}
@@ -30,6 +33,7 @@ module Pact
 
       h[:request] = request.to_hash
       h[:response] = response.to_hash
+      h[:metadata] = metadata
       h
     end
 

data/lib/pact/consumer_contract/interaction_v2_parser.rb

@@ -14,7 +14,11 @@ module Pact
       request = parse_request(hash['request'], options)
       response = parse_response(hash['response'], options)
       provider_states = parse_provider_states(hash['providerState'] || hash['provider_state'])
-      Interaction.new(symbolize_keys(hash).merge(request: request, response: response, provider_states: provider_states))
+      metadata = parse_metadata(hash['metadata'])
+      Interaction.new(symbolize_keys(hash).merge(request: request, 
+                                                 response: response, 
+                                                 provider_states: provider_states,
+                                                 metadata: metadata))
     end
 
     def self.parse_request request_hash, options
@@ -30,5 +34,9 @@ module Pact
     def self.parse_provider_states provider_state_name
       provider_state_name ? [Pact::ProviderState.new(provider_state_name)] : []
     end
+
+    def self.parse_metadata metadata_hash
+      symbolize_keys(metadata_hash)
+    end
   end
 end

data/lib/pact/consumer_contract/interaction_v3_parser.rb

@@ -19,7 +19,12 @@ module Pact
       if provider_states && provider_states.size > 1
         Pact.configuration.error_stream.puts("WARN: Currently only 1 provider state is supported. Ignoring ")
       end
-      Interaction.new(symbolize_keys(hash).merge(request: request, response: response, provider_states: provider_states, provider_state: provider_state))
+      metadata = parse_metadata(hash['metadata'])
+      Interaction.new(symbolize_keys(hash).merge(request: request,
+                                                 response: response,
+                                                 provider_states: provider_states,
+                                                 provider_state: provider_state,
+                                                 metadata: metadata))
     end
 
     def self.parse_request request_hash, options
@@ -42,14 +47,14 @@ module Pact
 
     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)
+        new_hash[key] = Pact::MatchingRules.merge(request_hash[key], look_up_matching_rules(key, request_matching_rules), 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)
+        new_hash[key] = Pact::MatchingRules.merge(response_hash[key], look_up_matching_rules(key, response_matching_rules), options)
       end
       Pact::Response.from_hash(response_hash)
     end
@@ -69,5 +74,19 @@ module Pact
         Pact::ProviderState.new(provider_state_hash['name'], provider_state_hash['params'])
       end
     end
+
+    def self.parse_metadata metadata_hash
+      symbolize_keys(metadata_hash)
+    end
+
+    def self.look_up_matching_rules(key, matching_rules)
+      # The matching rules for the path operate on the object itself and don't have sub paths
+      # Convert it into the format that Merge expects.
+      if key == 'path'
+        matching_rules[key] ? { '$.' => matching_rules[key] } : nil
+      else
+        matching_rules[key]
+      end
+    end
   end
 end

data/lib/pact/consumer_contract/pact_file.rb

@@ -33,6 +33,8 @@ module Pact
     def save_pactfile_to_tmp pact, name
       ::FileUtils.mkdir_p Pact.configuration.tmp_dir
       ::File.open(Pact.configuration.tmp_dir + "/#{name}", "w") { |file|  file << pact}
+    rescue Errno::EROFS => e
+      # do nothing, probably on RunKit
     end
 
     def render_pact(uri_string, options)
@@ -77,9 +79,38 @@ module Pact
 
     def get_remote(uri, options)
       request = Net::HTTP::Get.new(uri)
+      request = prepare_auth(request, options) if options[:username] || options[:token]
+
+      http = prepare_request(uri)
+      response = perform_http_request(http, request, options)
+
+      if response.is_a?(Net::HTTPRedirection)
+        uri = URI(response.header['location'])
+        req = Net::HTTP::Get.new(uri)
+        req = prepare_auth(req, options) if options[:username] || options[:token]
+
+        http = prepare_request(uri)
+        response = perform_http_request(http, req, options)
+      end
+      response
+    end
+
+    def prepare_auth(request, options)
       request.basic_auth(options[:username], options[:password]) if options[:username]
       request['Authorization'] = "Bearer #{options[:token]}" if options[:token]
-      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      request
+    end
+
+    def prepare_request(uri)
+      http = Net::HTTP.new(uri.host, uri.port, :ENV)
+      http.use_ssl = (uri.scheme == 'https')
+      http.ca_file = ENV['SSL_CERT_FILE'] if ENV['SSL_CERT_FILE'] && ENV['SSL_CERT_FILE'] != ''
+      http.ca_path = ENV['SSL_CERT_DIR'] if ENV['SSL_CERT_DIR'] && ENV['SSL_CERT_DIR'] != ''
+      http
+    end
+
+    def perform_http_request(http, request, options)
+      http.start do |http|
         http.open_timeout = options[:open_timeout] || OPEN_TIMEOUT
         http.read_timeout = options[:read_timeout] || READ_TIMEOUT
         http.request(request)

data/lib/pact/matchers/matchers.rb

@@ -1,3 +1,4 @@
+require 'pact/configuration'
 require 'pact/term'
 require 'pact/something_like'
 require 'pact/array_like'
@@ -20,23 +21,30 @@ module Pact
   # maintain backwards compatibility
 
   module Matchers
-
     NO_DIFF_AT_INDEX = NoDiffAtIndex.new
-    DEFAULT_OPTIONS = {allow_unexpected_keys: true, type: false}.freeze
     NO_DIFF = {}.freeze
+    NUMERIC_TYPES = %w[Integer Float Fixnum Bignum BigDecimal].freeze
+    DEFAULT_OPTIONS = {
+      allow_unexpected_keys: true,
+      type: false
+    }.freeze
 
     extend self
 
     def diff expected, actual, opts = {}
-      calculate_diff(expected, actual, DEFAULT_OPTIONS.merge(opts))
+      calculate_diff(expected, actual, DEFAULT_OPTIONS.merge(configurable_options).merge(opts))
     end
 
     def type_diff expected, actual, opts = {}
-      calculate_diff expected, actual, DEFAULT_OPTIONS.merge(opts).merge(type: true)
+      calculate_diff expected, actual, DEFAULT_OPTIONS.merge(configurable_options).merge(opts).merge(type: true)
     end
 
     private
 
+    def configurable_options
+      { treat_all_number_classes_as_equivalent: Pact.configuration.treat_all_number_classes_as_equivalent }
+    end
+
     def calculate_diff expected, actual, opts = {}
       options = DEFAULT_OPTIONS.merge(opts)
       case expected
@@ -112,7 +120,11 @@ module Pact
     def array_like_diff array_like, actual, options
       if actual.is_a? Array
         expected_size = [array_like.min, actual.size].max
-        expected_array = expected_size.times.collect{ Pact::Term.unpack_regexps(array_like.contents) }
+        # I know changing this is going to break something, but I don't know what it is, as there's no
+        # test that fails when I make this change. I know the unpack regexps was there for a reason however.
+        # Guess we'll have to change it and see!
+        # expected_array = expected_size.times.collect{ Pact::Term.unpack_regexps(array_like.contents) }
+        expected_array = expected_size.times.collect{ array_like.contents }
         actual_array_diff expected_array, actual, options.merge(:type => true)
       else
         Difference.new array_like.generate, actual, type_difference_message(array_like.generate, actual)
@@ -156,22 +168,22 @@ module Pact
 
     def object_diff expected, actual, options
       if options[:type]
-        type_difference expected, actual
+        type_difference expected, actual, options
       else
         exact_value_diff expected, actual, options
       end
     end
 
     def exact_value_diff expected, actual, options
-      if expected != actual
-        Difference.new expected, actual, value_difference_message(expected, actual, options)
-      else
+      if expected == actual
         NO_DIFF
+      else
+        Difference.new expected, actual, value_difference_message(expected, actual, options)
       end
     end
 
-    def type_difference expected, actual
-      if types_match? expected, actual
+    def type_difference expected, actual, options
+      if types_match? expected, actual, options
         NO_DIFF
       else
         TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual), type_difference_message(expected, actual)
@@ -186,8 +198,16 @@ module Pact
       actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
     end
 
-    def types_match? expected, actual
-      expected.class == actual.class || (is_boolean(expected) && is_boolean(actual))
+    # Make options optional to support existing monkey patches
+    def types_match? expected, actual, options = {}
+      expected.class == actual.class ||
+        (is_boolean(expected) && is_boolean(actual)) ||
+        (options.fetch(:treat_all_number_classes_as_equivalent, false) && is_number?(expected) && is_number?(actual))
+    end
+
+    def is_number? object
+      # deal with Fixnum and Integer without warnings by using string class names
+      NUMERIC_TYPES.include?(object.class.to_s)
     end
 
     def is_boolean object