pact 1.0.9 → 1.0.10

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

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'pact/term'
-require 'pact/something_like'
 require 'pact/matchers'
 
 describe Pact::Matchers do
@@ -24,7 +22,7 @@ describe Pact::Matchers do
     context "when an unexpected key is found" do
       let(:expected) { {:a => 1} }
       let(:actual) { {:a => 1, :b => 2} }
-      let(:difference) { {:b => {:expected => '<key not to be present>', :actual => 2 }} }
+      let(:difference) { {:b => {:expected => Pact::UnexpectedKey.new, :actual => 2 }} }
       it "returns it in the diff" do
         expect(diff(expected, actual, allow_unexpected_keys: false)).to eq difference
       end
@@ -34,7 +32,7 @@ describe Pact::Matchers do
   describe "expecting key to be present with nil value and not finding key" do
     let(:expected) { {a: nil} }
     let(:actual) { {} }
-    let(:difference) { {a: {expected: nil, actual: Pact::Matchers::KeyNotFound.new }} }
+    let(:difference) { {a: {expected: nil, actual: Pact::KeyNotFound.new }} }
     it "returns the key in the diff" do
       expect(diff(expected, actual)).to eq difference
     end
@@ -56,7 +54,7 @@ describe Pact::Matchers do
     context "when a key is not found" do
       let(:actual) { {a: 'blah'} }
       let(:expected) { {b: 'blah'} }
-      let(:difference) { {:b=>{:expected=>{:class=>String, :eg=>"blah"}, :actual=>Pact::Matchers::KeyNotFound.new}} }
+      let(:difference) { {:b=>{:expected=>{:class=>String, :eg=>"blah"}, :actual=>Pact::KeyNotFound.new}} }
       it "returns the difference" do
         expect(structure_diff(expected, actual)).to eq difference
       end
@@ -140,6 +138,24 @@ describe Pact::Matchers do
 
   describe 'diffing' do
 
+    context "when expected is longer than the actual" do
+      subject { [1,2,3] }
+      let(:actual) { [1,2]}
+      let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, Pact::Matchers::NO_DIFF_INDICATOR, {expected: 3, actual: Pact::IndexNotFound.new}] }
+      it 'returns the diff' do
+        expect(diff(subject, actual)).to eq(difference)
+      end
+    end
+
+    context "when actual array is longer than the expected" do
+      subject { [1] }
+      let(:actual) { [1,2]}
+      let(:difference) { [Pact::Matchers::NO_DIFF_INDICATOR, {expected: Pact::UnexpectedIndex.new , actual: 2}] }
+      it 'returns the diff' do
+        expect(diff(subject, actual)).to eq(difference)
+      end      
+    end
+
     context 'where an expected value is a non-empty string' do
 
       subject { {:a => 'a', :b => 'b'} }
@@ -167,7 +183,7 @@ describe Pact::Matchers do
       end
       context "when the actual value is an hash" do
         let(:actual) { {b: 'c'} }
-        let(:difference) { { a: {expected:"b", actual: Pact::Matchers::KeyNotFound.new}} }
+        let(:difference) { { a: {expected:"b", actual: Pact::KeyNotFound.new}} }
         it "should return the diff" do
           expect(diff(subject, actual)).to eql(difference)
         end
@@ -331,10 +347,10 @@ describe Pact::Matchers do
     context "a deep mismatch" do
       subject { {a:  {b: { c: [1,2]}, d: { e: Pact::Term.new(matcher: /a/, generate: 'apple')}}, f: 1, g: {h: 99}} }
       let(:actual) { {a:  {b: { c: [1,2]}, d: { e: 'food'}}, f: "thing"} }
-      let(:difference) { {:a=>{:d=>{:e=>{:expected=>/a/, :actual=>"food"}}}, :f=>{:expected=>1, :actual=>"thing"}, :g=>{:expected=>{:h=>99}, :actual=> Pact::Matchers::KeyNotFound.new}} }
+      let(:difference) { {:a=>{:d=>{:e=>{:expected=>/a/, :actual=>"food"}}}, :f=>{:expected=>1, :actual=>"thing"}, :g=>{:expected=>{:h=>99}, :actual=> Pact::KeyNotFound.new}} }
 
       it 'should return the diff' do
-        expect(diff(subject, actual)).to eql(difference)
+        expect(diff(subject, actual)).to eq(difference)
       end
     end
 
@@ -344,7 +360,7 @@ describe Pact::Matchers do
       let(:actual) { {:a => "apple" } }
 
       it 'does not include this in the diff' do
-        expect(diff(subject, actual)).to eql({})
+        expect(diff(subject, actual)).to eq({})
       end
     end
 
@@ -362,7 +378,7 @@ describe Pact::Matchers do
       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] })
+        expect(diff(subject, actual)).to eq({:expected => {:a => :b}, :actual => [4,5,6] })
       end
     end
 
@@ -371,7 +387,7 @@ describe Pact::Matchers do
       let(:actual) { {:a => :b} }
 
       it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eql({:expected => [4,5,6], :actual => {:a => :b} })
+        expect(diff(subject, actual)).to eq({:expected => [4,5,6], :actual => {:a => :b} })
       end
     end
 
@@ -381,7 +397,7 @@ describe Pact::Matchers do
       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)
+        expect(diff(subject, actual)).to eq(difference)
       end
     end
 
@@ -390,7 +406,7 @@ describe Pact::Matchers do
       let(:actual) { ["4","5","6"] }
 
       it 'includes this in the diff' do
-        expect(diff(subject, actual)).to eql({})
+        expect(diff(subject, actual)).to eq({})
       end
     end
 

data/spec/lib/pact/provider/configuration_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'pact/provider/configuration'
+
+module Pact::Provider::Configuration
+
+  describe "service_provider" do
+
+    before do
+      Pact.clear_configuration
+    end
+
+    let(:mock_config) { MockConfig.new }
+    context "when a provider is configured" do
+      before do
+        Pact.service_provider "Fred" do
+          app { "An app" }
+        end
+      end
+      it "should allow configuration of the test app" do
+        expect(Pact.configuration.provider.app).to eql "An app"
+      end
+    end
+
+    context "when a provider is not configured" do
+      it "raises an error" do
+        expect{ Pact.configuration.provider }.to raise_error(/Please configure your provider/)
+      end
+    end
+  end
+
+  describe PactVerification do
+
+    describe 'create_verification' do
+      let(:url) {'http://some/uri'}
+      let(:consumer_name) {'some consumer'}
+      let(:ref) {:prod}
+      let(:options) { {:ref => :prod} }
+      context "with valid values" do
+        subject do
+          uri = url
+          PactVerification.build(consumer_name, options) do
+            pact_uri uri
+          end
+        end
+
+        it "creates a Verification" do
+          Pact::Provider::PactVerification.should_receive(:new).with(consumer_name, url, ref)
+          subject
+        end
+      end
+
+      context "with a nil uri" do
+        subject do
+          PactVerification.build(consumer_name, options) do
+            pact_uri nil
+          end
+        end
+
+        it "raises a validation error" do
+          expect{ subject }.to raise_error /Please provide a pact_uri/
+        end
+      end
+    end
+  end
+
+  describe ServiceProviderDSL do
+
+    describe "initialize" do
+
+      context "with an object instead of a block" do
+        subject do
+          ServiceProviderDSL.build 'name' do
+            app 'blah'
+          end
+        end
+        it "raises an error" do
+          expect{ subject }.to raise_error /wrong number of arguments/
+        end
+      end
+
+    end
+
+    describe "validate" do
+      context "when no name is provided" do
+        subject do
+          ServiceProviderDSL.new ' ' do
+            app { Object.new }
+          end
+        end
+        it "raises an error" do
+          expect{ subject.send(:validate)}.to raise_error("Please provide a name for the Provider")
+        end
+      end
+      context "when nil name is provided" do
+        subject do
+          ServiceProviderDSL.new nil do
+            app { Object.new }
+          end
+        end
+        it "raises an error" do
+          expect{ subject.send(:validate)}.to raise_error("Please provide a name for the Provider")
+        end
+      end
+      context "when no app is provided" do
+        subject do
+          ServiceProviderDSL.new 'Blah' do
+          end
+        end
+        it "raises an error" do
+          expect{ subject.send(:validate) }.to raise_error("Please configure an app for the Provider")
+        end
+      end
+    end
+
+    describe 'honours_pact_with' do
+      before do
+        Pact.clear_configuration
+      end
+
+      context "with no optional params" do
+        subject do
+          ServiceProviderDSL.build 'some-provider' do
+            app {}
+            honours_pact_with 'some-consumer' do
+              pact_uri 'blah'
+            end
+          end
+        end
+        it 'adds a verification to the Pact.configuration' do
+          subject
+          expect(Pact.configuration.pact_verifications.first).to eq(Pact::Provider::PactVerification.new('some-consumer', 'blah', :head))
+        end
+      end
+
+      context "with all params specified" do
+        subject do
+          ServiceProviderDSL.build 'some-provider' do
+            app {}
+            honours_pact_with 'some-consumer', :ref => :prod do
+              pact_uri 'blah'
+            end
+          end
+        end
+        it 'adds a verification to the Pact.configuration' do
+          subject
+          expect(Pact.configuration.pact_verifications.first).to eq(Pact::Provider::PactVerification.new('some-consumer', 'blah', :prod))
+        end
+
+      end
+
+    end
+  end
+
+  describe ServiceProviderConfig do
+    describe "app" do
+      subject { ServiceProviderConfig.new { 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

data/spec/lib/pact/provider/request_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'pact/provider/request'
+
+describe Pact::Provider::Request::Replayable do
+
+  let(:path) { '/path?something' }
+  let(:body) { {a: 'body'} }
+  let(:headers) { {} }
+  let(:expected_request) do 
+    instance_double('Pact::Request::Expected', 
+      :method => 'post', 
+      :full_path => path, 
+      :body => body,
+      :headers => headers)
+  end
+
+  subject { described_class.new(expected_request)}
+
+  describe "method" do
+    it 'returns the method' do
+      expect(subject.method).to eq 'post'
+    end
+  end
+  describe "path" do
+    it "returns the full path" do
+      expect(subject.path).to eq(path)
+    end
+  end
+
+  describe "body" do
+    context "when body is a NullExpectation" do
+      let(:body) { Pact::NullExpectation.new }
+      it "returns an empty string, not sure if it should do this or return nil???" do
+        expect(subject.body).to eq ""
+      end
+    end
+    context "when body is an empty string" do
+      let(:body) { '' }
+      it "returns an empty string" do
+        expect(subject.body).to eq ""
+      end
+    end
+    context "when body is a string" do
+      let(:body) { 'a string'}
+      it "returns the string" do
+        expect(subject.body).to eq body
+      end
+    end
+    context "when body is a Term" do
+      let(:body) { Pact::Term.new(generate: 'a', matcher: /a/) }
+      it "returns the generated value" do
+        expect(subject.body).to eq "a"
+      end
+    end
+    context "when body is not a string" do
+      let(:body) { {a: 'body'} }
+      it "returns the object as a json string" do
+        expect(subject.body).to eq body.to_json
+      end
+    end
+  end
+
+  describe "headers" do
+    context "when headers are expected" do
+      let(:headers) { {"Content-Type" => "text/plain", "Accept" => "application/json"} }
+      let(:expected_headers) { {"CONTENT_TYPE" => "text/plain", "HTTP_ACCEPT" => "application/json"} }
+      it "transforms the headers into Rack format" do
+        expect(subject.headers).to eq( expected_headers )
+      end
+    end
+    context "when headers are not specified" do
+      let(:headers) { Pact::NullExpectation.new }
+      it "returns an empty hash" do
+        expect(subject.headers).to eq({})
+      end
+    end
+  end
+end

data/spec/lib/pact/provider/test_methods_spec.rb

@@ -16,35 +16,5 @@ module Pact::Provider
         expect{ subject.send(:get_provider_state, 'some state', 'consumer') }.to raise_error /Could not find.*some state.*consumer.*/
       end
     end
-
-    describe 'request path' do
-
-      let(:request) { OpenStruct.new(:path => 'path', :query => query)}
-
-      before do
-        @path = subject.send(:request_path, request)
-      end
-
-      describe 'query' do
-
-        context 'string query' do
-
-          let(:query) { 'query' }
-
-          it 'gets appended to the path' do
-            expect(@path).to eq('path?query')
-          end
-        end
-
-        context 'Term query' do
-
-          let(:query) { Pact::Term.new(generate: 'query', matcher: /q/) }
-
-          it 'appends the Term\'s generate to the path' do
-            expect(@path).to eq('path?query')
-          end
-        end
-      end
-    end
   end
 end

data/spec/lib/pact/verification_task_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'pact/verification_task'
+require 'pact/tasks/verification_task'
 
 module Pact
 	describe VerificationTask do

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+require 'rspec'
+require 'rspec/fire'
 require 'fakefs/spec_helpers'
 require 'rspec'
 require 'pact'
@@ -8,4 +10,5 @@ WebMock.disable_net_connect!(allow_localhost: true)
 
 RSpec.configure do | config |
   config.include(FakeFS::SpecHelpers, :fakefs => true)
+  config.include(RSpec::Fire)
 end

data/spec/support/factories.rb

@@ -71,8 +71,12 @@ end
 
 class RequestFactory
   extend Pact::HashUtils
-  DEFAULTS = {:path => '/path', :method => 'get'}.freeze
+  DEFAULTS = {:path => '/path', :method => 'get', :query => 'query', :headers => {}}.freeze
   def self.create_hash overrides = {}
    deep_merge(DEFAULTS, overrides)
   end
+
+  def self.create_actual
+    Pact::Consumer::Request::Actual.from_hash(create_hash)
+  end
 end

data/spec/support/pact_helper.rb

@@ -8,12 +8,18 @@ module Pact
 			def call env
 				if env['PATH_INFO'] == '/weather'
 					[200, {'Content-Type' => 'application/json'}, [{message: WEATHER[:current_state]}.to_json]]
+				elsif env['PATH_INFO'] == '/sometext'
+					[200, {'Content-Type' => 'text/plain'}, ['some text']]
 				else
 					raise "unexpected path #{env['PATH_INFO']}!!!"
 				end
 			end
 		end
 
+		Pact.configure do | config |
+			config.logger.level = Logger::DEBUG
+		end
+
 		Pact.service_provider "Some Provider" do
 			app { TestApp.new }