pact 1.3.3 → 1.4.0.rc2

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/difference'
-
-module Pact
-  module Matchers
-    describe Difference do
-
-      describe "#as_json" do
-
-        context "when something other than a regexp is expected" do
-
-          subject { Difference.new("apple", 'pear').as_json }
-
-          it "indicates that the actual was intended 'to eq'" do
-            expect(subject).to eq({:EXPECTED => "apple", :ACTUAL => "pear"})
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/embedded_diff_formatter'
-require 'pact/matchers/type_difference'
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-
-module Pact
-  module Matchers
-    describe EmbeddedDiffFormatter do
-
-      let(:diff) do
-        {
-          :something => TypeDifference.new(ExpectedType.new("Fred"), ActualType.new(1))
-        }
-      end
-
-      subject { EmbeddedDiffFormatter.call(diff, options) }
-
-      let(:options) { { colour: colour }}
-      let(:expected_coloured) { '"' + ::Term::ANSIColor.red("expected_type") + '":'}
-      let(:actual_coloured) { '"' + ::Term::ANSIColor.green("actual_type") + '":'}
-
-      describe ".call" do
-
-        let(:colour) { false }
-
-        context "when color_enabled is true" do
-
-          let(:colour) { true }
-
-          it "returns nicely formatted json" do
-            expect(subject.split("\n").size).to eq 6
-          end
-
-          it "returns a string displaying the diff in colour" do
-            expect(subject).to include expected_coloured
-            expect(subject).to include actual_coloured
-          end
-        end
-
-        context "when color_enabled is false" do
-
-          let(:colour) { false }
-
-          it "returns nicely formatted json" do
-            expect(subject.split("\n").size).to eq 6
-          end
-
-          it "returns a string displaying the diff without colour" do
-            expect(subject).to_not include expected_coloured
-            expect(subject).to_not include actual_coloured
-          end
-        end
-
-        context "with a Pact::Term" do
-          let(:diff) { {thing: Difference.new(Pact::Term.new(generate: "Joe", matcher: /Jo/), "Mary")} }
-
-          xit "displays the matcher from the Pact::Term" do
-            expect(subject).to_not include("Pact::Term")
-            expect(subject).to include("/Jo/")
-          end
-
-        end
-
-        context "when no options are specified" do
-          subject { EmbeddedDiffFormatter.call(diff) }
-
-          context "when Pact.configuration.color_enabled is true" do
-            it "returns a string displaying the diff in colour" do
-              expect(Pact.configuration).to receive(:color_enabled).and_return(true)
-              expect(subject).to include expected_coloured
-              expect(subject).to include actual_coloured
-            end
-          end
-
-          context "when Pact.configuration.color_enabled is false" do
-            it "returns a string displaying the diff without colour" do
-              expect(Pact.configuration).to receive(:color_enabled).and_return(false)
-              expect(subject).to_not include expected_coloured
-              expect(subject).to_not include actual_coloured
-            end
-          end
-
-        end
-      end
-
-    end
-
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/index_not_found'
-
-module Pact
-  describe IndexNotFound do
-
-    describe "#as_json" do
-      it "returns a string representation of the object" do
-        expect(subject.as_json).to eq subject.to_s
-      end
-    end
-
-    describe "#to_json" do
-      it "serialises the object to JSON" do
-        expect(subject.to_json).to eq "\"#{subject.to_s}\""
-      end
-    end
-
-  end
-
-end

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

@@ -1,114 +0,0 @@
-require 'spec_helper'
-require 'pact/matchers/list_diff_formatter'
-require 'pact/matchers/matchers'
-
-module Pact
-  module Matchers
-    describe ListDiffFormatter do
-
-      describe ".call" do
-        subject{ ListDiffFormatter.call(diff, {}) }
-
-        context "when using class based matching" do
-          let(:diff) { {root: TypeDifference.new(ExpectedType.new("Fred"), ActualType.new(1)) } }
-          let(:expected_output) { <<-EOS
-\tAt:
-\t\t[:root]
-\tExpected type:
-\t\tString
-\tActual type:
-\t\tFixnum
-EOS
-          }
-
-          it "shows the expected and actual classes" do
-            expect(subject + "\n").to eq(expected_output)
-          end
-
-        end
-
-        context "when there is an unmatched regexp" do
-          let(:diff) { {root: RegexpDifference.new(/fr.*ed/, "mary") } }
-          let(:expected_output) { <<-EOS
-\tAt:
-\t\t[:root]
-\tExpected to match:
-\t\t/fr.*ed/
-\tActual:
-\t\t"mary"
-EOS
-          }
-          it "shows the expected regexp" do
-            expect(subject + "\n").to eq(expected_output)
-          end
-        end
-
-        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 match(/Expected:.*"alphabet"/m)
-          end
-          it "includes the actual value" do
-            expect(subject).to match(/Actual:.*"woozle"/m)
-          end
-
-          it "includes the path" do
-            expect(subject).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 match(/Missing key with value\:.*\{/m)
-          end
-
-          it "includes the path" do
-            expect(subject).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 match(/Missing.*1/m)
-          end
-
-          it "includes the path" do
-            expect(subject).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 include("Array contained unexpected item:")
-          end
-
-          it "includes the path" do
-            expect(subject).to include('[1]')
-            expect(subject).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 include("Hash contained unexpected key with value:")
-          end
-
-          it "includes the path" do
-            expect(subject).to include('["blah"]')
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,500 +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
-
-    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) { [
-            Pact::Matchers::NO_DIFF_INDICATOR,
-             {: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: /p/}, nil)} }
-          it "returns the diff with the regexp unpacked" 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) { [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
-
-      context "when the different index is in the middle of an array" do
-        subject { [1,2,3] }
-        let(:actual) { [1,7,3]}
-        let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Difference.new(2, 7), Pact::Matchers::NO_DIFF_INDICATOR] }
-        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) { [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
-
-      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 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) { [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)
-        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