hs-pact-support 1.17.1

data/lib/pact/shared/active_support_support.rb

@@ -0,0 +1,65 @@
+# The support you need when you use ActiveSupport
+
+module Pact
+  module ActiveSupportSupport
+    extend self
+
+    def fix_all_the_things thing
+      if defined?(ActiveSupport)
+        if thing.is_a?(Regexp)
+          fix_regexp(thing)
+        elsif thing.is_a?(Array)
+          thing.collect{ | it | fix_all_the_things it }
+        elsif thing.is_a?(Hash)
+          thing.each_with_object({}) { | (k, v), new_hash | new_hash[k] = fix_all_the_things(v) }
+        elsif thing.is_a?(Pact::Term)
+          # matcher Regexp is fixed in its own as_json method
+          thing
+        elsif thing.class.name.start_with?("Pact")
+          warn_about_regexp(thing)
+          thing
+        else
+          thing
+        end
+      else
+        thing
+      end
+    end
+
+    # ActiveSupport JSON overwrites (i.e. TRAMPLES) the json methods of the Regexp class directly
+    # (beneath its destructive hooves of destruction).
+    # This does not seem to be able to be undone without affecting the JSON serialisation in the
+    # calling project, so the best way I've found to fix this issue is to reattach the
+    # original as_json to the Regexp instances in the ConsumerContract before we write them to the
+    # pact file. If anyone can find a better way, please submit a pull request ASAP!
+    def fix_regexp regexp
+      {:json_class => 'Regexp', "o" => regexp.options, "s" => regexp.source }
+    end
+
+    # Having Active Support JSON loaded somehow kills the formatting of pretty_generate for objects.
+    # Don't ask me why, but it still seems to work for hashes, so the hacky work around is to
+    # reparse the generated JSON into a hash and pretty_generate that... sigh...
+    # Oh ActiveSupport, why....
+    def fix_json_formatting json
+      if json =~ /\{".*?":"/
+        JSON.pretty_generate(JSON.parse(json, create_additions: false))
+      else
+        json
+      end
+    end
+
+    def remove_unicode json
+      json.gsub(/\\u([0-9A-Za-z]{4})/) {|s| [$1.to_i(16)].pack("U")}
+    end
+
+    def warn_about_regexp(thing)
+      thing.instance_variables.each do | iv_name |
+        iv = thing.instance_variable_get(iv_name)
+        if iv.is_a?(Regexp)
+          require 'pact/configuration'
+          Pact.configuration.error_stream.puts("WARN: Instance variable #{iv_name} for class #{thing.class.name} is a Regexp and isn't been serialized properly. Please raise an issue at https://github.com/pact-foundation/pact-support/issues/new.")
+        end
+      end
+    end
+  end
+end

data/lib/pact/shared/dsl.rb

@@ -0,0 +1,76 @@
+module Pact
+
+  class DslDelegator
+
+    def initialize delegation_target
+      @delegation_target = delegation_target
+    end
+
+    def instance_eval_with_previous_context_available(*args, &block)
+      with_previous_context_available(block.binding) do
+        bind_block_as_instance_method_on_self(&block).call(*args)
+      end
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if delegation_target_responds_to? method
+        delegation_target.send(method, *args, &block)
+      else
+        previous_context.send(method, *args, &block)
+      end
+    end
+
+    private
+
+    attr_accessor :delegation_target, :previous_context
+
+    def bind_block_as_instance_method_on_self(&block)
+      create_instance_method_from_block(&block).bind(self)
+    end
+
+
+    def create_instance_method_from_block &block
+      meth = self.class.class_eval do
+        define_method :block_as_instance_method_, &block
+        meth = instance_method :block_as_instance_method_
+        remove_method :block_as_instance_method_
+        meth
+      end
+    end
+
+    def with_previous_context_available(binding, &block)
+      @previous_context = binding.eval('self')
+      result = block.call
+      @previous_context = nil
+      result
+    end
+
+    def delegation_target_responds_to?(method)
+      delegation_target.respond_to? method
+    end
+
+  end
+
+
+  # Ripped from http://blog.joecorcoran.co.uk/2013/09/04/simple-pattern-ruby-dsl
+  # and then fixed up by using http://www.skorks.com/2013/03/a-closure-is-not-always-a-closure-in-ruby/
+  # to access variables and methods defined in the calling scope.
+  module DSL
+    def build(*args, &block)
+      new_instance_of_delegation_target_class = self.new(*args)
+      dsl_delegator_class = self.const_get('DSL_DELEGATOR_CLASS')
+      dsl_delegator = dsl_delegator_class.new(new_instance_of_delegation_target_class)
+      dsl_delegator.instance_eval_with_previous_context_available(&block) if block
+      new_instance_of_delegation_target_class.finalize
+      new_instance_of_delegation_target_class
+    end
+
+    def dsl(&block)
+      dsl_delegator_class = Class.new(DslDelegator, &block)
+      self.const_set('DSL_DELEGATOR_CLASS', dsl_delegator_class)
+    end
+
+  end
+end

data/lib/pact/shared/form_differ.rb

@@ -0,0 +1,32 @@
+require 'uri'
+
+module Pact
+  class FormDiffer
+
+    def self.call expected, actual, options = {}
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      ::Pact::Matchers.diff to_hash(expected), to_hash(actual), options
+    end
+
+    def self.to_hash form_body
+      if form_body.is_a?(Hash)
+        ensure_values_are_arrays form_body
+      else
+        decode_www_form form_body
+      end
+    end
+
+    def self.ensure_values_are_arrays hash
+      hash.each_with_object({}) do | (key, value), h |
+        h[key.to_s] = [*value]
+      end
+    end
+
+    def self.decode_www_form string
+      URI.decode_www_form(string).each_with_object({}) do | (key, value), hash |
+        hash[key] ||= []
+        hash[key] << value
+      end
+    end
+  end
+end

data/lib/pact/shared/jruby_support.rb

@@ -0,0 +1,18 @@
+module Pact
+  module JRubySupport
+
+    # Under jruby, JSON.pretty_generate inserts a blank new line between the opening and closing
+    # brackets of an empty hash, like so:
+    # {
+    #   "empty": {
+    #
+    #   }
+    # }
+    # This screws up the UnixDiffFormatter, so we need to remove the blank lines.
+
+    def fix_blank_lines_in_empty_hashes json
+      json.gsub(/({\n)\n(\s*})/,'\1\2')
+    end
+
+  end
+end

data/lib/pact/shared/json_differ.rb

@@ -0,0 +1,10 @@
+module Pact
+  class JsonDiffer
+
+    # Delegates to https://github.com/pact-foundation/pact-support/blob/master/lib/pact/matchers/matchers.rb#L25
+    def self.call expected, actual, options = {}
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      ::Pact::Matchers.diff expected, actual, options
+    end
+  end
+end

data/lib/pact/shared/key_not_found.rb

@@ -0,0 +1,15 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class KeyNotFound < Pact::DifferenceIndicator
+
+    def to_s
+      "<key not found>"
+    end
+
+    def empty?
+      true
+    end
+  end
+
+end

data/lib/pact/shared/multipart_form_differ.rb

@@ -0,0 +1,16 @@
+require 'uri'
+require 'pact/shared/text_differ'
+
+module Pact
+  class MultipartFormDiffer
+    def self.call expected, actual, options = {}
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      expected_boundary = expected.split.first
+      actual_boundary = actual.split.first
+      actual_with_hardcoded_boundary = actual.gsub(actual_boundary, expected_boundary)
+      TextDiffer.call(expected, actual_with_hardcoded_boundary, options)
+    rescue StandardError
+      TextDiffer.call(expected, actual, options)
+    end
+  end
+end

data/lib/pact/shared/null_expectation.rb

@@ -0,0 +1,31 @@
+module Pact
+  class NullExpectation
+    def to_s
+      "<No expectation>"
+    end
+
+    def ==(other_object)
+     other_object.is_a? NullExpectation
+    end
+
+    def ===(other_object)
+     other_object.is_a? NullExpectation
+    end
+
+    def eql?(other_object)
+      self == other_object
+    end
+
+    def hash
+      2934820948209428748274238642672
+    end
+
+    def empty?
+      true
+    end
+
+    def nil?
+      true
+    end
+  end
+end

data/lib/pact/shared/request.rb

@@ -0,0 +1,106 @@
+require 'pact/symbolize_keys'
+require 'pact/consumer_contract/headers'
+require 'pact/consumer_contract/query'
+
+module Pact
+  module Request
+    class Base
+      include Pact::SymbolizeKeys
+
+      attr_reader :method, :path, :headers, :body, :query, :options
+
+      def initialize(method, path, headers, body, query)
+        @method = method.to_s
+        @path = path
+        @headers = Hash === headers ? Headers.new(headers) : headers # Could be a NullExpectation - TODO make this more elegant
+        @body = body
+        set_query(query)
+      end
+
+      def to_hash
+        hash = {
+          method: method,
+          path: path,
+        }
+        hash[:query] = query if specified?(:query)
+        hash[:headers] = headers if specified?(:headers)
+        hash[:body] = body if specified?(:body)
+        hash
+      end
+
+      def method_and_path
+        "#{method.upcase} #{full_path}"
+      end
+
+      def full_path
+        display_path + display_query
+      end
+
+      def content_type
+        return nil unless specified?(:headers) && headers['Content-Type']
+        Pact::Reification.from_term(headers['Content-Type'])
+      end
+
+      def content_type? content_type
+        self.content_type == content_type
+      end
+
+      def modifies_resource?
+        http_method_modifies_resource? && body_specified?
+      end
+
+      def specified? key
+        !is_unspecified?(self.send(key))
+      end
+
+      protected
+
+      # Not including DELETE, as we don't care about the resources updated state.
+      def http_method_modifies_resource?
+        ['PUT','POST','PATCH'].include?(method.to_s.upcase)
+      end
+
+      def self.key_not_found
+        raise NotImplementedError
+      end
+
+      def body_specified?
+        specified?(:body)
+      end
+
+      def is_unspecified? value
+        value.is_a? self.class.key_not_found.class
+      end
+
+      def to_hash_without_body_or_query
+        hash = {
+          method: method.upcase,
+          path: path
+        }
+        hash[:headers] = headers if specified?(:headers)
+        hash
+      end
+
+      def display_path
+        reified_path = Pact::Reification.from_term(path)
+        reified_path.empty? ? "/" : reified_path
+      end
+
+      def display_query
+        (query.nil? || query.empty?) ? '' : "?#{Pact::Reification.from_term(query)}"
+      end
+
+      def set_query(query)
+        @query = if is_unspecified?(query)
+          query
+        else
+          if Pact::Query.is_a_query_object?(query)
+            query
+          else
+            Pact::Query.create(query)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/shared/text_differ.rb

@@ -0,0 +1,11 @@
+
+module Pact
+  class TextDiffer
+
+    def self.call expected, actual, options = {}
+      require 'pact/matchers' # avoid recursive loop between this file and pact/matchers
+      ::Pact::Matchers.diff expected, actual, options
+    end
+
+  end
+end

data/lib/pact/something_like.rb

@@ -0,0 +1,49 @@
+require 'pact/symbolize_keys'
+module Pact
+
+  # Specifies that the actual object should be considered a match if
+  # it includes the same keys, and the values of the keys are of the same class.
+
+  class SomethingLike
+    include SymbolizeKeys
+
+    attr_reader :contents
+
+    def initialize contents
+      @contents = contents
+    end
+
+    def to_hash
+      {
+        :json_class => self.class.name,
+        :contents => contents
+      }
+    end
+
+    def as_json opts = {}
+      to_hash
+    end
+
+    def to_json opts = {}
+      as_json.to_json opts
+    end
+
+    def self.json_create hash
+      new(symbolize_keys(hash)[:contents])
+    end
+
+    def eq other
+      self == other
+    end
+
+    def == other
+      other.is_a?(SomethingLike) && other.contents == self.contents
+    end
+
+    def generate
+      contents
+    end
+  end
+end
+
+

data/lib/pact/specification_version.rb

@@ -0,0 +1,18 @@
+module Pact
+  class SpecificationVersion < Gem::Version
+
+    def major
+      segments.first
+    end
+
+    def === other
+      major && major == other
+    end
+
+    def after? other
+      major && other < major
+    end
+  end
+
+  SpecificationVersion::NIL_VERSION = Pact::SpecificationVersion.new('0')
+end

data/lib/pact/support/version.rb

@@ -0,0 +1,5 @@
+module Pact
+  module Support
+    VERSION = "1.17.1"
+  end
+end

data/lib/pact/support.rb

@@ -0,0 +1,12 @@
+require 'pact/support/version'
+require 'pact/consumer_contract'
+require 'pact/matchers'
+require 'pact/logging'
+require 'pact/term'
+require 'pact/helpers'
+require 'pact/configuration'
+require 'pact/reification'
+
+module Pact
+  include Pact::Helpers
+end

data/lib/pact/symbolize_keys.rb

@@ -0,0 +1,13 @@
+module Pact
+  module SymbolizeKeys
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def symbolize_keys hash
+      return nil if hash.nil?
+      hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+    end
+  end
+end

data/lib/pact/term.rb

@@ -0,0 +1,85 @@
+require 'pact/shared/active_support_support'
+require 'json/add/regexp'
+require 'pact/errors'
+
+module Pact
+  class Term
+
+    include Pact::ActiveSupportSupport
+
+    attr_reader :generate, :matcher
+
+    def self.json_create(obj)
+      new(generate: obj['data']['generate'], matcher: obj['data']['matcher'])
+    end
+
+    def self.unpack_regexps source
+      case source
+      when Pact::Term then source.matcher
+      when Array then unpack_regexps_from_array source
+      when Hash then unpack_regexps_from_hash source
+      else
+        source
+      end
+    end
+
+    def initialize(attributes = {})
+      @generate = attributes[:generate]
+      @matcher = attributes[:matcher]
+      raise Pact::Error.new("Please specify a matcher for the Term") unless @matcher != nil
+      raise Pact::Error.new("Please specify a value to generate for the Term") unless @generate != nil
+      raise Pact::Error.new("Value to generate \"#{@generate}\" does not match regular expression #{@matcher.inspect}") unless @generate =~ @matcher
+    end
+
+    def to_hash
+      { json_class: self.class.name, data: { generate: generate, matcher: fix_regexp(matcher) } }
+    end
+
+    def as_json(options = {})
+      to_hash
+    end
+
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    def match(literal)
+      literal.respond_to?(:to_s) ? matcher.match(literal.to_s) : nil
+    end
+
+    def ==(other)
+      return false unless other.respond_to?(:generate) && other.respond_to?(:matcher)
+      generate == other.generate && matcher == other.matcher
+    end
+
+    def to_s
+      "Pact::Term matcher: #{matcher.inspect}" + (generate.nil? ? "" : " generate: \"#{generate}\"")
+    end
+
+    def diff_with_actual(actual)
+      match(actual) ? nil : {
+        expected: self,
+        actual: actual
+      }
+    end
+
+    def empty?
+      false
+    end
+
+    private
+
+    def self.unpack_regexps_from_array source
+      source.each_with_object([]) do | item, destination |
+        destination << unpack_regexps(item)
+      end
+    end
+
+    def self.unpack_regexps_from_hash source
+      source.keys.each_with_object({}) do | key, destination |
+        destination[key] = unpack_regexps source[key]
+      end
+    end
+  end
+end

data/lib/tasks/pact.rake

@@ -0,0 +1,29 @@
+
+namespace :pact do
+
+  desc "Verifies the pact files configured in the pact_helper.rb against this service provider."
+  task :verify do
+
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    handle_verification_failure do
+      execute_pact_verify
+    end
+  end
+
+  desc "Verifies the pact at the given URI against this service provider."
+  task 'verify:at', :pact_uri do | t, args |
+    require 'rainbow'
+    require 'pact/tasks/task_helper'
+
+    include Pact::TaskHelper
+
+    abort(Rainbow("Please provide a pact URI. eg. rake pact:verify:at[../my-consumer/spec/pacts/my_consumer-my_provider.json]").red) unless args[:pact_uri]
+    handle_verification_failure do
+      execute_pact_verify args[:pact_uri]
+    end
+  end
+
+end