hs-pact-support 1.17.1

data/lib/pact/matchers/list_diff_formatter.rb

@@ -0,0 +1,103 @@
+require 'awesome_print' # The .ai method comes from awesome_print
+
+module Pact
+  module Matchers
+    class ListDiffFormatter
+
+      attr_reader :diff
+
+      def initialize diff, options = {}
+        @diff = diff
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def to_hash
+        diff
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        diff_descriptions(diff).join("\n")
+      end
+
+      def diff_descriptions obj, path = [], descriptions = []
+        case obj
+        when Hash then handle_hash obj, path, descriptions
+        when Array then handle_array obj, path, descriptions
+        when Difference then handle_difference obj, path, descriptions
+        when TypeDifference then handle_mismatched_type obj, path, descriptions
+        when RegexpDifference then handle_mismatched_regexp obj, path, descriptions
+        when NoDiffAtIndex then nil
+        else
+          raise "Invalid diff, expected Hash, Array, NoDiffAtIndex or Difference, found #{obj.class}"
+        end
+        descriptions
+      end
+
+      def handle_hash hash, path, descriptions
+        hash.each_pair do | key, value |
+          diff_descriptions value, path + [key.inspect], descriptions
+        end
+      end
+
+      def handle_array array, path, descriptions
+        array.each_with_index do | obj, index |
+          diff_descriptions obj, path + [index], descriptions
+        end
+      end
+
+      def handle_difference difference, path, descriptions
+        case difference.expected
+        when Pact::UnexpectedKey then handle_unexpected_key(difference, path, descriptions)
+        when Pact::UnexpectedIndex then handle_unexpected_index(difference, path, descriptions)
+        else
+          case difference.actual
+          when Pact::KeyNotFound then handle_key_not_found(difference, path, descriptions)
+          when Pact::IndexNotFound then handle_index_not_found(difference, path, descriptions)
+          else
+            handle_mismatched_value(difference, path, descriptions)
+          end
+        end
+      end
+
+      def handle_unexpected_index difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tArray contained unexpected item:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_value difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected:\n\t\t#{difference.expected.ai}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_regexp difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected to match:\n\t\t#{difference.expected.inspect}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_type difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected type:\n\t\t#{difference.expected}\n\tActual type:\n\t\t#{difference.actual}"
+      end
+
+      def handle_index_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing index with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_key_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing key with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_unexpected_key difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tHash contained unexpected key with value:\n\t\t#{difference.actual.ai}"
+      end
+
+      def path_to_s path
+        "[" + path.join("][") + "]"
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/matchers.rb

@@ -0,0 +1,285 @@
+require 'pact/configuration'
+require 'pact/term'
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/shared/null_expectation'
+require 'pact/shared/key_not_found'
+require 'pact/matchers/unexpected_key'
+require 'pact/matchers/unexpected_index'
+require 'pact/matchers/index_not_found'
+require 'pact/matchers/difference'
+require 'pact/matchers/regexp_difference'
+require 'pact/matchers/type_difference'
+require 'pact/matchers/expected_type'
+require 'pact/matchers/actual_type'
+require 'pact/matchers/no_diff_at_index'
+require 'pact/reification'
+
+module Pact
+  # Should be called Differs
+  # Note to self: Some people are using this module directly, so if you refactor it
+  # maintain backwards compatibility
+
+  module Matchers
+    NO_DIFF_AT_INDEX = NoDiffAtIndex.new
+    NO_DIFF = {}.freeze
+    NUMERIC_TYPES = %w[Integer Float Fixnum Bignum BigDecimal].freeze
+    DEFAULT_OPTIONS = {
+      allow_unexpected_keys: true,
+      type: false
+    }.freeze
+
+    extend self
+
+    def diff expected, actual, opts = {}
+      calculate_diff(expected, actual, DEFAULT_OPTIONS.merge(configurable_options).merge(opts))
+    end
+
+    def type_diff expected, actual, opts = {}
+      calculate_diff expected, actual, DEFAULT_OPTIONS.merge(configurable_options).merge(opts).merge(type: true)
+    end
+
+    private
+
+    def configurable_options
+      { treat_all_number_classes_as_equivalent: Pact.configuration.treat_all_number_classes_as_equivalent }
+    end
+
+    def calculate_diff expected, actual, opts = {}
+      options = DEFAULT_OPTIONS.merge(opts)
+      case expected
+      when Hash then hash_diff(expected, actual, options)
+      when Array then array_diff(expected, actual, options)
+      when Regexp then regexp_diff(expected, actual, options)
+      when Pact::SomethingLike then calculate_diff(expected.contents, actual, options.merge(:type => true))
+      when Pact::ArrayLike then array_like_diff(expected, actual, options)
+      when Pact::Term then term_diff(expected, actual, options)
+      else object_diff(expected, actual, options)
+      end
+    end
+
+    alias_method :structure_diff, :type_diff # Backwards compatibility
+
+    def term_diff term, actual, options
+      if actual.is_a?(String)
+        actual_term_diff term, actual, options
+      else
+        RegexpDifference.new term.matcher, actual, "Expected a String matching #{term.matcher.inspect} (like #{term.generate.inspect}) but got #{class_name_with_value_in_brackets(actual)} at <path>"
+      end
+    end
+
+    def actual_term_diff term, actual, options
+      if term.matcher.match(actual)
+        NO_DIFF
+      else
+        RegexpDifference.new term.matcher, actual, "Expected a String matching #{term.matcher.inspect} (like #{term.generate.inspect}) but got #{actual.inspect} at <path>"
+      end
+    end
+
+    def regexp_diff regexp, actual, options
+      if actual.is_a?(String)
+        actual_regexp_diff regexp, actual, options
+      else
+        RegexpDifference.new regexp, actual, "Expected a String matching #{regexp.inspect} but got #{class_name_with_value_in_brackets(actual)} at <path>"
+      end
+    end
+
+    def actual_regexp_diff regexp, actual, options
+      if regexp.match(actual)
+        NO_DIFF
+      else
+        RegexpDifference.new regexp, actual, "Expected a String matching #{regexp.inspect} but got #{short_description(actual)} at <path>"
+      end
+    end
+
+    def array_diff expected, actual, options
+      if actual.is_a? Array
+        actual_array_diff expected, actual, options
+      else
+        Difference.new Pact::Reification.from_term(expected), actual, type_difference_message(Pact::Reification.from_term(expected), actual)
+      end
+    end
+
+    def actual_array_diff expected, actual, options
+      difference = []
+      diff_found = false
+      length = [expected.length, actual.length].max
+      length.times do | index|
+        expected_item = expected.fetch(index, Pact::UnexpectedIndex.new)
+        actual_item = actual.fetch(index, Pact::IndexNotFound.new)
+        if (item_diff = calculate_diff(expected_item, actual_item, options)).any?
+          diff_found = true
+          difference << item_diff
+        else
+          difference << NO_DIFF_AT_INDEX
+        end
+      end
+      diff_found ? difference : NO_DIFF
+    end
+
+    def array_like_diff array_like, actual, options
+      if actual.is_a? Array
+        expected_size = [array_like.min, actual.size].max
+        # I know changing this is going to break something, but I don't know what it is, as there's no
+        # test that fails when I make this change. I know the unpack regexps was there for a reason however.
+        # Guess we'll have to change it and see!
+        # expected_array = expected_size.times.collect{ Pact::Term.unpack_regexps(array_like.contents) }
+        expected_array = expected_size.times.collect{ array_like.contents }
+        actual_array_diff expected_array, actual, options.merge(:type => true)
+      else
+        Difference.new array_like.generate, actual, type_difference_message(array_like.generate, actual)
+      end
+    end
+
+    def hash_diff expected, actual, options
+      if actual.is_a? Hash
+        actual_hash_diff expected, actual, options
+      else
+        Difference.new Pact::Reification.from_term(expected), actual, type_difference_message(Pact::Reification.from_term(expected), actual)
+      end
+    end
+
+    def actual_hash_diff expected, actual, options
+      hash_diff = expected.each_with_object({}) do |(key, expected_value), difference|
+        diff_at_key = calculate_diff_at_key(key, expected_value, actual, difference, options)
+        difference[key] = diff_at_key if diff_at_key.any?
+      end
+      hash_diff.merge(check_for_unexpected_keys(expected, actual, options))
+    end
+
+    def calculate_diff_at_key key, expected_value, actual, difference, options
+      actual_value = actual.fetch(key, Pact::KeyNotFound.new)
+      diff_at_key = calculate_diff(expected_value, actual_value, options)
+      if actual_value.is_a?(Pact::KeyNotFound)
+        diff_at_key.message = key_not_found_message(key, actual)
+      end
+      diff_at_key
+    end
+
+    def check_for_unexpected_keys expected, actual, options
+      if options[:allow_unexpected_keys]
+        NO_DIFF
+      else
+        (actual.keys - expected.keys).each_with_object({}) do | key, running_diff |
+          running_diff[key] = Difference.new(UnexpectedKey.new, actual[key], "Did not expect the key \"#{key}\" to exist at <parent_path>")
+        end
+      end
+    end
+
+    def object_diff expected, actual, options
+      if options[:type]
+        type_difference expected, actual, options
+      else
+        exact_value_diff expected, actual, options
+      end
+    end
+
+    def exact_value_diff expected, actual, options
+      if expected == actual
+        NO_DIFF
+      else
+        Difference.new expected, actual, value_difference_message(expected, actual, options)
+      end
+    end
+
+    def type_difference expected, actual, options
+      if types_match? expected, actual, options
+        NO_DIFF
+      else
+        TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual), type_difference_message(expected, actual)
+      end
+    end
+
+    def type_diff_expected_display expected
+      ExpectedType.new(expected)
+    end
+
+    def type_diff_actual_display actual
+      actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
+    end
+
+    # Make options optional to support existing monkey patches
+    def types_match? expected, actual, options = {}
+      expected.class == actual.class ||
+        (is_boolean(expected) && is_boolean(actual)) ||
+        (options.fetch(:treat_all_number_classes_as_equivalent, false) && is_number?(expected) && is_number?(actual))
+    end
+
+    def is_number? object
+      # deal with Fixnum and Integer without warnings by using string class names
+      NUMERIC_TYPES.include?(object.class.to_s)
+    end
+
+    def is_boolean object
+      object == true || object == false
+    end
+
+    def has_children? object
+      object.is_a?(Hash) || object.is_a?(Array)
+    end
+
+    def value_difference_message expected, actual, options = {}
+      case expected
+      when Pact::UnexpectedIndex
+        "Actual array is too long and should not contain #{short_description(actual)} at <path>"
+      else
+        case actual
+        when Pact::IndexNotFound
+          "Actual array is too short and should have contained #{short_description(expected)} at <path>"
+        else
+          "Expected #{short_description(expected)} but got #{short_description(actual)} at <path>"
+        end
+      end
+    end
+
+    def type_difference_message expected, actual
+      case expected
+      when Pact::UnexpectedIndex
+        "Actual array is too long and should not contain #{short_description(actual)} at <path>"
+      else
+        case actual
+        when Pact::IndexNotFound
+          "Actual array is too short and should have contained #{short_description(expected)} at <path>"
+        else
+          expected_desc = class_name_with_value_in_brackets(expected)
+          expected_desc.gsub!("(", "(like ")
+          actual_desc = class_name_with_value_in_brackets(actual)
+          "Expected #{expected_desc} but got #{actual_desc} at <path>"
+        end
+      end
+    end
+
+    def class_name_with_value_in_brackets object
+      object_desc = has_children?(object) && object.inspect.length < 100 ? "" : " (#{object.inspect})"
+      object_desc = if object.nil?
+        "nil"
+      else
+        "#{class_description(object)}#{object_desc}"
+      end
+    end
+
+    def key_not_found_message key, actual
+      hint = actual.any? ? "(keys present are: #{actual.keys.join(", ")})" : "in empty Hash"
+      "Could not find key \"#{key}\" #{hint} at <parent_path>"
+    end
+
+    def short_description object
+      return "nil" if object.nil?
+      case object
+      when Hash then "a Hash"
+      when Array then "an Array"
+      else object.inspect
+      end
+    end
+
+    def class_description object
+      return "nil" if object.nil?
+      clazz = object.class
+      case clazz.name[0]
+      when /[AEIOU]/ then "an #{clazz}"
+      else
+        "a #{clazz}"
+      end
+    end
+  end
+end

data/lib/pact/matchers/multipart_form_diff_formatter.rb

@@ -0,0 +1,41 @@
+require 'pact/matchers/unix_diff_formatter'
+require 'pact/matchers/differ'
+
+module Pact
+  module Matchers
+    class MultipartFormDiffFormatter
+
+      def initialize diff, options = {}
+        @options = options
+        @body_diff = diff[:body]
+        @non_body_diff = diff.reject{ |k, v| k == :body }
+        @colour = options.fetch(:colour, false)
+        @differ = Pact::Matchers::Differ.new(@colour)
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def call
+        Pact::Matchers::UnixDiffFormatter::MESSAGES_TITLE + "\n" + non_body_diff_string + "\n" + body_diff_string
+      end
+
+      def non_body_diff_string
+        if @non_body_diff.any?
+          Pact::Matchers::ExtractDiffMessages.call(@non_body_diff).collect{ | message| "* #{message}" }.join("\n")
+        else
+          ""
+        end
+      end
+
+      def body_diff_string
+        if @body_diff
+          @differ.diff_as_string(@body_diff.expected, @body_diff.actual)
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/pact/matchers/no_diff_at_index.rb

@@ -0,0 +1,18 @@
+module Pact
+  module Matchers
+    class NoDiffAtIndex
+
+      def to_json options = {}
+        to_s.inspect
+      end
+
+      def to_s
+        '<no difference at this index>'
+      end
+
+      def == other
+        other.is_a? NoDiffAtIndex
+      end
+    end
+  end
+end

data/lib/pact/matchers/regexp_difference.rb

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

data/lib/pact/matchers/type_difference.rb

@@ -0,0 +1,16 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class TypeDifference < BaseDifference
+
+      def as_json options = {}
+        if KeyNotFound === actual
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL => actual.as_json }
+        else
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL_TYPE => actual.as_json }
+        end
+      end
+    end
+  end
+end

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
+      '<item 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,157 @@
+require 'pact/shared/jruby_support'
+require 'pact/matchers/differ'
+require 'pact/matchers/extract_diff_messages'
+
+module Pact
+  module Matchers
+
+    class UnixDiffFormatter
+
+      include JRubySupport
+
+      MESSAGES_TITLE = "\n\nDescription of differences\n--------------------------------------"
+
+      def initialize diff, options = {}
+        @diff = diff
+        @colour = options.fetch(:colour, false)
+        @actual = options.fetch(:actual, {})
+        @include_explanation = options.fetch(:include_explanation, true)
+        @differ = Pact::Matchers::Differ.new(@colour)
+        @messages = Pact::Matchers::ExtractDiffMessages.call(diff).collect{ | message| "* #{message}" }.join("\n")
+      end
+
+      def self.call diff, options = {}
+        # require stops circular dependency from pact/configuration <-> pact/matchers/unix_diff_formatter
+        require 'pact/configuration'
+        default_options = {colour: Pact.configuration.color_enabled}
+        new(diff, default_options.merge(options)).call
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+
+        expected = generate_string(diff, :expected)
+        actual = generate_string(diff, :actual)
+        suffix = @include_explanation ?  key + "\n" : ''
+        messages = @include_explanation ? "#{MESSAGES_TITLE}\n#{@messages}\n" : ''
+        string_diff = @differ.diff_as_string(actual, expected).lstrip
+        string_diff = remove_first_line(string_diff)
+        string_diff = remove_comma_from_end_of_arrays(string_diff)
+        suffix + string_diff + messages
+      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 NoDiffAtIndex 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
+          json = fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
+          add_comma_to_end_of_arrays json
+        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)
+        NoDifferenceDecorator.new
+      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
+        "Diff\n--------------------------------------\n" +
+        "Key: " + @differ.red("-") + @differ.red(" is expected \n") +
+        @differ.green("     +") + @differ.green(" is actual \n") +
+        "Matching keys and values are not shown\n"
+      end
+
+      def remove_first_line string_diff
+        lines = string_diff.split("\n")
+        if lines[0] =~ /@@/
+          lines[1..-1].join("\n")
+        else
+          string_diff
+        end
+      end
+
+
+      def add_comma_to_end_of_arrays string
+        string.gsub(/(\n\s*\])/, ',\1')
+      end
+
+      def remove_comma_from_end_of_arrays string
+        string.gsub(/,(\n\s*\])/, '\1')
+      end
+
+      class NoDifferenceDecorator
+
+        def to_json options = {}
+          "... "
+        end
+
+      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/matchers.rb

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