pact 0.1.28

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

@@ -0,0 +1,354 @@
+require 'spec_helper'
+require 'pact/term'
+require 'pact/matchers'
+
+describe Pact::Matchers do
+  include Pact::Matchers
+
+  describe 'structure_diff' do
+    let(:expected) {
+      {a: 'a string', b: 1, c: nil, d: [{e: 'thing'}], f: {g: 10}}
+    }
+
+    context "when the classes match" do
+      let(:actual) { {a: 'another string', b: 2, c: nil, d: [{e: 'something'}], f: {g: 100}} }
+      it "returns an empty hash" do
+        expect(structure_diff(expected, actual)).to be_empty
+      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'}}}  }
+
+      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
+      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
+          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
+        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
+        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
+        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
+        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
+        end          
+      end      
+    end
+  end
+
+  describe 'diffing' do
+
+    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 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)
+        end
+      end
+      context "when the actual value is an hash" do
+        let(:actual) { {b: 'c'} }
+        let(:difference) { { a: {expected:"b", actual: nil}} }
+        it "should return the diff" do
+          expect(diff(subject, actual)).to eql(difference)
+        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)
+        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)
+        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({})
+        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}])
+        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)
+        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)
+        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)
+        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) { {expected: subject, actual: actual} }
+        it "should return the diff" do
+          expect(diff(subject, actual)).to eql(difference)
+        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)
+        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)
+        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)
+        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({})
+        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)
+        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)
+        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)
+        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)
+        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 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=>{:expected=>nil, :actual=>"blah"}} }
+      it "should return the diff" do
+        expect(diff(subject, actual)).to eql(difference)
+      end
+    end
+
+    context "a deep mismatch" do
+      subject { {a:  {b: { c: [1,2]}, d: { e: Pact::Term.new(matcher: /a/)}}, 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=>nil}} }
+
+      it 'should return the diff' do
+        expect(diff(subject, actual)).to eql(difference)
+      end
+    end
+
+
+    context "where a Pact::Term is found that matches the actual value" do
+      subject { {:a => Pact::Term.new(:matcher => /a/)} }
+      let(:actual) { {:a => "apple" } }
+
+      it 'does not include this in the diff' do
+        expect(diff(subject, actual)).to eql({})
+      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 eql({:a => {:expected => [1,2,3], :actual => {: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 eql({:expected => {:a => :b}, :actual => [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 eql({:expected => [4,5,6], :actual => {: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, {:expected=>5, :actual=>6}, {:expected=>6, :actual=>7}] }
+
+      it 'includes this in the diff' do
+        expect(diff(subject, actual)).to eql(difference)
+      end
+    end
+
+    context "when an array that matches the Pact::Term is found" do
+      subject { [Pact::Term.new(:matcher => /4/),"5","6"] }
+      let(:actual) { ["4","5","6"] }
+
+      it 'includes this in the diff' do
+        expect(diff(subject, actual)).to eql({})
+      end
+    end
+
+  end
+
+end

data/spec/lib/pact/producer/configuration_dsl_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'pact/producer/configuration_dsl'
+
+module Pact::Producer
+  describe ConfigurationDSL do
+
+    class MockConfig
+      include ConfigurationDSL
+    end
+
+    describe "producer" do
+      let(:mock_config) { MockConfig.new }
+      context "when a producer is configured" do
+        before do
+          mock_config.producer do
+            name "Fred"
+            app { "An app" }
+          end
+        end
+        it "should allow configuration of the name" do
+          expect(mock_config.producer.name).to eql "Fred"
+        end
+        it "should allow configuration of the test app" do
+          expect(mock_config.producer.app).to eql "An app"
+        end
+      end
+      context "when a producer is not configured" do
+        it "raises an error" do
+          expect{ mock_config.producer }.to raise_error(/Please configure your producer/)
+        end
+      end
+    end
+
+
+    module ConfigurationDSL
+
+      describe ProducerDSL do
+
+        describe "initialize" do
+
+          context "with an object instead of a block" do
+            subject do
+              ProducerDSL.new do
+                name nil
+                app 'blah'
+              end
+            end
+            it "raises an error" do
+              expect{ subject }.to raise_error
+            end
+          end
+
+
+        end
+        describe "validate" do
+          context "when no name is provided" do
+            subject do
+              ProducerDSL.new do
+                app { Object.new }
+              end
+            end
+            it "raises an error" do
+              expect{ subject.validate}.to raise_error("Please provide a name for the Producer")
+            end
+          end
+          context "when nil name is provided" do
+            subject do
+              ProducerDSL.new do
+                name nil
+                app { Object.new }
+              end
+            end
+            it "raises an error" do
+              expect{ subject.validate}.to raise_error("Please provide a name for the Producer")
+            end
+          end
+          context "when no app is provided" do
+            subject do
+              ProducerDSL.new do
+                name 'Blah'
+              end
+            end
+            it "raises an error" do
+              expect{ subject.validate }.to raise_error("Please configure an app for the Producer")
+            end
+          end
+        end
+      end
+
+      describe ProducerConfig do
+        describe "app" do
+          subject { ProducerConfig.new("blah") { Object.new } }
+          it "should execute the app_block each time" do
+            expect(subject.app.object_id).to_not equal(subject.app.object_id)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/pact/producer/producer_state_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'pact/producer/producer_state'
+
+module Pact
+  module Producer
+
+    describe 'global ProducerState' do
+
+      MESSAGES = []
+
+      Pact.producer_state :no_alligators do
+        set_up do
+          MESSAGES << 'set_up'
+        end
+        tear_down do
+          MESSAGES << 'tear_down'
+        end
+      end
+
+      Pact.producer_state 'some alligators' do
+      end
+
+      before do
+        MESSAGES.clear
+      end
+
+      subject { ProducerState.get('no_alligators') }
+
+      describe 'set_up' do
+        it 'should call the block passed to set_up' do
+          subject.set_up
+          MESSAGES.should eq ['set_up']
+        end
+      end
+
+      describe 'tear_down' do
+        it 'should call the block passed to set_up' do
+          subject.tear_down
+          MESSAGES.should eq ['tear_down']
+        end
+      end
+
+      describe '.get' do
+        context 'when the name is a matching symbol' do
+          it 'will return the ProducerState' do
+            ProducerState.get('no_alligators').should_not be_nil
+          end
+        end
+        context 'when the name is a matching string' do
+          it 'will return the ProducerState' do
+            ProducerState.get('some alligators').should_not be_nil
+          end
+        end
+      end
+    end
+
+
+    describe 'namespaced ProducerStates' do
+
+      NAMESPACED_MESSAGES = []
+
+      Pact.with_consumer 'a consumer' do
+        producer_state 'the weather is sunny' do
+          set_up do
+            NAMESPACED_MESSAGES << 'sunny!'
+          end
+        end
+      end
+
+      Pact.producer_state 'the weather is cloudy' do
+        set_up do
+          NAMESPACED_MESSAGES << 'cloudy :('
+        end
+      end
+
+      before do
+        NAMESPACED_MESSAGES.clear
+      end
+
+      describe '.get' do
+        context 'for a consumer' do
+          it 'has a namespaced name' do
+            ProducerState.get('the weather is sunny', :for => 'a consumer').should_not be_nil
+          end
+
+          it 'falls back to a global state of the same name if one is not found for the specified consumer' do
+            ProducerState.get('the weather is cloudy', :for => 'a consumer').should_not be_nil
+          end
+        end
+
+      end
+
+      describe 'set_up' do
+        context 'for a consumer' do
+          it 'runs its own setup' do
+            ProducerState.get('the weather is sunny', :for => 'a consumer').set_up
+            NAMESPACED_MESSAGES.should eq ['sunny!']
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact/producer/rspec_spec.rb

@@ -0,0 +1,48 @@
+require 'pact/producer/rspec'
+
+describe "the match_term matcher" do
+
+  it 'does not match a hash to an array' do
+    expect({}).to_not match_term([])
+  end
+
+  it 'does not match an array to a hash' do
+    expect([]).to_not match_term({})
+  end
+
+  it 'matches regular expressions' do
+    expect('blah').to match_term(/[a-z]*/)
+  end
+
+  it 'matches pact terms' do
+    expect('wootle').to match_term Pact::Term.new(generate:'wootle', matcher:/woot../)
+  end
+
+  it 'matches all elements of arrays' do
+    expect(['one', 'two', ['three']]).to match_term [/one/, 'two', [Pact::Term.new(generate:'three', matcher:/thr../)]]
+  end
+
+  it 'matches all values of hashes' do
+    expect({1 => 'one', 2 => 2, 3 => 'three'}).to match_term({1 => /one/, 2 => 2, 3 => Pact::Term.new(generate:'three', matcher:/thr../)})
+  end
+
+  it 'matches all other objects using ==' do
+    expect('wootle').to match_term 'wootle'
+  end
+
+  # Note: because a consumer specifies only the keys it cares about, the pact ignores keys that are returned
+  # by the producer, but not are not specified in the pact. This means that any hash will match an
+  # expected empty hash, because there is currently no way for a consumer to expect an absence of keys.
+  it 'is confused by an empty hash' do
+    expect({:hello => 'everyone'}).to match_term({})
+  end
+
+  it 'should not be confused by an empty array' do
+    expect(['blah']).to_not match_term([])
+  end
+
+  it "should allow matches on an array where each item in the array only contains a subset of the actual" do
+    expect([{name: 'Fred', age: 12}, {name: 'John', age: 13}]).to match_term([{name: 'Fred'}, {name: 'John'}])
+  end
+
+end

data/spec/lib/pact/reification_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Pact
+  describe Reification do
+
+    let(:response_spec) do
+      {
+        woot: /x/,
+        britney: 'britney',
+        nested: { foo: /bar/, baz: 'qux' },
+        my_term: Term.new(generate: 'wiffle', matcher: /^wif/),
+        array: ['first', /second/]
+      }
+    end
+
+    describe "from term" do
+
+      subject { Reification.from_term(response_spec) }
+
+      it "converts regexes into real data" do
+        expect(subject[:woot]).to eql 'x'
+      end
+
+      it "converts terms into real data" do
+        expect(subject[:my_term]).to eql 'wiffle'
+      end
+
+      it "passes strings through" do
+        expect(subject[:britney]).to eql 'britney'
+      end
+
+      it "handles nested hashes" do
+        expect(subject[:nested]).to eql({ foo: 'bar', baz: 'qux' })
+      end
+
+      it "handles arrays" do
+        expect(subject[:array]).to eql ['first', 'second']
+      end
+
+    end
+
+  end
+end