pact-support 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1250628a81126493c975c34bd21ac627275e578a
-  data.tar.gz: 9f7e7f2609e0cc1f0ec03917b0bb35c70e3f36c5
+  metadata.gz: f84c7e04ee7c6d3b6a4608b95ec15979fde8c6d9
+  data.tar.gz: 2791aef2b37304e4c798ae5bd6c3549537728807
 SHA512:
-  metadata.gz: 130b05570e62134204018f8cd5227ffa103b6e4b2d825464131c84e1a6dc24e7318768f3f9a2adc82a0a0cc3098901856390628aca30fd23a4db8283b02ae19c
-  data.tar.gz: 5a48f981de6dfbbab2d1c0f6f4844f73591c8a0558944593911f92c5d0f57973b5d1fd5905d6186d1ba02e5cd0e64b6856d29800252bf2bc98050df56db6ba46
+  metadata.gz: 99b8273204ea956b052383e00f9601251348587911e29a47f04d25dd43d1c8a0e025aed2003f6d4842c5ac0e3e4475fba0498d24a565b84a74bdc0d4e1d27282
+  data.tar.gz: 3b658a185abf8011774c01a256ffa7559f81f81c7192bc46907a9f4ab8aeea8fa4114dc1d3bb890ec89a381b9ef84eac75393b420ab067a9129c0cf7e4b4152a

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Do this to generate your change history
 
-  git log --pretty=format:'  * %h - %s (%an, %ad)' vX.Y.Z..HEAD
+  git log --pretty=format:'  * %h - %s (%an, %ad)'
+
+### 1.1.0 (19 June 2017)
+* 1659c54 - Add list of messages to diff output (Beth Skurrie, Mon Jun 19 09:39:08 2017 +1000)
+* e18debc - Reify actual and expected when a type difference is encountered while doing exact matching (Beth Skurrie, Tue May 30 09:24:18 2017 +1000)
+* 2ba49b6 - Updating matching rules extraction to use inheritance as per #34 (Beth Skurrie, Mon May 29 16:17:57 2017 +1000)
 
 ### 1.0.1 (11 May 2017)
 * e34374b - Extract rules for QueryHash and QueryString so we can include request matching rules in the pact. (Beth Skurrie, Thu May 11 09:11:19 2017 +1000)

data/lib/pact/configuration.rb

@@ -162,8 +162,8 @@ module Pact
 
     def create_logger
       FileUtils::mkdir_p log_dir
-      logger = Logger.new(log_path)
-      logger.level = Logger::DEBUG
+      logger = ::Logger.new(log_path)
+      logger.level = ::Logger::DEBUG
       logger
     end
   end

data/lib/pact/matchers/base_difference.rb

@@ -5,11 +5,13 @@ module Pact
   module Matchers
     class BaseDifference
 
-      attr_reader :expected, :actual
+      attr_reader :expected, :actual, :message
+      attr_writer :message
 
-      def initialize expected, actual
+      def initialize expected, actual, message = nil
         @expected = expected
         @actual = actual
+        @message = message
       end
 
       def any?

data/lib/pact/matchers/differ.rb

@@ -51,8 +51,8 @@ module Pact
           end
         end
         #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s,output)
-        output << matching_encoding("\n",output)
+        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

data/lib/pact/matchers/extract_messages.rb

@@ -0,0 +1,71 @@
+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
+        diff
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        diff_messages(diff).join("\n")
+      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/matchers.rb

@@ -22,11 +22,11 @@ module Pact
     NO_DIFF = {}.freeze
 
     def diff expected, actual, opts = {}
-      calculate_diff(Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts))
+      calculate_diff(expected, actual, DEFAULT_OPTIONS.merge(opts))
     end
 
     def type_diff expected, actual, opts = {}
-      calculate_diff Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts).merge(type: true)
+      calculate_diff expected, actual, DEFAULT_OPTIONS.merge(opts).merge(type: true)
     end
 
     private
@@ -39,17 +39,42 @@ module Pact
       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, Pact::Reification.from_term(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, Pact::Reification.from_term(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) && regexp.match(actual)
+      if actual.is_a?(String)
+        actual_regexp_diff regexp, actual, options
+      else
+        RegexpDifference.new regexp, Pact::Reification.from_term(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
+        RegexpDifference.new regexp, Pact::Reification.from_term(actual), "Expected a String matching #{regexp.inspect} but got #{short_description(actual)} at <path>"
       end
     end
 
@@ -57,7 +82,7 @@ module Pact
       if actual.is_a? Array
         actual_array_diff expected, actual, options
       else
-        Difference.new expected, actual
+        Difference.new Pact::Reification.from_term(expected), Pact::Reification.from_term(actual), type_difference_message(expected, actual)
       end
     end
 
@@ -84,7 +109,7 @@ module Pact
         expected_array = expected_size.times.collect{ Pact::Term.unpack_regexps(array_like.contents) }
         actual_array_diff expected_array, actual, options.merge(:type => true)
       else
-        Difference.new array_like.generate, actual
+        Difference.new array_like.generate, Pact::Reification.from_term(actual), type_difference_message(expected, actual)
       end
     end
 
@@ -92,24 +117,33 @@ module Pact
       if actual.is_a? Hash
         actual_hash_diff expected, actual, options
       else
-        Difference.new expected, actual
+        Difference.new Pact::Reification.from_term(expected), Pact::Reification.from_term(actual), type_difference_message(expected, actual)
       end
     end
 
     def actual_hash_diff expected, actual, options
-      hash_diff = expected.each_with_object({}) do |(key, value), difference|
-        diff_at_key = calculate_diff(value, actual.fetch(key, Pact::KeyNotFound.new), 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])
+          running_diff[key] = Difference.new(UnexpectedKey.new, actual[key], "Did not expect the key \"#{key}\" to exist at <parent_path>")
         end
       end
     end
@@ -124,7 +158,7 @@ module Pact
 
     def exact_value_diff expected, actual, options
       if expected != actual
-        Difference.new expected, actual
+        Difference.new expected, actual, value_difference_message(expected, actual, options)
       else
         NO_DIFF
       end
@@ -134,7 +168,7 @@ module Pact
       if types_match? expected, actual
         NO_DIFF
       else
-        TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual)
+        TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual), type_difference_message(expected, actual)
       end
     end
 
@@ -154,6 +188,67 @@ module Pact
       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 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)
+        message = "Expected #{expected_desc} but got #{actual_desc} at <path>"
+      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/unix_diff_formatter.rb

@@ -1,5 +1,6 @@
 require 'pact/shared/jruby_support'
 require 'pact/matchers/differ'
+require 'pact/matchers/extract_messages'
 
 module Pact
   module Matchers
@@ -8,15 +9,20 @@ module Pact
 
       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)
       end
 
-      def self.call diff, options = {colour: Pact.configuration.color_enabled}
-        new(diff, options).call
+      def self.call diff, options = {}
+        default_options = {colour: Pact.configuration.color_enabled}
+        new(diff, default_options.merge(options)).call
       end
 
       def call
@@ -24,11 +30,15 @@ module Pact
       end
 
       def to_s
+
         expected = generate_string(diff, :expected)
         actual = generate_string(diff, :actual)
-        suffix = @include_explanation ?  "\n" + key : ''
-        string_diff = remove_comma_from_end_of_arrays(@differ.diff_as_string(actual, expected).lstrip)
-        string_diff + suffix
+        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
@@ -91,11 +101,22 @@ module Pact
       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"
+        "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

data/lib/pact/matching_rules/extract.rb

@@ -33,8 +33,6 @@ module Pact
         when Pact::Term then record_regex_rule object, path
         when Pact::QueryString then recurse(object.query, path, match_type)
         when Pact::QueryHash then recurse_hash(object.query, path, match_type)
-        else
-          record_match_type_rule path, match_type
         end
       end
 
@@ -51,6 +49,7 @@ module Pact
       end
 
       def handle_something_like something_like, path, match_type
+        record_match_type_rule path, "type"
         recurse something_like.contents, path, "type"
       end
 

data/lib/pact/support/version.rb

@@ -1,5 +1,5 @@
 module Pact
   module Support
-    VERSION = "1.0.1"
+    VERSION = "1.1.0"
   end
 end

data/pact-support.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake', '~> 10.0.3'
   gem.add_development_dependency 'webmock', '~> 2.0.0'
   gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'fakefs', '~> 0.4'
+  gem.add_development_dependency 'fakefs', '0.5.2' #0.5.3+ breaks everything
   gem.add_development_dependency 'hashie', '~> 2.0'
   gem.add_development_dependency 'activesupport'
   gem.add_development_dependency 'appraisal'

data/spec/integration/matching_rules_extract_and_merge_spec.rb

@@ -61,13 +61,9 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy", pending: 'Waiting for Pact JVM to implement nested type matching' do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates a similar object hierarchy that does the same thing" do
-      expect(recreated_expected).to eq similar
-    end
   end
 
   context "with a Pact::SomethingLike containing an Array" do
@@ -87,12 +83,8 @@ describe "converting Pact::Term and Pact::SomethingLike to matching rules and ba
       }
     end
 
-    it "recreates the same object hierarchy", pending: 'Waiting for Pact JVM to implement nested type matching' do
+    it "recreates the same object hierarchy" do
       expect(recreated_expected).to eq expected
     end
-
-    it "recreates a similar object hierarchy that does the same thing" do
-      expect(recreated_expected).to eq similar
-    end
   end
 end

data/spec/lib/pact/matchers/extract_messages_spec.rb

@@ -0,0 +1,78 @@
+require 'pact/matchers/extract_messages'
+
+module Pact
+  module Matchers
+    describe ExtractDiffMessages do
+
+      subject { ExtractDiffMessages.call(diff) }
+
+      context "<path> with a diff in a Hash" do
+        let(:diff) { {a: Difference.new(nil, nil, "There was a difference at <path>") } }
+
+        it { is_expected.to eq "* There was a difference at $.a" }
+      end
+
+      context "<parent_path> with a diff in a Hash" do
+        let(:diff) { {a: Difference.new(nil, nil, "There was a difference at <parent_path>") } }
+
+        it { is_expected.to eq "* There was a difference at $" }
+      end
+
+      context "<path> with a diff in a nested Hash" do
+        let(:diff) { {a: {b: Difference.new(nil, nil, "There was a difference at <path>")}} }
+
+        it { is_expected.to eq "* There was a difference at $.a.b" }
+      end
+
+      context "<parent_path> with a diff in a nested Hash" do
+        let(:diff) { {a: {b: Difference.new(nil, nil, "There was a difference at <parent_path>")}} }
+
+        it { is_expected.to eq "* There was a difference at $.a" }
+      end
+
+      context "<path> with a diff in an Array" do
+        let(:diff) { [NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <path>")] }
+
+        it { is_expected.to eq "* There was a difference at $[1]" }
+      end
+
+      context "<parent_path> with a diff in an Array" do
+        let(:diff) { [NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <parent_path>")] }
+
+        it { is_expected.to eq "* There was a difference at $" }
+      end
+
+      context "<path> with a diff in a nested Array" do
+        let(:diff) { [NoDiffAtIndex.new,[NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <path>")]] }
+
+        it { is_expected.to eq "* There was a difference at $[1][1]" }
+      end
+
+      context "<parent_path> with a diff in a nested Array" do
+        let(:diff) { [NoDiffAtIndex.new,[NoDiffAtIndex.new, Difference.new(nil, nil, "There was a difference at <parent_path>")]] }
+
+        it { is_expected.to eq "* There was a difference at $[1]" }
+      end
+
+      context "when there is a space in the key" do
+        let(:diff) do
+          {"Foo Bar" => Difference.new(nil, nil, "There was a difference at <path>")}
+        end
+
+        it { is_expected.to eq "* There was a difference at $.\"Foo Bar\"" }
+      end
+
+      context "with two differences" do
+        let(:diff) do
+          {
+            a: Difference.new(nil, nil, "There was a difference at <path>"),
+            b: Difference.new(nil, nil, "There was a difference at <path>")
+          }
+        end
+
+        it { is_expected.to eq "* There was a difference at $.a\n* There was a difference at $.b" }
+      end
+
+    end
+  end
+end

data/spec/lib/pact/matchers/matchers_messages_hash_and_array_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'pact/matchers'
+require 'pact/consumer_contract/headers'
+
+module Pact::Matchers
+
+  describe Pact::Matchers do
+    include Pact::Matchers
+
+    describe "diff" do
+      STRING = "foo"
+      INT = 1
+      FLOAT = 1.0
+      HASH = {foo: "bar"}
+      ARRAY = ["foo"]
+
+      context "with a Hash" do
+
+        context "with a missing key when the actual is an empty Hash" do
+          let(:expected) { {thing: "foo"} }
+          let(:actual) { {} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Could not find key \"thing\" in empty Hash at <parent_path>"
+          end
+        end
+
+        context "with a missing key when the actual is a populated Hash" do
+          let(:expected) { {thing: "foo"} }
+          let(:actual) { {a_thing: "foo", other_thing: "foo"} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Could not find key \"thing\" (keys present are: a_thing, other_thing) at <parent_path>"
+          end
+        end
+
+        context "with an unexpected key" do
+          let(:expected) { {thing: "foo"} }
+          let(:actual) { {thing: "foo", another_thing: "foo"} }
+          let(:difference) { diff(expected, actual, {allow_unexpected_keys: false}) }
+
+          it "returns a message" do
+            expect(difference[:another_thing].message).to eq "Did not expect the key \"another_thing\" to exist at <parent_path>"
+          end
+        end
+      end
+
+      context "with an Array" do
+
+        context "with not enough Integer items" do
+          let(:expected) { {thing: [1, 2]} }
+          let(:actual) { {thing: [1]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too short and should have contained 2 at <path>"
+          end
+        end
+
+        context "with not enough String items" do
+          let(:expected) { {thing: [1, STRING]} }
+          let(:actual) { {thing: [1]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too short and should have contained \"foo\" at <path>"
+          end
+        end
+
+        context "with not enough Hash items" do
+          let(:expected) { {thing: [1, HASH]} }
+          let(:actual) { {thing: [1]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too short and should have contained a Hash at <path>"
+          end
+        end
+
+        context "with not enough Array items" do
+          let(:expected) { {thing: [1, ARRAY]} }
+          let(:actual) { {thing: [1]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too short and should have contained an Array at <path>"
+          end
+        end
+
+        context "with an extra item that is an Integer" do
+          let(:expected) { {thing: [1]} }
+          let(:actual) { {thing: [1, 2]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too long and should not contain 2 at <path>"
+          end
+        end
+
+        context "with an extra item that is a String" do
+          let(:expected) { {thing: [1]} }
+          let(:actual) { {thing: [1, "foo"]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too long and should not contain \"foo\" at <path>"
+          end
+        end
+
+        context "with an extra item that is a Hash" do
+          let(:expected) { {thing: [1]} }
+          let(:actual) { {thing: [1, HASH]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too long and should not contain a Hash at <path>"
+          end
+        end
+
+        context "with an extra item that is an Array" do
+          let(:expected) { {thing: [1]} }
+          let(:actual) { {thing: [1, ARRAY]} }
+          let(:difference) { diff(expected, actual) }
+
+          it "returns a message" do
+            expect(difference[:thing][1].message).to eq "Actual array is too long and should not contain an Array at <path>"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/matchers/matchers_messages_mismatched_value_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'pact/matchers'
+require 'pact/consumer_contract/headers'
+
+module Pact::Matchers
+
+  describe Pact::Matchers do
+    include Pact::Matchers
+
+    describe "diff" do
+      STRING = "foo"
+      INT = 1
+      FLOAT = 1.0
+      HASH = {foo: "bar"}
+      ARRAY = ["foo"]
+
+      COMBINATIONS = [
+        [STRING, "bar", "Expected \"foo\" but got \"bar\" at <path>"],
+        [STRING, nil, "Expected \"foo\" but got nil at <path>"],
+        [STRING, INT, "Expected \"foo\" but got 1 at <path>"],
+        [STRING, FLOAT, "Expected \"foo\" but got 1.0 at <path>"],
+        [STRING, HASH, "Expected \"foo\" but got a Hash at <path>"],
+        [STRING, ARRAY, "Expected \"foo\" but got an Array at <path>"],
+        [Pact.like(STRING), "bar", nil],
+        [Pact.like(STRING), nil, "Expected a String (like \"foo\") but got nil at <path>"],
+        [Pact.like(STRING), INT, "Expected a String (like \"foo\") but got a Fixnum (1) at <path>"],
+        [Pact.like(STRING), FLOAT, "Expected a String (like \"foo\") but got a Float (1.0) at <path>"],
+        [Pact.like(STRING), HASH, "Expected a String (like \"foo\") but got a Hash at <path>"],
+        [Pact.like(STRING), ARRAY, "Expected a String (like \"foo\") but got an Array at <path>"],
+        [INT, 2, "Expected 1 but got 2 at <path>"],
+        [INT, nil, "Expected 1 but got nil at <path>"],
+        [INT, STRING, "Expected 1 but got \"foo\" at <path>"],
+        [INT, FLOAT, "Expected 1 but got \"foo\" at <path>", {pending: true}],
+        [INT, HASH, "Expected 1 but got a Hash at <path>"],
+        [INT, ARRAY, "Expected 1 but got an Array at <path>"],
+        [Pact.like(INT), 2, nil],
+        [Pact.like(INT), nil, "Expected a Fixnum (like 1) but got nil at <path>"],
+        [Pact.like(INT), STRING, "Expected a Fixnum (like 1) but got a String (\"foo\") at <path>"],
+        [Pact.like(INT), FLOAT, "Expected a Fixnum (like 1) but got a Float (1.0) at <path>"],
+        [Pact.like(INT), HASH, "Expected a Fixnum (like 1) but got a Hash at <path>"],
+        [Pact.like(INT), ARRAY, "Expected a Fixnum (like 1) but got an Array at <path>"],
+        [HASH, HASH, nil],
+        [HASH, nil, "Expected a Hash but got nil at <path>"],
+        [HASH, STRING, "Expected a Hash but got a String (\"foo\") at <path>"],
+        [HASH, INT, "Expected a Hash but got a Fixnum (1) at <path>"],
+        [HASH, FLOAT, "Expected a Hash but got a Float (1.0) at <path>"],
+        [HASH, ARRAY, "Expected a Hash but got an Array at <path>"],
+        [Pact.like(HASH), STRING, "Expected a Hash but got a String (\"foo\") at <path>"],
+        [ARRAY, ARRAY, nil],
+        [ARRAY, nil, "Expected an Array but got nil at <path>"],
+        [ARRAY, STRING, "Expected an Array but got a String (\"foo\") at <path>"],
+        [ARRAY, INT, "Expected an Array but got a Fixnum (1) at <path>"],
+        [ARRAY, FLOAT, "Expected an Array but got a Float (1.0) at <path>"],
+        [ARRAY, HASH, "Expected an Array but got a Hash at <path>"]
+      ]
+
+      COMBINATIONS.each do | expected, actual, expected_message, options |
+        context "when expected is #{expected.inspect} and actual is #{actual.inspect}", options || {} do
+          let(:difference) { diff({thing: expected}, {thing: actual}) }
+          let(:message) { difference[:thing] ? difference[:thing].message : nil }
+
+          it "returns the message '#{expected_message}'" do
+            expect(message).to eq expected_message
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/matchers/matchers_messages_regexp_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'pact/matchers'
+require 'pact/consumer_contract/headers'
+
+module Pact::Matchers
+
+  describe Pact::Matchers do
+    include Pact::Matchers
+
+    describe "diff" do
+      STRING = "foo"
+      INT = 1
+      FLOAT = 1.0
+      HASH = {foo: "bar"}
+      ARRAY = ["foo"]
+
+
+      let(:term) { Pact.term(/foo/, "food") }
+      let(:regexp) { /foo/ }
+      let(:actual) { "drink" }
+      let(:difference) { diff({thing: expected}, {thing: actual}) }
+
+      context "with a Pact::Term" do
+        let(:expected) { term }
+
+        context "when the Pact::Term does not match" do
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ (like \"food\") but got \"drink\" at <path>"
+          end
+        end
+
+        context "when the actual is a Fixnum" do
+          let(:actual) { INT }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ (like \"food\") but got a Fixnum (1) at <path>"
+          end
+        end
+
+        context "when the actual is Hash" do
+          let(:actual) { HASH }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ (like \"food\") but got a Hash at <path>"
+          end
+        end
+
+        context "when the actual is a Fixnum" do
+          let(:actual) { INT }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ (like \"food\") but got a Fixnum (1) at <path>"
+          end
+        end
+
+        context "when the actual is nil" do
+          let(:actual) { nil }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ (like \"food\") but got nil at <path>"
+          end
+        end
+      end
+
+      context "with a Regexp" do
+
+        let(:expected) { regexp }
+
+        context "when the Pact::Term does not match" do
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got \"drink\" at <path>"
+          end
+        end
+
+        context "when the actual is a Fixnum" do
+          let(:actual) { INT }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got a Fixnum (1) at <path>"
+          end
+        end
+
+        context "when the actual is Hash" do
+          let(:actual) { HASH }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got a Hash at <path>"
+          end
+        end
+
+        context "when the actual is a Fixnum" do
+          let(:actual) { INT }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got a Fixnum (1) at <path>"
+          end
+        end
+
+        context "when the actual is nil" do
+          let(:actual) { nil }
+          it "returns a message" do
+            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got nil at <path>"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/matchers/matchers_spec.rb

@@ -45,7 +45,7 @@ module Pact::Matchers
 
       context 'when the actual is something like the expected' do
         let(:expected) { Pact::SomethingLike.new( { a: 1 } ) }
-        let(:actual) { { a: 2} }
+        let(:actual)   { { a: 2 } }
 
         it 'returns an empty diff' do
           expect(diff(expected, actual)).to eq({})
@@ -53,6 +53,15 @@ module Pact::Matchers
 
       end
 
+      context 'when the there is a mismatch of a parent, and a child contains a SomethingLike' do
+        let(:expected) { {thing: {foo: Pact::SomethingLike.new(1)}} }
+        let(:actual)   { {thing: [Pact::SomethingLike.new(1)]} }
+        let(:difference) { {thing: Difference.new({foo: 1}, [1]) } }
+
+        it "reifies the children" do
+          expect(diff(expected, actual)).to eq difference
+        end
+      end
     end
 
     describe 'option {allow_unexpected_keys: false}' do
@@ -125,14 +134,14 @@ module Pact::Matchers
         end
         context "and a hash is found" do
           let(:actual) { {a: {b: 1}} }
-          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new({:b=>1})) } }
+          let(:difference) { {a: TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new({:b=>1})) } }
           it "returns the diff" do
             expect(type_diff(expected, actual)).to eq difference
           end
         end
         context "and an array is found" do
           let(:actual) { {a: [1] } }
-          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new([1]))}}
+          let(:difference) { {a: TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new([1]))}}
           it "returns the diff" do
             expect(type_diff(expected, actual)).to eq difference
           end
@@ -147,7 +156,7 @@ module Pact::Matchers
             [
               NoDiffAtIndex.new,
               {
-                :name => TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
+                name: TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
               }
             ]
           }
@@ -162,7 +171,7 @@ module Pact::Matchers
         let(:expected) { {a: nil} }
         context "and a string is found" do
           let(:actual) { {a: 'a string'} }
-          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(nil), Pact::ActualType.new("a string")) } }
+          let(:difference) { {a: TypeDifference.new(Pact::ExpectedType.new(nil), Pact::ActualType.new("a string")) } }
           it "returns the diff" do
             expect(type_diff(expected, actual)).to eq difference
           end
@@ -184,8 +193,8 @@ module Pact::Matchers
         let(:expected) { {a: {b: Pact::Term.new(:matcher => /p/, :generate => 'apple')}} }
         context "and a non matching value is found" do
           let(:actual) { {a: nil} }
-          let(:difference) { {a: Difference.new({b: /p/}, nil)} }
-          it "returns the diff with the regexp unpacked" do
+          let(:difference) { {a: Difference.new({b: "apple"}, nil)} }
+          it "returns the diff with the term reified" do
             expect(type_diff(expected, actual)).to eq difference
           end
         end
@@ -264,6 +273,17 @@ module Pact::Matchers
             expect(diff(subject, actual)).to eq(difference)
           end
         end
+
+        context "when the actual value is an array, and both expected and actual contain SomethingLike" do
+          subject { {a: {foo: Pact.like("b")}} }
+          let(:actual) { {a: [Pact.like(1)] } }
+          let(:difference) { {a: Difference.new({foo: "b"}, [1]) } }
+
+          it "should return the diff with the reified likes" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
+        end
+
         context "when the actual value is an hash" do
           let(:actual) { {b: 'c'} }
           let(:difference) { { a: Difference.new("b",Pact::KeyNotFound.new)} }

data/spec/lib/pact/matchers/unix_diff_formatter_spec.rb

@@ -9,7 +9,7 @@ module Pact
 
       describe ".call" do
 
-        let(:key_lines_count) { 4 }
+        let(:key_lines_count) { 9 }
         let(:colour) { false }
         subject { UnixDiffFormatter.call(diff, {colour: colour}) }
 
@@ -55,7 +55,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -77,7 +77,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -99,7 +99,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 5 + key_lines_count
+            expect(line_count).to eq 4 + key_lines_count
           end
 
         end
@@ -121,7 +121,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
+            expect(line_count).to eq 7 + key_lines_count
           end
         end
 
@@ -141,7 +141,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 8 + key_lines_count
+            expect(line_count).to eq 7 + key_lines_count
           end
 
         end
@@ -160,7 +160,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 7 + key_lines_count
+            expect(line_count).to eq 6 + key_lines_count
           end
 
         end
@@ -187,7 +187,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 9 + key_lines_count
+            expect(line_count).to eq 8 + key_lines_count
           end
 
         end
@@ -205,7 +205,7 @@ EOF
           end
 
           it "generates the right number of lines, even with ActiveSupport loaded" do
-            expect(line_count).to eq 10 + key_lines_count
+            expect(line_count).to eq 9 + key_lines_count
           end
 
         end

data/spec/lib/pact/matching_rules/extract_spec.rb

@@ -20,8 +20,7 @@ module Pact
 
           let(:rules) do
             {
-              "$.body.foo" => {"match" => "type"},
-              "$.body.alligator.name" => {"match" => "type"}
+              "$.body" => {"match" => "type"}
             }
           end
 
@@ -64,7 +63,7 @@ module Pact
 
           let(:rules) do
             {
-              "$.body.foo" => {"match" => "type"},
+              "$.body" => {"match" => "type"},
               "$.body.alligator.name" => {"match" => "regex", "regex"=>".*a"},
             }
           end
@@ -88,8 +87,7 @@ module Pact
 
           let(:rules) do
             {
-              "$.body.alligators[0].name" => {"match" => "type"},
-              "$.body.alligators[1].name" => {"match" => "type"}
+              "$.body" => {"match" => "type"}
             }
           end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact-support
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - James Fraser
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-10 00:00:00.000000000 Z
+date: 2017-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -172,16 +172,16 @@ dependencies:
   name: fakefs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.5.2
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -274,6 +274,7 @@ files:
 - lib/pact/matchers/difference_indicator.rb
 - lib/pact/matchers/embedded_diff_formatter.rb
 - lib/pact/matchers/expected_type.rb
+- lib/pact/matchers/extract_messages.rb
 - lib/pact/matchers/index_not_found.rb
 - lib/pact/matchers/list_diff_formatter.rb
 - lib/pact/matchers/matchers.rb
@@ -324,9 +325,13 @@ files:
 - spec/lib/pact/matchers/differ_spec.rb
 - spec/lib/pact/matchers/difference_spec.rb
 - spec/lib/pact/matchers/embedded_diff_formatter_spec.rb
+- spec/lib/pact/matchers/extract_messages_spec.rb
 - spec/lib/pact/matchers/index_not_found_spec.rb
 - spec/lib/pact/matchers/list_diff_formatter_spec.rb
 - spec/lib/pact/matchers/matchers_array_like_spec.rb
+- spec/lib/pact/matchers/matchers_messages_hash_and_array_spec.rb
+- spec/lib/pact/matchers/matchers_messages_mismatched_value_spec.rb
+- spec/lib/pact/matchers/matchers_messages_regexp_spec.rb
 - spec/lib/pact/matchers/matchers_spec.rb
 - spec/lib/pact/matchers/no_diff_at_index_spec.rb
 - spec/lib/pact/matchers/regexp_difference_spec.rb
@@ -391,7 +396,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Shared code for Pact gems
@@ -414,9 +419,13 @@ test_files:
 - spec/lib/pact/matchers/differ_spec.rb
 - spec/lib/pact/matchers/difference_spec.rb
 - spec/lib/pact/matchers/embedded_diff_formatter_spec.rb
+- spec/lib/pact/matchers/extract_messages_spec.rb
 - spec/lib/pact/matchers/index_not_found_spec.rb
 - spec/lib/pact/matchers/list_diff_formatter_spec.rb
 - spec/lib/pact/matchers/matchers_array_like_spec.rb
+- spec/lib/pact/matchers/matchers_messages_hash_and_array_spec.rb
+- spec/lib/pact/matchers/matchers_messages_mismatched_value_spec.rb
+- spec/lib/pact/matchers/matchers_messages_regexp_spec.rb
 - spec/lib/pact/matchers/matchers_spec.rb
 - spec/lib/pact/matchers/no_diff_at_index_spec.rb
 - spec/lib/pact/matchers/regexp_difference_spec.rb