pact-support 0.0.1

data/lib/pact/matchers/unexpected_index.rb

@@ -0,0 +1,11 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class UnexpectedIndex < Pact::DifferenceIndicator
+
+    def to_s
+      '<index not to exist>'
+    end
+
+  end
+end

data/lib/pact/matchers/unexpected_key.rb

@@ -0,0 +1,11 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class UnexpectedKey < Pact::DifferenceIndicator
+
+    def to_s
+      '<key not to exist>'
+    end
+
+  end
+end

data/lib/pact/matchers/unix_diff_formatter.rb

@@ -0,0 +1,114 @@
+require 'pact/shared/jruby_support'
+require 'pact/matchers/differ'
+
+module Pact
+  module Matchers
+
+    class UnixDiffFormatter
+
+      include JRubySupport
+
+      def initialize diff, options = {}
+        @diff = diff
+        @colour = options.fetch(:colour, false)
+        @differ = Pact::Matchers::Differ.new(@colour)
+      end
+
+      def self.call diff, options = {colour: Pact.configuration.color_enabled}
+        new(diff, options).call
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        expected = generate_string(diff, :expected)
+        actual = generate_string(diff, :actual)
+        @differ.diff_as_string(actual, expected).lstrip + "\n" + key
+      end
+
+      private
+
+      def handle thing, target
+        case thing
+        when Hash then copy_hash(thing, target)
+        when Array then copy_array(thing, target)
+        when Difference then copy_diff(thing, target)
+        when TypeDifference then copy_diff(thing, target)
+        when RegexpDifference then copy_diff(thing, target)
+        when NoDiffIndicator then copy_no_diff(thing, target)
+        else copy_object(thing, target)
+        end
+      end
+
+      def generate_string diff, target
+        comparable = handle(diff, target)
+        begin
+          # Can't think of an elegant way to check if we can pretty generate other than to try it and maybe fail
+          fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
+        rescue JSON::GeneratorError
+          comparable.to_s
+        end
+      end
+
+      def copy_hash hash, target
+        hash.keys.each_with_object({}) do | key, new_hash |
+          value = handle hash[key], target
+          new_hash[key] = value unless (KeyNotFound === value || UnexpectedKey === value)
+        end
+      end
+
+      def copy_array array, target
+        array.each_index.each_with_object([]) do | index, new_array |
+          value = handle array[index], target
+          new_array[index] = value unless (UnexpectedIndex === value || IndexNotFound === value)
+        end
+      end
+
+      def copy_no_diff(thing, target)
+        thing
+      end
+
+      def copy_diff difference, target
+        if target == :actual
+          handle difference.actual, target
+        else
+          handle difference.expected, target
+        end
+      end
+
+      def copy_object object, target
+        if Regexp === object
+          RegexpDecorator.new(object)
+        else
+          object
+        end
+      end
+
+      def key
+        "Key: " + @differ.red("-") + @differ.red(" means \"expected, but was not found\". \n") +
+        @differ.green("     +") + @differ.green(" means \"actual, should not be found\". \n") +
+        "     Values where the expected matches the actual are not shown.\n"
+      end
+
+      class RegexpDecorator
+
+        def initialize regexp
+          @regexp = regexp
+        end
+
+        def to_json options={}
+          @regexp.inspect
+        end
+
+        def as_json
+          @regexp.inspect
+        end
+      end
+
+      attr_reader :diff
+    end
+
+  end
+end

data/lib/pact/reification.rb

@@ -0,0 +1,28 @@
+require 'randexp'
+
+module Pact
+  module Reification
+
+    def self.from_term(term)
+      case term
+      when Pact::Term, Regexp, Pact::SomethingLike
+        term.generate
+      when Hash
+        term.inject({}) do |mem, (key,term)|
+          mem[key] = from_term(term)
+        mem
+        end
+      when Array
+        term.inject([]) do |mem, term|
+          mem << from_term(term)
+          mem
+        end
+      when Pact::Request::Base
+        from_term(term.to_hash)
+      else
+        term
+      end
+    end
+
+  end
+end

data/lib/pact/rspec.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+# This is horrible, must work out a better way of doing this
+module Pact
+  module RSpec
+
+    def self.color_enabled?
+      if ::RSpec.configuration.respond_to?(:color_enabled?)
+        ::RSpec.configuration.color_enabled?(::RSpec.configuration.output_stream)
+      else
+        ::RSpec.configuration.color_enabled?
+      end
+    end
+
+    def self.formatter_class
+      if ::RSpec::Core::Formatters.respond_to?(:register)
+        require 'pact/provider/rspec/formatter_rspec_3'
+        Pact::Provider::RSpec::Formatter
+      else
+        require 'pact/provider/rspec/formatter_rspec_2'
+        Pact::Provider::RSpec::Formatter2
+      end
+
+    end
+
+    def self.full_description example
+      example.respond_to?(:full_description) ? example.full_description : example.example.full_description
+    end
+
+    def self.runner_defined?
+      defined?(::RSpec::Core::Runner)
+    end
+
+    def self.is_rspec_3
+      ::RSpec::Core::Formatters.respond_to?(:register)
+    end
+
+    def self.is_rspec_2
+      !is_rspec_3
+    end
+
+    def self.with_rspec_3
+      if is_rspec_3
+        yield
+      end
+    end
+
+    def self.with_rspec_2
+      if is_rspec_2
+        yield
+      end
+    end
+  end
+end

data/lib/pact/shared/active_support_support.rb

@@ -0,0 +1,51 @@
+module Pact
+  module ActiveSupportSupport
+
+    extend self
+
+    def fix_all_the_things thing
+      if thing.is_a?(Regexp)
+        fix_regexp(thing)
+      elsif thing.is_a?(Array)
+        thing.each{ | it | fix_all_the_things it }
+      elsif thing.is_a?(Hash)
+          thing.values.each{ | it | fix_all_the_things it }
+      elsif thing.class.name.start_with?("Pact")
+        thing.instance_variables.collect{ | iv_name | thing.instance_variable_get(iv_name)}.each do | iv |
+          fix_all_the_things iv
+        end
+      end
+      thing
+    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
+      def regexp.as_json options = {}
+        {:json_class => 'Regexp', "o" => self.options, "s" => self.source }
+      end
+      regexp
+    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.include?("\n")
+        json
+      else
+        JSON.pretty_generate(JSON.parse(json, create_additions: false))
+      end
+    end
+
+    def remove_unicode json
+      json.gsub(/\\u([0-9A-Za-z]{4})/) {|s| [$1.to_i(16)].pack("U")}
+    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)
+      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/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,15 @@
+require 'pact/matchers/matchers'
+
+module Pact
+  class JsonDiffer
+
+    extend Matchers
+
+
+    def self.call expected, actual, options = {}
+      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/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,97 @@
+require 'pact/matchers'
+require 'pact/symbolize_keys'
+require 'pact/consumer_contract/headers'
+
+module Pact
+
+  module Request
+
+    class Base
+      include Pact::Matchers
+      include Pact::SymbolizeKeys
+      extend Pact::Matchers
+
+      attr_reader :method, :path, :headers, :body, :query, :options
+
+      def initialize(method, path, headers, body, query)
+        @method = method.to_s
+        @path = path.chomp('/')
+        @headers = Hash === headers ? Headers.new(headers) : headers # Could be a NullExpectation - TODO make this more elegant
+        @body = body
+        @query = query
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_hash
+        hash = {
+          method: method,
+          path: path,
+        }
+
+        hash.merge!(query: query) if specified?(:query)
+        hash.merge!(headers: headers) if specified?(:headers)
+        hash.merge!(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 if headers.is_a? self.class.key_not_found.class
+        headers['Content-Type']
+      end
+
+      def modifies_resource?
+        http_method_modifies_resource? && body_specified?
+      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 specified? key
+        !(self.send(key).is_a? self.class.key_not_found.class)
+      end
+
+      def to_hash_without_body
+        keep_keys = [:method, :path, :headers, :query]
+        as_json.reject{ |key, value| !keep_keys.include? key }.tap do | hash |
+          hash[:method] = method.upcase
+        end
+      end
+
+      def display_path
+        path.empty? ? "/" : path
+      end
+
+      def display_query
+        (query.nil? || query.empty?) ? '' : "?#{Pact::Reification.from_term(query)}"
+      end
+
+    end
+  end
+end