pact 1.1.0.rc2 → 1.1.0.rc3

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

@@ -5,21 +5,11 @@ module Pact
   module Matchers
     describe Difference do
 
-      describe "#to_hash" do
-
-        context "when a regexp is expected" do
-
-          subject { Difference.new(/ap/, 'pear').to_hash }
-
-          it "indicates that the actual was indended 'to match'" do
-            expect(subject).to eq({:EXPECTED_TO_MATCH => "/ap/", :ACTUAL => "pear"})
-          end
-
-        end
+      describe "#as_json" do
 
         context "when something other than a regexp is expected" do
 
-          subject { Difference.new("apple", 'pear').to_hash }
+          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"})

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

@@ -0,0 +1,77 @@
+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) { true }
+
+        context "when color_enabled is true" do
+          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 "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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -43,13 +43,13 @@ module Pact::Matchers
     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) } }
+      let(:difference) { {:a=> RegexpDifference.new(/b/, Pact::KeyNotFound.new) } }
       it "returns the diff" do
         expect(diff(expected, actual)).to eq difference
       end
     end
 
-    describe 'structure_diff' do
+    describe 'type_diff' do
       let(:expected) {
         {a: 'a string', b: 1, c: nil, d: [{e: 'thing'}], f: {g: 10}, h: false}
       }
@@ -58,49 +58,48 @@ module Pact::Matchers
         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
+          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=>Difference.new({:class=>String, :eg=>"blah"}, Pact::KeyNotFound.new)} }
+        let(:difference) { {:b=>TypeDifference.new(Pact::ExpectedType.new("blah"), Pact::KeyNotFound.new)} }
         it "returns the difference" do
-          expect(structure_diff(expected, actual)).to eq difference
+          expect(type_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: Difference.new({:class => Fixnum, eg: 1 } , {:class => String, :value => 'a string'})}  }
+        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(structure_diff(expected, actual)).to eq difference
+            expect(type_diff(expected, actual)).to eq difference
           end
         end
         context "and nil is found" do
           let(:actual) { {a: nil}}
-          let(:difference ) { {a: Difference.new({:class => Fixnum, eg: 1}, nil) } }
+          let(:difference ) { {a: TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new(nil)) } }
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            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=>Difference.new({:class=>Fixnum, :eg=>1}, {:class=>Hash, :value=>{:b=>1}}) } }
+          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new({:b=>1})) } }
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            expect(type_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]} ) } }
+          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(1), Pact::ActualType.new([1]))}}
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            expect(type_diff(expected, actual)).to eq difference
           end
         end
       end
@@ -112,13 +111,12 @@ module Pact::Matchers
           let(:difference) { [
             Pact::Matchers::NO_DIFF_INDICATOR,
              {:name =>
-                  Difference.new( { :class=>String, :eg=>"Mary" },
-                  { :class=>Fixnum, :value=>1} )
+                  TypeDifference.new(Pact::ExpectedType.new("Mary"), Pact::ActualType.new(1))
               }
             ]
           }
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            expect(type_diff(expected, actual)).to eq difference
           end
         end
       end
@@ -128,9 +126,9 @@ module Pact::Matchers
         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"}) } }
+          let(:difference) { {:a=>TypeDifference.new(Pact::ExpectedType.new(nil), Pact::ActualType.new("a string")) } }
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            expect(type_diff(expected, actual)).to eq difference
           end
         end
       end
@@ -139,12 +137,30 @@ module Pact::Matchers
         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")} }
+          let(:difference) { {:a=>Pact::Matchers::RegexpDifference.new(/p/,"banana")} }
           it "returns the diff" do
-            expect(structure_diff(expected, actual)).to eq difference
+            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
@@ -367,7 +383,7 @@ module Pact::Matchers
       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")}},
+        let(:difference) { {:a=>{:d=>{:e=> RegexpDifference.new(/a/, "food")}},
           :f=> Difference.new(1, "thing"),
           :g=>Difference.new({:h=>99}, Pact::KeyNotFound.new)} }
 

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'pact/matchers/regexp_difference'
+
+module Pact
+  module Matchers
+    describe RegexpDifference do
+
+      context "when a regexp is expected" do
+
+        subject { RegexpDifference.new(/ap/, 'pear').as_json }
+
+        it "indicates that the actual was indended 'to match'" do
+          expect(subject).to eq({:EXPECTED_TO_MATCH => "/ap/", :ACTUAL => "pear"})
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'pact/matchers/type_difference'
+
+module Pact
+  module Matchers
+    describe TypeDifference do
+
+      describe "#as_json" do
+
+        let(:expected) { ExpectedType.new("Fred") }
+        let(:actual) { ActualType.new(1) }
+        subject { TypeDifference.new expected, actual }
+
+        context "when the actual is a KeyNotFound" do
+          let(:actual) { KeyNotFound.new }
+          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL => actual.to_s } }
+
+          it "use the key ACTUAL" do
+            expect(subject.as_json).to eq(expected_hash)
+          end
+        end
+
+        context "when the actual is an ActualType" do
+          let(:expected_hash) { {:EXPECTED_TYPE => "String", :ACTUAL_TYPE => "Fixnum" } }
+
+          it "uses the key ACTUAL_TYPE" do
+             expect(subject.as_json).to eq(expected_hash)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'pact/matchers/unexpected_index'
+
+module Pact
+  describe UnexpectedIndex 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