pact-support 1.9.0 → 1.15.0

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

@@ -1,146 +0,0 @@
-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
-
-      context "with an ArrayLike" do
-        context "with an extra item that is an Integer" do
-          let(:expected) { {thing: Pact.like([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
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers'
-require 'pact/consumer_contract/headers'
-require 'support/ruby_version_helpers'
-
-module Pact::Matchers
-
-  describe Pact::Matchers do
-    include Pact::Matchers
-    extend RubyVersionHelpers
-
-    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_numeric} (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_numeric} (like 1) but got nil at <path>"],
-        [Pact.like(INT), STRING, "Expected #{a_numeric} (like 1) but got a String (\"foo\") at <path>"],
-        [Pact.like(INT), FLOAT, "Expected #{a_numeric} (like 1) but got a Float (1.0) at <path>"],
-        [Pact.like(INT), HASH, "Expected #{a_numeric} (like 1) but got a Hash at <path>"],
-        [Pact.like(INT), ARRAY, "Expected #{a_numeric} (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_numeric} (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_numeric} (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

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers'
-require 'pact/consumer_contract/headers'
-require 'support/ruby_version_helpers'
-
-module Pact::Matchers
-
-  describe Pact::Matchers do
-    include Pact::Matchers
-    include RubyVersionHelpers
-
-    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 numeric" 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_numeric} (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 numeric" 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_numeric} (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 numeric" do
-          let(:actual) { INT }
-          it "returns a message" do
-            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got #{a_numeric} (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 numeric" do
-          let(:actual) { INT }
-          it "returns a message" do
-            expect(difference[:thing].message).to eq "Expected a String matching /foo/ but got #{a_numeric} (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

@@ -1,521 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers'
-require 'pact/consumer_contract/headers'
-
-module Pact::Matchers
-
-  describe Pact::Matchers do
-    include Pact::Matchers
-
-    # TODO this is an integration test
-    describe 'matching headers' do
-      let(:expected) { Pact::Headers.new('Content-Type' => 'application/hippo')}
-
-      context "when the headers match in a case insensitive way" do
-
-        context "when the values match" do
-          let(:actual) { Pact::Headers.new('CONTENT-TYPE' => 'application/hippo')}
-          it "returns an empty diff" do
-            expect(diff(expected, actual)).to be_empty
-          end
-        end
-
-        context "when the header values do not match" do
-          let(:actual) { Pact::Headers.new('CONTENT-TYPE' => 'application/alligator')}
-          let(:difference) { {"Content-Type" => Difference.new('application/hippo', 'application/alligator')} }
-          it "returns the diff" do
-            expect(diff(expected, actual)).to eq difference
-          end
-        end
-      end
-
-      context "when the headers do not match" do
-
-        let(:actual) { Pact::Headers.new('Content-Length' => '1')}
-        let(:difference) { {"Content-Type" => Difference.new('application/hippo', Pact::KeyNotFound.new)} }
-        it "returns a diff" do
-          expect(diff(expected, actual)).to eq difference
-        end
-
-      end
-
-    end
-
-    describe 'matching with something like' do
-
-      context 'when the actual is something like the expected' do
-        let(:expected) { Pact::SomethingLike.new( { a: 1 } ) }
-        let(:actual)   { { a: 2 } }
-
-        it 'returns an empty diff' do
-          expect(diff(expected, actual)).to eq({})
-        end
-
-      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: [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
-      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
-
-    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
-
-    describe "expecting a string matching a regexp and not finding key" do
-      let(:expected) { {a: /b/} }
-      let(:actual) { {} }
-      let(:difference) { {:a=> RegexpDifference.new(/b/, Pact::KeyNotFound.new) } }
-      it "returns the diff" do
-        expect(diff(expected, actual)).to eq difference
-      end
-    end
-
-    describe 'type_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(type_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=>TypeDifference.new(Pact::ExpectedType.new("blah"), Pact::KeyNotFound.new)} }
-        it "returns the difference" do
-          expect(type_diff(expected, actual)).to eq difference
-        end
-      end
-
-      context "when a number is expected" do
-        let(:expected) { {a: 1} }
-        let(:difference) { {a: TypeDifference.new(Pact::ExpectedType.new(1) , Pact::ActualType.new('a string'))}  }
-
-        context "and a string is found" do
-          let(:actual) { {a: 'a string'}}
-          it "returns the diff" do
-            expect(type_diff(expected, actual)).to eq difference
-          end
-        end
-        context "and nil is found" do
-          let(:actual) { {a: nil} }
-          let(:difference ) { {a: TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new(nil)) } }
-          it "returns the diff" do
-            expect(type_diff(expected, actual)).to eq difference
-          end
-        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})) } }
-          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]))}}
-          it "returns the diff" do
-            expect(type_diff(expected, actual)).to eq difference
-          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) {
-            [
-              NoDiffAtIndex.new,
-              {
-                name: TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
-              }
-            ]
-          }
-          it "returns the diff" do
-            expect(type_diff(expected, actual)).to eq difference
-          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: 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
-        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=>Pact::Matchers::RegexpDifference.new(/p/,"banana")} }
-          it "returns the diff" do
-            expect(type_diff(expected, actual)).to eq difference
-          end
-        end
-      end
-
-      context "when a term is expected inside a missing hash" do
-        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: "apple"}, nil)} }
-          it "returns the diff with the term reified" do
-            expect(type_diff(expected, actual)).to eq difference
-          end
-        end
-      end
-
-      context "when unexpected keys are allowed" do
-        let(:expected) { { a: 'b' } }
-        let(:actual) { {a: 'c', d: 'e'} }
-        let(:difference) { {} }
-        it "returns the diff" do
-          expect(type_diff(expected, actual, allow_unexpected_keys: true)).to eq difference
-        end
-      end
-
-      context "when unexpected keys are not allowed" do
-        let(:expected) { { a: 'b' } }
-        let(:actual) { {a: 'c', d: 'e'} }
-        let(:difference) { {d: Difference.new(Pact::UnexpectedKey.new, 'e')} }
-        it "returns the diff" do
-          expect(type_diff(expected, actual, allow_unexpected_keys: false)).to eq difference
-        end
-      end
-    end
-
-    describe 'diffing' do
-
-      context "when expected is longer than the actual" do
-        subject { [1, 2, 3] }
-        let(:actual) { [1, 2] }
-        let(:difference) { [NoDiffAtIndex.new, NoDiffAtIndex.new, Difference.new(3, Pact::IndexNotFound.new)] }
-        it 'returns the diff' do
-          expect(diff(subject, actual)).to eq(difference)
-        end
-      end
-
-      context "when the different index is in the middle of an array" do
-        subject { [1,2,3] }
-        let(:actual) { [1,7,3]}
-        let(:difference) { [NoDiffAtIndex.new, Difference.new(2, 7), NoDiffAtIndex.new] }
-        it 'returns the diff' do
-          expect(diff(subject, actual)).to eq(difference)
-        end
-      end
-
-      context "when actual array is longer than the expected" do
-        subject { [1] }
-        let(:actual) { [1,2]}
-        let(:difference) { [NoDiffAtIndex.new, Difference.new(Pact::UnexpectedIndex.new, 2)] }
-        it 'returns the diff' do
-          expect(diff(subject, actual)).to eq(difference)
-        end
-      end
-
-      context 'where an expected value is a non-empty string' do
-
-        subject { {:a => 'a', :b => 'b'} }
-
-        context 'and the actual value is an empty string' do
-
-          let(:actual) { {:a => 'a', :b => ''} }
-
-          it 'includes this in the diff' do
-            expect(diff(subject, actual)).to eq({:b => Difference.new('b', '')})
-          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) { Difference.new(subject, actual) }
-          it "should return the diff" do
-            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: [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)} }
-          it "should return the diff" do
-            expect(diff(subject, actual)).to eq(difference)
-          end
-        end
-        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
-        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
-        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
-
-      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
-        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
-        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
-        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
-        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
-
-      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
-        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
-        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
-        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
-        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
-
-      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
-        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
-        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
-        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
-        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
-
-      context "when the expected value is a String matcher" do
-
-      end
-
-      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 a hash with a matcher" do
-
-      end
-
-      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
-
-      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=> RegexpDifference.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)
-        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" } }
-
-        it 'does not include this in the diff' do
-          expect(diff(subject, actual)).to eq({})
-        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} } }
-
-        it 'includes this in the diff' do
-          expect(diff(subject, actual)).to eq({:a => Difference.new([1,2,3], {:b => 1})})
-        end
-      end
-
-      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(Difference.new({:a => :b}, [4,5,6] ))
-        end
-      end
-
-      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(Difference.new([4,5,6],{:a => :b}))
-        end
-      end
-
-      context "when two different arrays are found" do
-        subject { [4,5,6] }
-        let(:actual) { [4, 6, 7] }
-        let(:difference) { [NoDiffAtIndex.new, Difference.new(5, 6), Difference.new(6, 7)] }
-
-        it 'includes this in the diff' do
-          expect(diff(subject, actual)).to eq(difference)
-        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"] }
-
-        it 'includes this in the diff' do
-          expect(diff(subject, actual)).to eq({})
-        end
-      end
-
-    end
-
-  end
-end