pact 1.0.26 → 1.0.27

data/lib/pact/provider/world.rb

@@ -0,0 +1,19 @@
+module Pact
+
+  def self.world
+    @world ||= Pact::Provider::World.new
+  end
+
+  module Provider
+    class World
+
+      def initialize
+      end
+
+      def provider_states
+        @provider_states_proxy ||= Pact::Provider::ProviderStateProxy.new
+      end
+
+    end
+  end
+end

data/lib/pact/templates/provider_state.erb

@@ -0,0 +1,15 @@
+
+Could not find one or more provider states.
+Have you required the provider states file for this consumer in your pact_helper.rb?
+If you have not yet defined these states, here is a template:
+<% consumers.keys.each do | consumer_name | %>
+Pact.provider_states_for "<%= consumer_name %>" do
+<% consumers[consumer_name].each do | provider_state | %>
+  provider_state "<%= provider_state %>" do
+    set_up do
+      # Your set up code goes here
+    end
+  end
+<% end %>
+end
+<% end %>

data/lib/pact/version.rb

@@ -1,3 +1,3 @@
 module Pact
-  VERSION = "1.0.26"
+  VERSION = "1.0.27"
 end

data/{scratchpad.txt → scratchpad.rb}

@@ -29,8 +29,24 @@ Need a way to specify a literal empty hash, rather than a hash that matches anyt
 {:something => actual({}) }
 {:something => empty_hash }
 
-Slightly unintuitive behaviour: {} matches any hash, but [] only matches an empty array (or does now we've changed the code). Should [] match any array? How do we then specify an empty array?
+# Slightly unintuitive behaviour: {} matches any hash, but [] only matches an empty array (or does now we've changed the code). Should [] match any array? How do we then specify an empty array?
 
 {:something => literal([]) }
 {:something => actual([]) }
 {:something => empty_array }
+
+
+Pact.build do
+   {
+      status: 200,
+      headers: exactly({
+
+         }),
+      body: including({
+         age: literal('12'),
+         phoneNumber: example("0415 134 234", /\d{4} \d{3} \d{3}/),
+         favouriteColors:
+      })
+   }
+
+end

data/spec/integration/consumer_spec.rb

@@ -57,8 +57,8 @@ describe "A service consumer side of a pact", :pact => true  do
           "provider_state" => "something",
           "body"=>{
             "a"=>{
-              "expected"=>"some body",
-              "actual"=>"not matching body"
+              "EXPECTED"=>"some body",
+              "ACTUAL"=>"not matching body"
             }
           }
         }]

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'pact/matchers/diff_decorator'
+require 'pact/matchers/matchers'
+
+module Pact
+  module Matchers
+    describe DiffDecorator do
+
+      describe "to_s" do
+        subject { DiffDecorator.new(diff) }
+
+        context "when there is a mismatched value" do
+          let(:diff) { {root: {"blah" => { 1 => Difference.new("alphabet", "woozle")}}} }
+          let(:expected_output) { ""}
+
+          it "includes the expected value" do
+            expect(subject.to_s).to match(/Expected:.*"alphabet"/m)
+          end
+          it "includes the actual value" do
+            expect(subject.to_s).to match(/Actual:.*"woozle"/m)
+          end
+
+          it "includes the path" do
+            expect(subject.to_s).to include('[:root]["blah"][1]')
+          end
+        end
+
+        context "when there is a missing key" do
+          let(:expected_hash) { {"abc" => {"def" => [1,2]}}}
+          let(:diff) { {root: {"blah" => { 1 => Difference.new(expected_hash, Pact::KeyNotFound.new )}}} }
+          let(:expected_output) { ""}
+
+          it "includes the expected value" do
+            expect(subject.to_s).to match(/Missing key with value\:.*\{/m)
+          end
+
+          it "includes the path" do
+            expect(subject.to_s).to include('[:root]["blah"][1]')
+          end
+        end
+
+        context "when there is a missing index" do
+          let(:diff) { [NoDiffIndicator.new, Difference.new(1, IndexNotFound.new )]}
+          it "includes the expected value" do
+            expect(subject.to_s).to match(/Missing.*1/m)
+          end
+
+          it "includes the path" do
+            expect(subject.to_s).to include('[1]')
+          end
+        end
+
+        context "when there is an unexpected index" do
+          let(:diff) { [NoDiffIndicator.new, Difference.new(UnexpectedIndex.new, 2), Difference.new(UnexpectedIndex.new, "b")]}
+          it "includes the unexpected value" do
+            expect(subject.to_s).to include("Array contained unexpected item:")
+          end
+
+          it "includes the path" do
+            expect(subject.to_s).to include('[1]')
+            expect(subject.to_s).to include('[2]')
+          end
+        end
+
+        context "when there is an unexpected key" do
+          let(:diff) { {"blah" => Difference.new(UnexpectedKey.new, "b")}}
+          it "includes the unexpected key" do
+            expect(subject.to_s).to include("Hash contained unexpected key with value:")
+          end
+
+          it "includes the path" do
+            expect(subject.to_s).to include('["blah"]')
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -1,424 +1,429 @@
 require 'spec_helper'
 require 'pact/matchers'
 
-describe Pact::Matchers do
-  include Pact::Matchers
+module Pact::Matchers
 
-  describe 'matching with something like' do
+  describe Pact::Matchers do
+    include Pact::Matchers
 
-    context 'when the actual is something like the expected' do
-      let(:expected) { Pact::SomethingLike.new( { a: 1 } ) }
-      let(:actual) { { a: 2} }
+    describe 'matching with something like' do
 
-      it 'returns an empty diff' do
-        expect(diff(expected, actual)).to eq({})
-      end
-
-    end
+      context 'when the actual is something like the expected' do
+        let(:expected) { Pact::SomethingLike.new( { a: 1 } ) }
+        let(:actual) { { a: 2} }
 
-  end
+        it 'returns an empty diff' do
+          expect(diff(expected, actual)).to eq({})
+        end
 
-  describe 'option {allow_unexpected_keys: false}' do
-    context "when an unexpected key is found" do
-      let(:expected) { {:a => 1} }
-      let(:actual) { {:a => 1, :b => 2} }
-      let(:difference) { {:b => {:expected => Pact::UnexpectedKey.new, :actual => 2 }} }
-      it "returns it in the diff" do
-        expect(diff(expected, actual, allow_unexpected_keys: false)).to eq difference
       end
-    end
-  end
 
-  describe "expecting key to be present with nil value and not finding key" do
-    let(:expected) { {a: nil} }
-    let(:actual) { {} }
-    let(:difference) { {a: {expected: nil, actual: Pact::KeyNotFound.new }} }
-    it "returns the key in the diff" do
-      expect(diff(expected, actual)).to eq difference
     end
-  end
 
-  describe "expecting a string matching a regexp and not finding key" do
-    let(:expected) { {a: /b/} }
-    let(:actual) { {} }
-    let(:difference) { {:a=>{:expected=>/b/, :actual=> Pact::KeyNotFound.new }} }
-    it "returns the diff" do
-      expect(diff(expected, actual)).to eq difference
+    describe 'option {allow_unexpected_keys: false}' do
+      context "when an unexpected key is found" do
+        let(:expected) { {:a => 1} }
+        let(:actual) { {:a => 1, :b => 2} }
+        let(:difference) { {:b => Difference.new(Pact::UnexpectedKey.new, 2 )} }
+        it "returns it in the diff" do
+          expect(diff(expected, actual, allow_unexpected_keys: false)).to eq difference
+        end
+      end
     end
-  end
-
-  describe 'structure_diff' do
-    let(:expected) {
-      {a: 'a string', b: 1, c: nil, d: [{e: 'thing'}], f: {g: 10}, h: false}
-    }
 
-    context "when the classes match" do
-      let(:actual) { {a: 'another string', b: 2, c: nil, d: [{e: 'something'}], f: {g: 100}, h: true} }
-      let(:difference) { {} }
-      it "returns an empty hash" do
-        expect(structure_diff(expected, actual)).to eq difference
+    describe "expecting key to be present with nil value and not finding key" do
+      let(:expected) { {a: nil} }
+      let(:actual) { {} }
+      let(:difference) { {a: Difference.new(nil, Pact::KeyNotFound.new )} }
+      it "returns the key in the diff" do
+        expect(diff(expected, actual)).to eq difference
       end
     end
 
-    context "when a key is not found" do
-      let(:actual) { {a: 'blah'} }
-      let(:expected) { {b: 'blah'} }
-      let(:difference) { {:b=>{:expected=>{:class=>String, :eg=>"blah"}, :actual=>Pact::KeyNotFound.new}} }
-      it "returns the difference" do
-        expect(structure_diff(expected, actual)).to eq difference
+    describe "expecting a string matching a regexp and not finding key" do
+      let(:expected) { {a: /b/} }
+      let(:actual) { {} }
+      let(:difference) { {:a=> Difference.new(/b/, Pact::KeyNotFound.new) } }
+      it "returns the diff" do
+        expect(diff(expected, actual)).to eq difference
       end
     end
 
-    context "when a number is expected" do
-      let(:expected) { {a: 1} }
-      #let(:difference) { {a: {expected: 'Fixnum (eg. 1)', actual: 'String ("a string")'}}  }
-      let(:difference) { {a: {expected: {:class => Fixnum, eg: 1 } , actual: {:class => String, :value => 'a string'}}}  }
+    describe 'structure_diff' do
+      let(:expected) {
+        {a: 'a string', b: 1, c: nil, d: [{e: 'thing'}], f: {g: 10}, h: false}
+      }
 
-      context "and a string is found" do
-        let(:actual) { {a: 'a string'}}
-        it "returns the diff" do
+      context "when the classes match" do
+        let(:actual) { {a: 'another string', b: 2, c: nil, d: [{e: 'something'}], f: {g: 100}, h: true} }
+        let(:difference) { {} }
+        it "returns an empty hash" do
           expect(structure_diff(expected, actual)).to eq difference
         end
       end
-      context "and nil is found" do
-        let(:actual) { {a: nil}}
-        let(:difference ) { {a: {:expected => {:class => Fixnum, eg: 1}, :actual => nil} } }
-        it "returns the diff" do
+
+      context "when a key is not found" do
+        let(:actual) { {a: 'blah'} }
+        let(:expected) { {b: 'blah'} }
+        let(:difference) { {:b=>Difference.new({:class=>String, :eg=>"blah"}, Pact::KeyNotFound.new)} }
+        it "returns the difference" do
           expect(structure_diff(expected, actual)).to eq difference
         end
       end
-      context "and a hash is found" do
-        let(:actual) { {a: {b: 1}} }
-        let(:difference) { {:a=>{:expected=>{:class=>Fixnum, :eg=>1}, :actual=>{:class=>Hash, :value=>{:b=>1}}}} }
-        it "returns the diff" do
-          expect(structure_diff(expected, actual)).to eq difference
+
+      context "when a number is expected" do
+        let(:expected) { {a: 1} }
+        #let(:difference) { {a: {expected: 'Fixnum (eg. 1)', actual: 'String ("a string")'}}  }
+        let(:difference) { {a: Difference.new({:class => Fixnum, eg: 1 } , {:class => String, :value => 'a string'})}  }
+
+        context "and a string is found" do
+          let(:actual) { {a: 'a string'}}
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
         end
-      end
-      context "and an array is found" do
-        let(:actual) { {a: [1] } }
-        let(:difference) { {:a=>{:expected=>{:class=>Fixnum, :eg=>1}, :actual=>{:class=>Array, :value=>[1]}}} }
-        it "returns the diff" do
-          expect(structure_diff(expected, actual)).to eq difference
+        context "and nil is found" do
+          let(:actual) { {a: nil}}
+          let(:difference ) { {a: Difference.new({:class => Fixnum, eg: 1}, nil) } }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
+        end
+        context "and a hash is found" do
+          let(:actual) { {a: {b: 1}} }
+          let(:difference) { {:a=>Difference.new({:class=>Fixnum, :eg=>1}, {:class=>Hash, :value=>{:b=>1}}) } }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
+        end
+        context "and an array is found" do
+          let(:actual) { {a: [1] } }
+          let(:difference) { {:a=>Difference.new({:class=>Fixnum, :eg=>1}, {:class=>Array, :value=>[1]} ) } }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
         end
       end
-    end
 
-    context "when an array is expected" do
-      let(:expected) { [{name: 'Fred'}, {name: 'Mary'}] }
-      context "when an item with differing class values is found" do
-        let(:actual) { [{name: 'Fred'}, {name: 1}] }
-        let(:difference) { [
-          Pact::Matchers::NO_DIFF_INDICATOR,
-           {:name => {
-                :expected=> { :class=>String, :eg=>"Mary" },
-                :actual=> { :class=>Fixnum, :value=>1} }
-            }
-          ]
-        }
-        it "returns the diff" do
-          expect(structure_diff(expected, actual)).to eq difference
+      context "when an array is expected" do
+        let(:expected) { [{name: 'Fred'}, {name: 'Mary'}] }
+        context "when an item with differing class values is found" do
+          let(:actual) { [{name: 'Fred'}, {name: 1}] }
+          let(:difference) { [
+            Pact::Matchers::NO_DIFF_INDICATOR,
+             {:name =>
+                  Difference.new( { :class=>String, :eg=>"Mary" },
+                  { :class=>Fixnum, :value=>1} )
+              }
+            ]
+          }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
         end
       end
-    end
 
 
-    context "when nil is expected" do
-      let(:expected) { {a: nil} }
-      context "and a string is found" do
-        let(:actual) { {a: 'a string'} }
-        let(:difference) { {:a=>{:expected=>nil, :actual=>{:class=>String, :value=>"a string"}}} }
-        it "returns the diff" do
-          expect(structure_diff(expected, actual)).to eq difference
+      context "when nil is expected" do
+        let(:expected) { {a: nil} }
+        context "and a string is found" do
+          let(:actual) { {a: 'a string'} }
+          let(:difference) { {:a=>Difference.new(nil, {:class=>String, :value=>"a string"}) } }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
         end
       end
-    end
 
-    context "when a term is expected" do
-      let(:expected) { {a: Pact::Term.new(:matcher => /p/, :generate => 'apple')} }
-      context "and a non matching string is found" do
-        let(:actual) { {a: 'banana'} }
-        let(:difference) { {:a=>{:expected=>/p/, :actual=>"banana"}} }
-        it "returns the diff" do
-          expect(structure_diff(expected, actual)).to eq difference
+      context "when a term is expected" do
+        let(:expected) { {a: Pact::Term.new(:matcher => /p/, :generate => 'apple')} }
+        context "and a non matching string is found" do
+          let(:actual) { {a: 'banana'} }
+          let(:difference) { {:a=>Pact::Matchers::Difference.new(/p/,"banana")} }
+          it "returns the diff" do
+            expect(structure_diff(expected, actual)).to eq difference
+          end
         end
       end
     end
-  end
 
-  describe 'diffing' do
+    describe 'diffing' do
 
-    context "when expected is longer than the actual" do
-      subject { [1,2,3] }
-      let(:actual) { [1,2]}
-      let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Pact::Matchers::NO_DIFF_INDICATOR, {expected: 3, actual: Pact::IndexNotFound.new}] }
-      it 'returns the diff' do
-        expect(diff(subject, actual)).to eq(difference)
+      context "when expected is longer than the actual" do
+        subject { [1,2,3] }
+        let(:actual) { [1,2]}
+        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(3, Pact::IndexNotFound.new)] }
+        it 'returns the diff' do
+          expect(diff(subject, actual)).to eq(difference)
+        end
       end
-    end
 
-    context "when actual array is longer than the expected" do
-      subject { [1] }
-      let(:actual) { [1,2]}
-      let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, {expected: Pact::UnexpectedIndex.new , actual: 2}] }
-      it 'returns the diff' do
-        expect(diff(subject, actual)).to eq(difference)
+      context "when actual array is longer than the expected" do
+        subject { [1] }
+        let(:actual) { [1,2]}
+        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(Pact::UnexpectedIndex.new, 2)] }
+        it 'returns the diff' do
+          expect(diff(subject, actual)).to eq(difference)
+        end
       end
-    end
 
-    context 'where an expected value is a non-empty string' do
+      context 'where an expected value is a non-empty string' do
 
-      subject { {:a => 'a', :b => 'b'} }
+        subject { {:a => 'a', :b => 'b'} }
 
-      context 'and the actual value is an empty string' do
+        context 'and the actual value is an empty string' do
 
-        let(:actual) { {:a => 'a', :b => ''} }
+          let(:actual) { {:a => 'a', :b => ''} }
+
+          it 'includes this in the diff' do
+            expect(diff(subject, actual)).to eq({:b => Difference.new('b', '')})
+          end
 
-        it 'includes this in the diff' do
-          expect(diff(subject, actual)).to eql({:b => {:expected => 'b', :actual => ''}})
         end
 
       end
 
-    end
-
-    context "when the expected value is a hash" do
-      subject { {a: 'b'} }
-      context "when the actual value is an array" do
-        let(:actual) { [1] }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+      context "when the expected value is a hash" do
+        subject { {a: 'b'} }
+        context "when the actual value is an array" do
+          let(:actual) { [1] }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an hash" do
-        let(:actual) { {b: 'c'} }
-        let(:difference) { { a: {expected:"b", actual: Pact::KeyNotFound.new}} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an hash" do
+          let(:actual) { {b: 'c'} }
+          let(:difference) { { a: Difference.new("b",Pact::KeyNotFound.new)} }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an number" do
-        let(:actual) { 1 }
-        let(:difference) { {expected: {a: "b"}, actual: 1} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an number" do
+          let(:actual) { 1 }
+          let(:difference) { Difference.new({a: "b"}, 1)  }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is a string" do
-        let(:actual) { "Thing" }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is a string" do
+          let(:actual) { "Thing" }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is the same" do
-        let (:actual) { {a: 'b'} }
-        it "should return an empty hash" do
-          expect(diff(subject, actual)).to eql({})
+        context "when the actual value is the same" do
+          let (:actual) { {a: 'b'} }
+          it "should return an empty hash" do
+            expect(diff(subject, actual)).to eq({})
+          end
         end
       end
-    end
 
-    context "when the expected value is an array" do
-      subject { [1] }
-      context "when the actual value is an array" do
-        let(:actual) { [2] }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql([{expected: 1, actual: 2}])
+      context "when the expected value is an array" do
+        subject { [1] }
+        context "when the actual value is an array" do
+          let(:actual) { [2] }
+          let(:difference) { [Difference.new(1, 2)] }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq difference
+          end
         end
-      end
-      context "when the actual value is an hash" do
-        let(:actual) { {b: 'c'} }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an hash" do
+          let(:actual) { {b: 'c'} }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an number" do
-        let(:actual) { 1 }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an number" do
+          let(:actual) { 1 }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is a string" do
-        let(:actual) { "Thing" }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is a string" do
+          let(:actual) { "Thing" }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is the same" do
-        let (:actual) { [1] }
-        it "should return an empty hash" do
-          expect(diff(subject, actual)).to eql({})
+        context "when the actual value is the same" do
+          let (:actual) { [1] }
+          it "should return an empty hash" do
+            expect(diff(subject, actual)).to eql({})
+          end
         end
       end
-    end
 
-    context "when the expected value is a string" do
-      subject { "Thing"}
-      context "when the actual value is an array" do
-        let(:actual) { [2] }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+      context "when the expected value is a string" do
+        subject { "Thing"}
+        context "when the actual value is an array" do
+          let(:actual) { [2] }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an hash" do
-        let(:actual) { {b: 'c'} }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an hash" do
+          let(:actual) { {b: 'c'} }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an number" do
-        let(:actual) { 1 }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an number" do
+          let(:actual) { 1 }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is a string" do
-        let(:actual) { "Another Thing" }
-        let(:difference) { {expected: subject, actual: actual} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is a string" do
+          let(:actual) { "Another Thing" }
+          let(:difference) { Difference.new(subject, actual) }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is the same" do
-        let (:actual) { "Thing" }
-        it "should return an empty hash" do
-          expect(diff(subject, actual)).to eql({})
+        context "when the actual value is the same" do
+          let (:actual) { "Thing" }
+          it "should return an empty hash" do
+            expect(diff(subject, actual)).to eq({})
+          end
         end
       end
-    end
 
-    context "when the expected value is a number" do
-      subject { 1 }
-      let(:difference) { {expected: subject, actual: actual} }
-      context "when the actual value is an array" do
-        let(:actual) { [2] }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+      context "when the expected value is a number" do
+        subject { 1 }
+        let(:difference) { Difference.new(subject, actual) }
+        context "when the actual value is an array" do
+          let(:actual) { [2] }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an hash" do
-        let(:actual) { {b: 'c'} }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an hash" do
+          let(:actual) { {b: 'c'} }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is an number" do
-        let(:actual) { 2 }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is an number" do
+          let(:actual) { 2 }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is a string" do
-        let(:actual) { "Another Thing" }
-        it "should return the diff" do
-          expect(diff(subject, actual)).to eql(difference)
+        context "when the actual value is a string" do
+          let(:actual) { "Another Thing" }
+          it "should return the diff" do
+            expect(diff(subject, actual)).to eq(difference)
+          end
         end
-      end
-      context "when the actual value is the same" do
-        let (:actual) { 1 }
-        it "should return an empty hash" do
-          expect(diff(subject, actual)).to eql({})
+        context "when the actual value is the same" do
+          let (:actual) { 1 }
+          it "should return an empty hash" do
+            expect(diff(subject, actual)).to eq({})
+          end
         end
       end
-    end
 
-    context "when the expected value is a String matcher" do
+      context "when the expected value is a String matcher" do
 
-    end
+      end
 
-    context "when the expected value is a Number matcher" do
+      context "when the expected value is a Number matcher" do
 
-    end
-    context "when the expected value is an array with a matcher" do
+      end
+      context "when the expected value is an array with a matcher" do
 
-    end
-    context "when the expected value is a hash with a matcher" do
+      end
+      context "when the expected value is a hash with a matcher" do
 
-    end
+      end
 
-    context "when an expected value is nil but not nil is found" do
-      subject { {a: nil} }
-      let(:actual) { {a: 'blah'} }
-      let(:difference) { {:a=>{:expected=>nil, :actual=>"blah"}} }
-      it "should return the diff" do
-        expect(diff(subject, actual)).to eql(difference)
+      context "when an expected value is nil but not nil is found" do
+        subject { {a: nil} }
+        let(:actual) { {a: 'blah'} }
+        let(:difference) { {:a=>Difference.new(nil, "blah")} }
+        it "should return the diff" do
+          expect(diff(subject, actual)).to eq(difference)
+        end
       end
-    end
 
-    context "a deep mismatch" do
-      subject { {a:  {b: { c: [1,2]}, d: { e: Pact::Term.new(matcher: /a/, generate: 'apple')}}, f: 1, g: {h: 99}} }
-      let(:actual) { {a:  {b: { c: [1,2]}, d: { e: 'food'}}, f: "thing"} }
-      let(:difference) { {:a=>{:d=>{:e=>{:expected=>/a/, :actual=>"food"}}}, :f=>{:expected=>1, :actual=>"thing"}, :g=>{:expected=>{:h=>99}, :actual=> Pact::KeyNotFound.new}} }
+      context "a deep mismatch" do
+        subject { {a:  {b: { c: [1,2]}, d: { e: Pact::Term.new(matcher: /a/, generate: 'apple')}}, f: 1, g: {h: 99}} }
+        let(:actual) { {a:  {b: { c: [1,2]}, d: { e: 'food'}}, f: "thing"} }
+        let(:difference) { {:a=>{:d=>{:e=> Difference.new(/a/, "food")}},
+          :f=> Difference.new(1, "thing"),
+          :g=>Difference.new({:h=>99}, Pact::KeyNotFound.new)} }
 
-      it 'should return the diff' do
-        expect(diff(subject, actual)).to eq(difference)
+        it 'should return the diff' do
+          expect(diff(subject, actual)).to eq(difference)
+        end
       end
-    end
 
 
-    context "where a Pact::Term is found that matches the actual value" do
-      subject { {:a => Pact::Term.new(:matcher => /a/, :generate => 'apple')} }
-      let(:actual) { {:a => "apple" } }
+      context "where a Pact::Term is found that matches the actual value" do
+        subject { {:a => Pact::Term.new(:matcher => /a/, :generate => 'apple')} }
+        let(:actual) { {:a => "apple" } }
 
-      it 'does not include this in the diff' do
-        expect(diff(subject, actual)).to eq({})
+        it 'does not include this in the diff' do
+          expect(diff(subject, actual)).to eq({})
+        end
       end
-    end
 
-    context "where an array is expected at a key inside a hash, but a hash is found" do
-      subject { {:a => [1,2,3]} }
-      let(:actual) { {:a => {:b => 1} } }
+      context "where an array is expected at a key inside a hash, but a hash is found" do
+        subject { {:a => [1,2,3]} }
+        let(:actual) { {:a => {:b => 1} } }
 
-      it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eql({:a => {:expected => [1,2,3], :actual => {:b => 1}}})
+        it 'includes this in the diff' do
+          expect(diff(subject, actual)).to eq({:a => Difference.new([1,2,3], {:b => 1})})
+        end
       end
-    end
 
-    context "where an array is expected, but a hash is found" do
-      subject { {:a => :b} }
-      let(:actual) { [4,5,6] }
+      context "where an array is expected, but a hash is found" do
+        subject { {:a => :b} }
+        let(:actual) { [4,5,6] }
 
-      it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eq({:expected => {:a => :b}, :actual => [4,5,6] })
+        it 'includes this in the diff' do
+          expect(diff(subject, actual)).to eq(Difference.new({:a => :b}, [4,5,6] ))
+        end
       end
-    end
 
-    context "where a hash is expected, but array is found" do
-      subject { [4,5,6] }
-      let(:actual) { {:a => :b} }
+      context "where a hash is expected, but array is found" do
+        subject { [4,5,6] }
+        let(:actual) { {:a => :b} }
 
-      it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eq({:expected => [4,5,6], :actual => {:a => :b} })
+        it 'includes this in the diff' do
+          expect(diff(subject, actual)).to eq(Difference.new([4,5,6],{:a => :b}))
+        end
       end
-    end
 
-    context "when two different arrays are found" do
-      subject { [4,5,6] }
-      let(:actual) { [4,6,7] }
-      let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, {:expected=>5, :actual=>6}, {:expected=>6, :actual=>7}] }
+      context "when two different arrays are found" do
+        subject { [4,5,6] }
+        let(:actual) { [4,6,7] }
+        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(5, 6), Difference.new(6, 7)] }
 
-      it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eq(difference)
+        it 'includes this in the diff' do
+          expect(diff(subject, actual)).to eq(difference)
+        end
       end
-    end
 
-    context "when an array that matches the Pact::Term is found" do
-      subject { [Pact::Term.new(:matcher => /4/, :generate => '4'),"5","6"] }
-      let(:actual) { ["4","5","6"] }
+      context "when an array that matches the Pact::Term is found" do
+        subject { [Pact::Term.new(:matcher => /4/, :generate => '4'),"5","6"] }
+        let(:actual) { ["4","5","6"] }
 
-      it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eq({})
+        it 'includes this in the diff' do
+          expect(diff(subject, actual)).to eq({})
+        end
       end
+
     end
 
   end
-
 end