pact-support 0.0.1

data/lib/pact/consumer_contract/file_name.rb

@@ -0,0 +1,19 @@
+module Pact
+
+  module FileName
+
+    extend self
+
+    def file_name consumer_name, provider_name
+      "#{filenamify(consumer_name)}-#{filenamify(provider_name)}.json"
+    end
+
+    def file_path consumer_name, provider_name, pact_dir = Pact.configuration.pact_dir
+      File.join(pact_dir, file_name(consumer_name, provider_name))
+    end
+
+    def filenamify name
+      name.downcase.gsub(/\s/, '_')
+    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/interaction.rb

@@ -0,0 +1,73 @@
+require 'pact/consumer_contract/request'
+require 'pact/consumer_contract/response'
+require 'pact/symbolize_keys'
+require 'pact/shared/active_support_support'
+
+module Pact
+   class Interaction
+    include ActiveSupportSupport
+      include SymbolizeKeys
+
+      attr_accessor :description, :request, :response, :provider_state
+
+      def initialize attributes = {}
+        @description = attributes[:description]
+        @request = attributes[:request]
+        @response = attributes[:response]
+        @provider_state = attributes[:provider_state] || attributes[:providerState]
+      end
+
+      def self.from_hash hash
+        request = Pact::Request::Expected.from_hash(hash['request'])
+        response = Pact::Response.from_hash(hash['response'])
+        new(symbolize_keys(hash).merge({request: request, response: response}))
+      end
+
+      def to_hash
+        hash = { :description => @description }
+        hash[:provider_state] = @provider_state if @provider_state #Easier to read when provider state at top
+        hash.merge(:request => @request.as_json, :response => @response)
+      end
+
+      def as_json options = {}
+        fix_all_the_things to_hash
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      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) && as_json == other.as_json
+      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
+        JSON.pretty_generate(self)
+      end
+   end
+end

data/lib/pact/consumer_contract/pact_file.rb

@@ -0,0 +1,24 @@
+module Pact
+
+  module PactFile
+
+    extend self
+
+    def read uri, options = {}
+      pact = open(uri.to_s) { | file | file.read }
+      if options[:save_pactfile_to_tmp]
+        save_pactfile_to_tmp pact, ::File.basename(uri.to_s)
+      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}
+    end
+  end
+end

data/lib/pact/consumer_contract/request.rb

@@ -0,0 +1,73 @@
+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
+        diff({:method => method, :path => path}, {:method => actual_request.method, :path => actual_request.path}).empty?
+      end
+
+      def difference(actual_request)
+        request_diff = diff(to_hash_without_body, actual_request.to_hash_without_body)
+        unless body.is_a? NullExpectation
+          request_diff.merge(body_difference(actual_request.body))
+        else
+          request_diff
+        end
+      end
+
+      protected
+
+      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_difference(actual_body)
+        body_differ.call({:body => body}, {body: actual_body}, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
+      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,51 @@
+require 'pact/consumer_contract/headers'
+require 'pact/symbolize_keys'
+
+module Pact
+
+  class Response < Hash
+
+    include SymbolizeKeys
+
+    def initialize attributes
+      merge!(attributes)
+    end
+
+    def status
+      self[:status]
+    end
+
+    def headers
+      self[:headers]
+    end
+
+    def body
+      self[:body]
+    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?
+      !self.key?(:body)
+    end
+
+  end
+
+end

data/lib/pact/consumer_contract/service_consumer.rb

@@ -0,0 +1,28 @@
+require 'pact/symbolize_keys'
+
+module Pact
+  class ServiceConsumer
+    include SymbolizeKeys
+
+    attr_accessor :name
+    def initialize options
+      @name = options[:name]
+    end
+
+    def to_s
+      name
+    end
+
+    def to_hash
+      {name: name}
+    end
+
+    def as_json options = {}
+      to_hash
+    end
+
+    def self.from_hash hash
+      new(symbolize_keys(hash))
+    end
+  end
+end

data/lib/pact/consumer_contract/service_provider.rb

@@ -0,0 +1,28 @@
+require 'pact/symbolize_keys'
+
+module Pact
+  class ServiceProvider
+    include SymbolizeKeys
+
+    attr_accessor :name
+    def initialize options
+      @name = options[:name] || '[provider name unknown - please update the pact gem in the consumer project to the latest version and regenerate the pacts]'
+    end
+
+    def to_s
+      name
+    end
+
+    def to_hash
+      {name: name}
+    end
+
+    def as_json options = {}
+      to_hash
+    end
+
+    def self.from_hash hash
+      new(symbolize_keys(hash))
+    end
+  end
+end

data/lib/pact/logging.rb

@@ -0,0 +1,14 @@
+require 'logger'
+require_relative 'configuration'
+
+module Pact
+  module Logging
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def logger
+      Pact.configuration.logger
+    end
+  end
+end

data/lib/pact/matchers.rb

@@ -0,0 +1 @@
+require_relative 'matchers/matchers'

data/lib/pact/matchers/actual_type.rb

@@ -0,0 +1,16 @@
+require 'pact/matchers/expected_type'
+
+
+module Pact
+  class ActualType < Pact::ExpectedType
+
+    def initialize value
+      @value = value
+    end
+
+    def to_s
+      type
+    end
+
+  end
+end

data/lib/pact/matchers/base_difference.rb

@@ -0,0 +1,37 @@
+require 'pact/matchers/expected_type'
+require 'pact/matchers/actual_type'
+
+module Pact
+  module Matchers
+    class BaseDifference
+
+      attr_reader :expected, :actual
+
+      def initialize expected, actual
+        @expected = expected
+        @actual = actual
+      end
+
+      def any?
+        true
+      end
+
+      def empty?
+        false
+      end
+
+      def to_json options = {}
+        as_json.to_json(options)
+      end
+
+      def to_s
+        as_json.to_s
+      end
+
+      def == other
+        other.class == self.class && other.expected == expected && other.actual == actual
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/differ.rb

@@ -0,0 +1,153 @@
+# Ripped from RSpec::Expectations::Differ in rspec/expectations/differ.rb in rspec-expectations 2.14.3
+# Thank you kindly to the original author.
+# Needed to be able to turn the colour off, but can't set RSpec.configuration.color to false
+# once it has been set to true due to a "if bool" at the start of the color= method
+
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'pp'
+
+module Pact
+  module Matchers
+    class Differ
+
+      def initialize(color = false)
+        @color = color
+      end
+
+      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+      def diff_as_string(input_data_new, input_data_old)
+        output = matching_encoding("", input_data_old)
+        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
+        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
+        diffs = Diff::LCS.diff(data_old, data_new)
+        return output if diffs.empty?
+        oldhunk = hunk = nil
+        file_length_difference = 0
+        diffs.each do |piece|
+          begin
+            hunk = Diff::LCS::Hunk.new(
+              data_old, data_new, piece, context_lines, file_length_difference
+            )
+            file_length_difference = hunk.file_length_difference
+            next unless oldhunk
+            # Hunks may overlap, which is why we need to be careful when our
+            # diff includes lines of context. Otherwise, we might print
+            # redundant lines.
+            if (context_lines > 0) and hunk.overlaps?(oldhunk)
+              if hunk.respond_to?(:merge)
+                # diff-lcs 1.2.x
+                hunk.merge(oldhunk)
+              else
+                # diff-lcs 1.1.3
+                hunk.unshift(oldhunk)
+              end
+            else
+              output << matching_encoding(oldhunk.diff(format).to_s, output)
+            end
+          ensure
+            oldhunk = hunk
+            output << matching_encoding("\n", output)
+          end
+        end
+        #Handle the last remaining hunk
+        output << matching_encoding(oldhunk.diff(format).to_s,output)
+        output << matching_encoding("\n",output)
+        color_diff output
+      rescue Encoding::CompatibilityError
+        if input_data_new.encoding != input_data_old.encoding
+          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
+          "differs from the encoding of the expected string (#{input_data_new.encoding})"
+        else
+          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
+        end
+      end
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        if diff = diff_as_string(actual_as_string, expected_as_string)
+          color_diff diff
+        end
+      end
+
+      def red(text)
+        return text unless @color
+        color(text, 31)
+      end
+
+      def green(text)
+        return text unless @color
+        color(text, 32)
+      end
+
+    protected
+
+      def format
+        :unified
+      end
+
+      def context_lines
+        3
+      end
+
+      def color(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+
+      def blue(text)
+        color(text, 34)
+      end
+
+      def color_diff(diff)
+        return diff unless @color
+
+        diff.lines.map { |line|
+          case line[0].chr
+          when "+"
+            green line
+          when "-"
+            red line
+          when "@"
+            line[1].chr == "@" ? blue(line) : line
+          else
+            line
+          end
+        }.join
+      end
+
+      def object_to_string(object)
+        case object
+        when Hash
+          object.keys.sort_by { |k| k.to_s }.map do |key|
+            pp_key   = PP.singleline_pp(key, "")
+            pp_value = PP.singleline_pp(object[key], "")
+
+            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
+            #
+            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
+            # <# a: b: c:> not <# c: a: b:>
+            matching_encoding("#{pp_key} => #{pp_value}", key.to_s)
+          end.join(",\n")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object,"")
+        end
+      end
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string, source)
+          string.encode(source.encoding)
+        end
+      else
+        def matching_encoding(string, source)
+          string
+        end
+      end
+    end
+
+  end
+end
+