hs-pact-support 1.17.1

data/lib/pact/consumer_contract/interaction_v3_parser.rb

@@ -0,0 +1,92 @@
+require 'pact/consumer_contract/request'
+require 'pact/consumer_contract/response'
+require 'pact/consumer_contract/provider_state'
+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)
+      provider_states = parse_provider_states(hash['providerStates'])
+      provider_state = provider_states.any? ? provider_states.first.name : nil
+      if provider_states && provider_states.size > 1
+        Pact.configuration.error_stream.puts("WARN: Currently only 1 provider state is supported. Ignoring ")
+      end
+      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
+      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], 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], look_up_matching_rules(key, response_matching_rules), 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
+
+    def self.parse_provider_states provider_states
+      (provider_states || []).collect do | provider_state_hash |
+        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

@@ -0,0 +1,157 @@
+require "net/http"
+require "pact/configuration"
+require "pact/http/authorization_header_redactor"
+
+module Pact
+  module PactFile
+    extend self
+
+    OPEN_TIMEOUT = 5
+    READ_TIMEOUT = 5
+    RETRY_LIMIT = 3
+
+    class HttpError < StandardError
+      attr_reader :uri, :response
+
+      def initialize(uri, response)
+        @uri, @response = uri, response
+        super("HTTP request failed: status=#{response.code}")
+      end
+    end
+
+    def read uri, options = {}
+      uri_string = uri.to_s
+      pact = render_pact(uri_string, options)
+      if options[:save_pactfile_to_tmp]
+        save_pactfile_to_tmp pact, ::File.basename(uri_string)
+      end
+      pact
+    rescue StandardError => e
+      $stderr.puts "Error reading file from #{uri}"
+      $stderr.puts "#{e.to_s} #{e.backtrace.join("\n")}"
+      raise e
+    end
+
+    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)
+      local?(uri_string) ? get_local(uri_string, options) : get_remote_with_retry(uri_string, options)
+    end
+
+    private
+
+    def local? uri
+      !uri.start_with?("http://", "https://")
+    end
+
+    def get_local(filepath, _)
+      File.read windows_safe(filepath)
+    end
+
+    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)
+          case
+          when success?(response)
+            return response.body
+          when retryable?(response)
+            raise HttpError.new(uri, response) if abort_retry?(i, options)
+            delay_retry(i + 1)
+            next
+          else
+            raise HttpError.new(uri, response)
+          end
+        rescue Timeout::Error => e
+          raise e if abort_retry?(i, options)
+          delay_retry(i + 1)
+        end
+      end
+    end
+
+    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, options)
+      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, options)
+        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]
+      request
+    end
+
+    def prepare_request(uri, options)
+      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.set_debug_output(Pact::Http::AuthorizationHeaderRedactor.new(Pact.configuration.output_stream)) if verbose?(options)
+      if disable_ssl_verification?
+        if verbose?(options)
+          Pact.configuration.output_stream.puts("SSL verification is disabled")
+        end
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      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)
+      end
+    end
+
+    def success?(response)
+      response.code.to_i == 200
+    end
+
+    def retryable?(response)
+      (500...600).cover?(response.code.to_i)
+    end
+
+    def abort_retry?(count, options)
+      count >= (options[:retry_limit] || RETRY_LIMIT)
+    end
+
+    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
+
+    def verbose?(options)
+      options[:verbose] || ENV['VERBOSE'] == 'true'
+    end
+
+    def disable_ssl_verification?
+      ENV['PACT_DISABLE_SSL_VERIFICATION'] == 'true' || ENV['PACT_BROKER_DISABLE_SSL_VERIFICATION'] == 'true'
+    end
+  end
+end

data/lib/pact/consumer_contract/provider_state.rb

@@ -0,0 +1,34 @@
+module Pact
+  class ProviderState
+
+    attr_reader :name, :params
+
+    def initialize name, params = {}
+      @name = name
+      @params = params
+    end
+
+    def self.from_hash(hash)
+      new(hash["name"], hash["params"])
+    end
+
+    def ==(other)
+      other.is_a?(Pact::ProviderState) && other.name == self.name && other.params == self.params
+    end
+
+    def to_hash
+      {
+        "name" => name,
+        "params" => params
+      }
+    end
+
+    def to_json(opts = {})
+      as_json(opts).to_json(opts)
+    end
+
+    def as_json(opts = {})
+      to_hash
+    end
+  end
+end

data/lib/pact/consumer_contract/query.rb

@@ -0,0 +1,138 @@
+require 'pact/consumer_contract/query_hash'
+require 'pact/consumer_contract/query_string'
+
+module Pact
+  class Query
+    DEFAULT_SEP = /[&;] */n
+    COMMON_SEP = { ";" => /[;] */n, ";," => /[;,] */n, "&" => /[&] */n }
+
+    class NestedQuery < Hash; end
+
+    def self.create query
+      if query.is_a? Hash
+        Pact::QueryHash.new(query)
+      else
+        Pact::QueryString.new(query)
+      end
+    end
+
+    def self.is_a_query_object?(object)
+      object.is_a?(Pact::QueryHash) || object.is_a?(Pact::QueryString)
+    end
+
+    def self.parsed_as_nested?(object)
+      object.is_a?(NestedQuery)
+    end
+
+    def self.parse_string query_string
+      parsed_query = parse_string_as_non_nested_query(query_string)
+
+      # If Rails nested params...
+      if parsed_query.keys.any?{ | key| key =~ /\[.*\]/ }
+        parse_string_as_nested_query(query_string)
+      else
+        parsed_query.each_with_object({}) do | (key, value), new_hash |
+          new_hash[key] = [*value]
+        end
+      end
+    end
+
+    # Ripped from Rack to avoid adding an unnecessary dependency, thank you Rack
+    # https://github.com/rack/rack/blob/649c72bab9e7b50d657b5b432d0c205c95c2be07/lib/rack/utils.rb
+    def self.parse_string_as_non_nested_query(qs, d = nil, &unescaper)
+      unescaper ||= method(:unescape)
+
+      params = {}
+
+      (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
+        next if p.empty?
+        k, v = p.split('=', 2).map!(&unescaper)
+
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+
+      return params.to_h
+    end
+
+    def self.parse_string_as_nested_query(qs, d = nil)
+      params = {}
+
+      unless qs.nil? || qs.empty?
+        (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
+          k, v = p.split('=', 2).map! { |s| unescape(s) }
+
+          normalize_params(params, k, v)
+        end
+      end
+
+      return NestedQuery[params.to_h]
+    end
+
+    def self.normalize_params(params, name, v)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      if k.empty?
+        if !v.nil? && name == "[]"
+          return Array(v)
+        else
+          return
+        end
+      end
+
+      if after == ''
+        params[k] = v
+      elsif after == "["
+        params[name] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params_hash_type?(params[k].last) && !params_hash_has_key?(params[k].last, child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      params
+    end
+
+    def self.params_hash_type?(obj)
+      obj.is_a?(Hash)
+    end
+
+    def self.params_hash_has_key?(hash, key)
+      return false if key =~ /\[\]/
+
+      key.split(/[\[\]]+/).inject(hash) do |h, part|
+        next h if part == ''
+        return false unless params_hash_type?(h) && h.key?(part)
+        h[part]
+      end
+
+      true
+    end
+
+    def self.unescape(s, encoding = Encoding::UTF_8)
+      URI.decode_www_form_component(s, encoding)
+    end
+  end
+end

data/lib/pact/consumer_contract/query_hash.rb

@@ -0,0 +1,89 @@
+require 'cgi'
+require 'pact/shared/active_support_support'
+require 'pact/symbolize_keys'
+
+module Pact
+  class QueryHash
+
+    include ActiveSupportSupport
+    include SymbolizeKeys
+
+    attr_reader :original_string
+
+    def initialize(query, original_string = nil, nested = false)
+      @hash = query.nil? ? query : convert_to_hash_of_arrays(query)
+      @original_string = original_string
+      @nested = nested
+    end
+
+    def nested?
+      @nested
+    end
+
+    def any_key_contains_square_brackets?
+      query.keys.any?{ |key| key =~ /\[.*\]/ }
+    end
+
+    def as_json(opts = {})
+      @hash
+    end
+
+    def to_json(opts = {})
+      as_json(opts).to_json(opts)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      QueryHash === other && other.query == query
+    end
+
+    # other will always be a QueryString, not a QueryHash, as it will have ben created
+    # from the actual query string.
+    def difference(other)
+      require 'pact/matchers' # avoid recursive loop between this file, pact/reification and pact/matchers
+
+      if any_key_contains_square_brackets?
+        other_query_hash_non_nested = Query.parse_string_as_non_nested_query(other.query)
+        Pact::Matchers.diff(query, convert_to_hash_of_arrays(other_query_hash_non_nested), allow_unexpected_keys: false)
+      else
+        other_query_hash = Query.parse_string(other.query)
+        Pact::Matchers.diff(query, symbolize_keys(convert_to_hash_of_arrays(other_query_hash)), allow_unexpected_keys: false)
+      end
+    end
+
+    def query
+      @hash
+    end
+
+    def to_s
+      @hash.inspect
+    end
+
+    def empty?
+      @hash && @hash.empty?
+    end
+
+    def to_hash
+      @hash
+    end
+
+    private
+
+    def convert_to_hash_of_arrays(query)
+      query.each_with_object({}) {|(k, v), hash| insert(hash, k, v) }
+    end
+
+    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
+    end
+  end
+end

data/lib/pact/consumer_contract/query_string.rb

@@ -0,0 +1,51 @@
+require 'pact/shared/active_support_support'
+
+module Pact
+  class QueryString
+
+    include ActiveSupportSupport
+
+    def initialize query
+      @query = query.nil? ? query : query.dup
+    end
+
+    def as_json opts = {}
+      @query
+    end
+
+    def to_json opts = {}
+      as_json(opts).to_json(opts)
+    end
+
+    def eql? other
+      self == other
+    end
+
+    def == other
+      QueryString === other && other.query == query
+    end
+
+    def difference(other)
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      Pact::Matchers.diff(query, other.query)
+    end
+
+    def query
+      @query
+    end
+
+    def to_s
+      @query
+    end
+
+    def empty?
+      @query && @query.empty?
+    end
+
+    # Naughty...
+    def nil?
+      @query.nil?
+    end
+
+  end
+end

data/lib/pact/consumer_contract/request.rb

@@ -0,0 +1,83 @@
+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
+      attr_accessor :options #Temporary hack
+
+      def self.from_hash(hash)
+        sym_hash = symbolize_keys hash
+        method = sym_hash.fetch(:method)
+        path = sym_hash.fetch(:path)
+        query = sym_hash.fetch(:query, key_not_found)
+        headers = sym_hash.fetch(:headers, key_not_found)
+        body = sym_hash.fetch(:body, key_not_found)
+        options = sym_hash.fetch(:options, {})
+        new(method, path, headers, body, query, options)
+      end
+
+      def initialize(method, path, headers, body, query, options = {})
+        super(method, path, headers, body, query)
+        @options = options
+      end
+
+      def matches?(actual_request)
+        difference(actual_request).empty?
+      end
+
+      def matches_route? actual_request
+        require 'pact/matchers' # avoid recusive loop between pact/reification, pact/matchers and this file
+        route = {:method => method.upcase, :path => path}
+        other_route = {:method => actual_request.method.upcase, :path => actual_request.path}
+        Pact::Matchers.diff(route, other_route).empty?
+      end
+
+      def difference(actual_request)
+        require 'pact/matchers' # avoid recusive loop between pact/reification, pact/matchers and this file
+        request_diff = Pact::Matchers.diff(to_hash_without_body_or_query, actual_request.to_hash_without_body_or_query)
+        request_diff.merge!(query_diff(actual_request.query))
+        request_diff.merge!(body_diff(actual_request.body))
+      end
+
+      protected
+
+      def query_diff actual_query
+        if specified?(:query)
+          query_diff = query.difference(actual_query)
+          query_diff.any? ? {query: query_diff} : {}
+        else
+          {}
+        end
+      end
+
+      def self.key_not_found
+        Pact::NullExpectation.new
+      end
+
+      private
+
+      # Options is a dirty hack to allow Condor to send extra keys in the request,
+      # as it's too much work to set up an exactly matching expectation.
+      # Need to implement a proper matching strategy and remove this.
+      # Do not rely on it!
+      def runtime_options
+        DEFAULT_OPTIONS.merge(symbolize_keys(options))
+      end
+
+      def body_diff(actual_body)
+        if specified?(:body)
+          body_difference = body_differ.call(body, actual_body, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
+          return { body: body_difference } if body_difference.any?
+        end
+        {}
+      end
+
+      def body_differ
+        Pact.configuration.body_differ_for_content_type content_type
+      end
+    end
+  end
+end

data/lib/pact/consumer_contract/response.rb

@@ -0,0 +1,58 @@
+require 'pact/consumer_contract/headers'
+require 'pact/symbolize_keys'
+
+module Pact
+
+  class Response < Hash
+
+    include SymbolizeKeys
+
+    ALLOWED_KEYS = [:status, :headers, :body, 'status', 'headers', 'body'].freeze
+    private_constant :ALLOWED_KEYS
+
+    def initialize attributes
+      merge!(attributes.reject{|key, value| !ALLOWED_KEYS.include?(key)})
+    end
+
+    def status
+      self[:status]
+    end
+
+    def headers
+      self[:headers]
+    end
+
+    def body
+      self[:body]
+    end
+
+    def specified? key
+      self.key?(key.to_sym)
+    end
+
+    def body_allows_any_value?
+      body_not_specified? || body_is_empty_hash?
+    end
+
+    def [] key
+      super key.to_sym
+    end
+
+    def self.from_hash hash
+      headers = Headers.new(hash[:headers] || hash['headers'] || {})
+      new(symbolize_keys(hash).merge(headers: headers))
+    end
+
+    private
+
+    def body_is_empty_hash?
+      body.is_a?(Hash) && body.empty?
+    end
+
+    def body_not_specified?
+      !specified?(:body)
+    end
+
+  end
+
+end