hs-pact-support 1.17.1

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/consumer_contract/string_with_matching_rules.rb

@@ -0,0 +1,17 @@
+module Pact
+  class StringWithMatchingRules < String
+    attr_reader :matching_rules
+    attr_reader :pact_specification_version
+
+    def initialize string, pact_specification_version, matching_rules = {}
+      super(string)
+      @matching_rules = matching_rules
+      @pact_specification_version = pact_specification_version
+    end
+
+    # How can we show the matching rules too?
+    def to_s
+      super
+    end
+  end
+end

data/lib/pact/consumer_contract.rb

@@ -0,0 +1 @@
+require 'pact/consumer_contract/consumer_contract'

data/lib/pact/errors.rb

@@ -0,0 +1,21 @@
+module Pact
+  class Error < ::StandardError
+  end
+
+  # Raised when the interaction is not defined correctly
+  class InvalidInteractionError < Error
+    def initialize(interaction)
+      super(build_message(interaction))
+    end
+
+    private
+
+    def build_message(interaction)
+      missing_attributes = []
+      missing_attributes << :description unless interaction.description
+      missing_attributes << :request unless interaction.request
+      missing_attributes << :response unless interaction.response
+      "Missing attributes: #{missing_attributes}"
+    end
+  end
+end

data/lib/pact/helpers.rb

@@ -0,0 +1,60 @@
+require 'pact/something_like'
+require 'pact/term'
+require 'pact/array_like'
+
+# Protected, exposed through Pact.term and Pact.like, and included in Pact::Consumer::RSpec
+
+module Pact
+  module Helpers
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def term arg1, arg2 = nil
+      case arg1
+      when Hash then Pact::Term.new(arg1)
+      when Regexp then Pact::Term.new(matcher: arg1, generate: arg2)
+      when String then Pact::Term.new(matcher: arg2, generate: arg1)
+      else
+        raise ArgumentError, "Cannot create a Pact::Term from arguments #{arg1.inspect} and #{arg2.inspect}. Please provide a Regexp and a String."
+      end
+    end
+
+    def like content
+      Pact::SomethingLike.new(content)
+    end
+
+    def each_like content, options = {}
+      Pact::ArrayLike.new(content, options)
+    end
+
+    def like_uuid uuid
+      Pact::Term.new(generate: uuid, matcher: /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/)
+    end
+
+    def like_datetime datetime
+      Pact::Term.new(generate: datetime, matcher: /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)$/)
+    end
+
+    def like_datetime_with_milliseconds datetime
+      Pact::Term.new(generate: datetime, matcher: /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d{3}([+-][0-2]\d:[0-5]\d|Z)$/)
+    end
+
+    alias_method :like_datetime_with_miliseconds, :like_datetime_with_milliseconds
+
+    def like_date date
+      Pact::Term.new(generate: date, matcher: /^\d{4}-[01]\d-[0-3]\d$/)
+    end
+
+    def like_datetime_rfc822 datetime
+      Pact::Term.new(
+        generate: datetime,
+        matcher: /(?x)(Mon|Tue|Wed|Thu|Fri|Sat|Sun),
+                        \s\d{2}\s
+                        (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)
+                        \s\d{4}\s\d{2}:\d{2}:\d{2}\s(\+|-)\d{4}/
+      )
+    end
+  end
+end

data/lib/pact/http/authorization_header_redactor.rb

@@ -0,0 +1,32 @@
+require "delegate"
+
+module Pact
+  module Http
+    class AuthorizationHeaderRedactor < SimpleDelegator
+      def puts(*args)
+        __getobj__().puts(*redact_args(args))
+      end
+
+      def print(*args)
+        __getobj__().puts(*redact_args(args))
+      end
+
+      def <<(*args)
+        __getobj__().send(:<<, *redact_args(args))
+      end
+
+      private
+
+      attr_reader :redactions
+
+      def redact_args(args)
+        args.collect{ | s| redact(s) }
+      end
+
+      def redact(string)
+        return string unless string.is_a?(String)
+        string.gsub(/Authorization: .*\\r\\n/, "Authorization: [redacted]\\r\\n")
+      end
+    end
+  end
+end

data/lib/pact/logging.rb

@@ -0,0 +1,14 @@
+require 'logger'
+require 'pact/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/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,39 @@
+require 'pact/matchers/expected_type'
+require 'pact/matchers/actual_type'
+
+module Pact
+  module Matchers
+    class BaseDifference
+
+      attr_reader :expected, :actual, :message
+      attr_writer :message
+
+      def initialize expected, actual, message = nil
+        @expected = expected
+        @actual = actual
+        @message = message
+      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
+

data/lib/pact/matchers/difference.rb

@@ -0,0 +1,13 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class Difference < BaseDifference
+
+      def as_json options = {}
+        {:EXPECTED => expected, :ACTUAL => actual}
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/difference_indicator.rb

@@ -0,0 +1,26 @@
+require 'pact/shared/active_support_support'
+
+module Pact
+  class DifferenceIndicator
+
+    include ActiveSupportSupport
+
+    def == other
+      other.class == self.class
+    end
+
+    def eql? other
+      self == other
+    end
+
+    def to_json options = {}
+      remove_unicode as_json.to_json(options)
+    end
+
+    def as_json options = {}
+      to_s
+    end
+
+  end
+
+end

data/lib/pact/matchers/embedded_diff_formatter.rb

@@ -0,0 +1,60 @@
+require 'pact/shared/active_support_support'
+require 'rainbow'
+
+module Pact
+  module Matchers
+    class EmbeddedDiffFormatter
+
+      include Pact::ActiveSupportSupport
+
+      EXPECTED = /"EXPECTED([A-Z_]*)":/
+
+      ACTUAL = /"ACTUAL([A-Z_]*)":/
+
+      attr_reader :diff, :colour
+
+      def initialize diff, options = {}
+        @diff = diff
+        @colour = options.fetch(:colour, false)
+      end
+
+      def self.call diff, options = {colour: Pact.configuration.color_enabled}
+        new(diff, options).call
+      end
+
+      def call
+        to_s
+      end
+
+      def to_hash
+        diff
+      end
+
+      def to_s
+        colourise_message_if_configured fix_json_formatting(diff.to_json)
+      end
+
+      def colourise_message_if_configured message
+        if colour
+          colourise_message message
+        else
+          message
+        end
+      end
+
+      def colourise_message message
+        message.split("\n").collect{| line | colourise(line) }.join("\n")
+      end
+
+      def colourise line
+        line.gsub(EXPECTED){|match| coloured_key match, :red }.gsub(ACTUAL){ | match | coloured_key match, :green }
+      end
+
+      def coloured_key match, colour
+        '"' + Rainbow(match.downcase.gsub(/^"|":$/,'')).color(colour) + '":'
+      end
+
+    end
+
+  end
+end

data/lib/pact/matchers/expected_type.rb

@@ -0,0 +1,35 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class ExpectedType < Pact::DifferenceIndicator
+
+    def initialize value
+      @value = value
+    end
+
+    def type
+      @value.class.name
+    end
+
+    def to_json options = {}
+      type
+    end
+
+    def as_json options = {}
+      type
+    end
+
+    def eq? other
+      self.class == other.class && other.type == type
+    end
+
+    def == other
+      eq? other
+    end
+
+    def to_s
+      type
+    end
+
+  end
+end

data/lib/pact/matchers/extract_diff_messages.rb

@@ -0,0 +1,76 @@
+# @api public. Used by lib/pact/provider/rspec/pact_broker_formatter.rb
+module Pact
+  module Matchers
+    class ExtractDiffMessages
+
+      attr_reader :diff
+
+      def initialize diff, options = {}
+        @diff = diff
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def to_hash
+        to_a
+      end
+
+      def call
+        to_a
+      end
+
+      def to_s
+        diff_messages(diff).join("\n")
+      end
+
+      def to_a
+        diff_messages(diff)
+      end
+
+      def diff_messages obj, path = [], messages = []
+        case obj
+        when Hash then handle_hash obj, path, messages
+        when Array then handle_array obj, path, messages
+        when BaseDifference then handle_difference obj, path, messages
+        when NoDiffAtIndex then nil
+        else
+          raise "Invalid diff, expected Hash, Array, NoDiffAtIndex or BaseDifference, found #{obj.class}"
+        end
+        messages
+      end
+
+      def handle_hash hash, path, messages
+        hash.each_pair do | key, value |
+          next_part = key =~ /\s/ ? key.inspect : key
+          diff_messages value, path + [".#{next_part}"], messages
+        end
+      end
+
+      def handle_array array, path, messages
+        array.each_with_index do | obj, index |
+          diff_messages obj, path + ["[#{index}]"], messages
+        end
+      end
+
+      def handle_difference difference, path, messages
+        if difference.message
+          message = difference.message
+          message = message.gsub("<path>", path_to_s(path))
+          message = message.gsub("<parent_path>", parent_path_to_s(path))
+          messages << message
+        end
+      end
+
+      def path_to_s path
+        "$" + path.join
+      end
+
+      def parent_path_to_s path
+        path_to_s(path[0..-2])
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/index_not_found.rb

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