hs-pact-support 1.17.1

data/lib/pact/array_like.rb

@@ -0,0 +1,49 @@
+require 'pact/symbolize_keys'
+module Pact
+  class ArrayLike
+    include SymbolizeKeys
+
+    attr_reader :contents
+    attr_reader :min
+
+    def initialize contents, options = {}
+      @contents = contents
+      @min = options[:min] || 1
+    end
+
+    def to_hash
+      {
+        :json_class => self.class.name,
+        :contents => contents,
+        :min => min
+      }
+    end
+
+    def as_json opts = {}
+      to_hash
+    end
+
+    def to_json opts = {}
+      as_json.to_json opts
+    end
+
+    def self.json_create hash
+      symbolized_hash = symbolize_keys(hash)
+      new(symbolized_hash[:contents], {min: symbolized_hash[:min]})
+    end
+
+    def eq other
+      self == other
+    end
+
+    def == other
+      other.is_a?(ArrayLike) && other.contents == self.contents && other.min == self.min
+    end
+
+    def generate
+      min.times.collect{ Pact::Reification.from_term contents }
+    end
+  end
+end
+
+

data/lib/pact/configuration.rb

@@ -0,0 +1,193 @@
+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
+
+  class Configuration
+
+    DIFF_FORMATTERS = {
+      :embedded => Pact::Matchers::EmbeddedDiffFormatter,
+      :unix => Pact::Matchers::UnixDiffFormatter,
+      :list => Pact::Matchers::ListDiffFormatter
+    }
+
+
+    class NilMatcher
+      def self.=~ other
+        other == nil ? 0 : nil
+      end
+    end
+
+    DIFF_FORMATTER_REGISTRATIONS = [
+      [/multipart\/form-data/, Pact::Matchers::MultipartFormDiffFormatter],
+      [/.*/, Pact::Matchers::UnixDiffFormatter],
+      [NilMatcher, Pact::Matchers::UnixDiffFormatter]
+    ]
+
+    DIFFERS = [
+      [/json/, Pact::JsonDiffer],
+      [/application\/x\-www\-form\-urlencoded/, Pact::FormDiffer],
+      [/multipart\/form-data/, Pact::MultipartFormDiffer],
+      [NilMatcher, Pact::TextDiffer],
+      [/.*/, Pact::TextDiffer]
+    ]
+
+
+    DEFAULT_DIFFER = Pact::TextDiffer
+
+    attr_accessor :pact_dir
+    attr_accessor :log_dir
+    attr_accessor :tmp_dir
+
+    attr_writer :logger
+
+    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
+      c.pact_dir = File.expand_path('./spec/pacts')
+      c.tmp_dir = File.expand_path('./tmp/pacts')
+      c.log_dir = default_log_dir
+
+      c.output_stream = $stdout
+      c.error_stream = $stderr
+      c.pactfile_write_order = :chronological
+      c.treat_all_number_classes_as_equivalent = true
+
+      c
+    end
+
+    def initialize
+      @differ_registrations = []
+      @diff_formatter_registrations = []
+    end
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    # Should this be deprecated in favour of register_diff_formatter???
+    def diff_formatter= diff_formatter
+      register_diff_formatter(/.*/, diff_formatter)
+      register_diff_formatter(nil, diff_formatter)
+    end
+
+    def register_diff_formatter content_type, diff_formatter
+      key = content_type_regexp_for content_type
+      @diff_formatter_registrations << [key, diff_formatter_for(diff_formatter)]
+    end
+
+    def diff_formatter_for_content_type content_type
+      diff_formatter_registrations.find{ | registration | registration.first =~ content_type }.last
+    end
+
+    def register_body_differ content_type, differ
+      key = content_type_regexp_for content_type
+      validate_differ differ
+      @differ_registrations << [key, differ]
+    end
+
+    def body_differ_for_content_type content_type
+      differ_registrations
+        .find{ | registration | registration.first =~ content_type }
+        .tap do |it|
+          if content_type.nil? && it.last == Pact::TextDiffer
+            error_stream.puts "WARN: No content type found, performing text diff on body"
+            logger.warn "No content type found, performing text diff on body"
+          end
+        end.last
+    end
+
+    def log_path
+      log_dir + "/pact.log"
+    end
+
+    def color_enabled
+      # Can't use ||= when the variable might be false, it will execute the expression if it's false
+      defined?(@color_enabled) ? @color_enabled : true
+    end
+
+    def color_enabled= color_enabled
+      @color_enabled = color_enabled
+    end
+
+    private
+
+    def diff_formatter_for input
+      if DIFF_FORMATTERS[input]
+        DIFF_FORMATTERS[input]
+      elsif input.respond_to?(:call)
+        input
+      else
+        raise "Pact diff_formatter needs to respond to call, or be in the preconfigured list: #{DIFF_FORMATTERS.keys}"
+      end
+    end
+
+    def validate_differ differ
+      if !differ.respond_to?(:call)
+        raise "Pact.configuration.register_body_differ expects a differ that is a lamda or a class/object that responds to call."
+      end
+    end
+
+    def content_type_regexp_for content_type
+      case content_type
+      when String then Regexp.new(/^#{Regexp.escape(content_type)}$/)
+      when Regexp then content_type
+      when nil then NilMatcher
+      else
+        raise "Invalid content type used to register a differ (#{content_type.inspect}). Please use a Regexp or a String."
+      end
+    end
+
+    def differ_registrations
+      @differ_registrations + DIFFERS
+    end
+
+    def diff_formatter_registrations
+      @diff_formatter_registrations + DIFF_FORMATTER_REGISTRATIONS
+    end
+
+    def self.default_log_dir
+      File.expand_path("./log")
+    end
+
+    #Would love a better way of determining this! It sure won't work on windows.
+    def is_rake_running?
+      `ps -ef | grep rake | grep #{Process.ppid} | grep -v 'grep'`.size > 0
+    end
+
+    def create_logger
+      FileUtils::mkdir_p log_dir
+      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
+
+  def self.configuration
+    @configuration ||= Configuration.default_configuration
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.clear_configuration
+    @configuration = nil
+  end
+end

data/lib/pact/consumer/request.rb

@@ -0,0 +1,27 @@
+require 'pact/shared/request'
+require 'pact/shared/key_not_found'
+
+module Pact
+  module Consumer
+    module Request
+      class Actual < Pact::Request::Base
+
+        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)
+          headers = sym_hash.fetch(:headers)
+          body = sym_hash.fetch(:body, nil)
+          new(method, path, headers, body, query)
+        end
+
+        protected
+
+        def self.key_not_found
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer_contract/consumer_contract.rb

@@ -0,0 +1,97 @@
+require 'pact/logging'
+require 'pact/something_like'
+require 'pact/symbolize_keys'
+require 'pact/term'
+require 'pact/shared/active_support_support'
+require 'date'
+require 'json/add/regexp'
+require 'open-uri'
+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
+    include Logging
+    include PactFile
+
+    attr_accessor :interactions
+    attr_accessor :consumer
+    attr_accessor :provider
+
+    def initialize(attributes = {})
+      @interactions = attributes[:interactions] || []
+      @consumer = attributes[:consumer]
+      @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)
+      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
+      deserialised_object = JSON.load(maintain_backwards_compatiblity_with_producer_keys(string))
+      from_hash(deserialised_object)
+    end
+
+    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
+      string.gsub('"producer":', '"provider":').gsub('"producer_state":', '"provider_state":') if string
+    end
+
+    def find_interaction criteria
+      interactions = find_interactions criteria
+      if interactions.size == 0
+        raise Pact::Error.new("Could not find interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}.")
+      elsif interactions.size > 1
+        raise Pact::Error.new("Found more than 1 interaction matching #{criteria} in pact file between #{consumer.name} and #{provider.name}.")
+      end
+      interactions.first
+    end
+
+    def find_interactions criteria
+      interactions.select{ | interaction| interaction.matches_criteria?(criteria)}
+    end
+
+    def each
+      interactions.each do | interaction |
+        yield interaction
+      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/file_name.rb

@@ -0,0 +1,22 @@
+module Pact
+  module FileName
+    extend self
+
+    def file_name consumer_name, provider_name, options = {}
+      pid = options[:unique] ? "-#{Process.pid}" : ''
+      "#{filenamify(consumer_name)}-#{filenamify(provider_name)}#{pid}.json"
+    end
+
+    def file_path consumer_name, provider_name, pact_dir = Pact.configuration.pact_dir, options = {}
+      File.join(windows_safe(pact_dir), file_name(consumer_name, provider_name, options))
+    end
+
+    def filenamify name
+      name.downcase.gsub(/\s/, '_')
+    end
+
+    def windows_safe(pact_dir)
+      pact_dir.gsub("\\", "/")
+    end
+  end
+end

data/lib/pact/consumer_contract/headers.rb

@@ -0,0 +1,51 @@
+module Pact
+
+  class DuplicateHeaderError < StandardError; end
+  class InvalidHeaderNameTypeError < StandardError; end
+
+  class Headers < Hash
+
+    def initialize hash = {}
+      hash.each_pair do | key, value |
+        check_for_invalid key
+        self[find_matching_key(key)] = value
+      end
+      self.freeze
+    end
+
+    def [] key
+      super(find_matching_key(key))
+    end
+
+    def fetch *args, &block
+      args[0] = find_matching_key(args[0]) if args.first
+      super(*args, &block)
+    end
+
+    def key? key
+      super(find_matching_key(key))
+    end
+
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+
+    private
+
+    def find_matching_key key
+      key = key.to_s
+      match = keys.find { |k| k.downcase == key.downcase }
+      match.nil? ? key : match
+    end
+
+    def check_for_invalid key
+      unless (String === key || Symbol === key)
+        raise InvalidHeaderNameTypeError.new "Header name (#{key}) must be a String or a Symbol."
+      end
+      if key? key
+        raise DuplicateHeaderError.new "Duplicate header found (#{find_matching_key(key)} and #{key}. Please use a comma separated single value when multiple headers with the same name are required."
+      end
+    end
+
+  end
+
+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].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]),
+        :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

@@ -0,0 +1,81 @@
+require 'pact/shared/active_support_support'
+require 'pact/consumer_contract/interaction_parser'
+
+module Pact
+  class Interaction
+    include ActiveSupportSupport
+
+    attr_accessor :description, :request, :response, :provider_state, :provider_states, :metadata, :_id, :index
+
+    def initialize attributes = {}
+      @description = attributes[:description]
+      @request = attributes[:request]
+      @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 = {}
+      InteractionParser.call(hash, options)
+    end
+
+    def to_hash
+      h = { description: description }
+
+      if provider_states
+        h[:provider_states] = provider_states.collect(&:to_hash)
+      else
+        h[:provider_state] = provider_state
+      end
+
+      h[:request] = request.to_hash
+      h[:response] = response.to_hash
+      h[:metadata] = metadata
+      h
+    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
+
+    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 eq? other
+      self == other
+    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 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,57 @@
+require 'pact/consumer_contract/request'
+require 'pact/consumer_contract/response'
+require 'pact/consumer_contract/provider_state'
+require 'pact/consumer_contract/query'
+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)
+      provider_states = parse_provider_states(hash['providerState'] || hash['provider_state'])
+      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
+      original_query_string = request_hash['query']
+      query_is_string = original_query_string.is_a?(String)
+      if query_is_string
+        request_hash = request_hash.dup
+        request_hash['query'] = Pact::Query.parse_string(request_hash['query'])
+      end
+      # The query has to be a hash at this stage for the matching rules to be applied
+      request_hash = Pact::MatchingRules.merge(request_hash, request_hash['matchingRules'], options)
+      # The original query string needs to be passed in to the constructor so it can be used
+      # when the request is replayed. Otherwise, we loose the square brackets because they get lost
+      # in the translation between string => structured object, as we don't know/store which
+      # query string convention was used.
+      if query_is_string
+        request_hash['query'] = Pact::QueryHash.new(request_hash['query'], original_query_string, Pact::Query.parsed_as_nested?(request_hash['query']))
+      end
+      request = 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
+
+    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