pact 0.1.28 → 1.3.3

data/spec/lib/pact/configuration_spec.rb

@@ -19,17 +19,279 @@ describe Pact do
         expect(Pact.configuration.send(key)).to eql(value)
       end
     end
+
   end
 
-  describe "configuration" do
-    it "should have a default pact_dir" do
-      expect(Pact.configuration.pact_dir).to eql File.expand_path('./spec/pacts')
+  describe Pact::Configuration do
+    let(:configuration) { Pact::Configuration.new }
+
+    describe "log_dir" do
+      it "sets the location of the logs" do
+        expect(Logger).to receive(:new).with("./tmp/logs/pact.log").and_call_original
+        Pact.configure do | config |
+          config.log_dir = "./tmp/logs"
+        end
+        Pact.configuration.logger
+      end
     end
-    it "should have a default log_dir" do
-      expect(Pact.configuration.log_dir).to eql File.expand_path('./log')
+
+    describe "logger" do
+      it "sets the location of the logs to log_dir by default" do
+        expect(Logger).to receive(:new).with(File.expand_path("./log/pact.log")).and_call_original
+        Pact.configuration.logger
+      end
+      it "defaults to DEBUG" do
+        expect(Pact.configuration.logger.level).to eq Logger::DEBUG
+      end
     end
-    it "should have a default logger configured" do
-      expect(Pact.configuration.logger).to be_instance_of Logger
+
+    describe "doc_dir" do
+      it "defaults to ./doc/pacts" do
+        expect(Pact.configuration.doc_dir).to eq File.expand_path("./doc/pacts")
+      end
+
+      it "can be changed" do
+        Pact.configuration.doc_dir = "newdir"
+        expect(Pact.configuration.doc_dir).to eq "newdir"
+      end
+    end
+
+    describe "doc_generator" do
+
+      context "with a symbol" do
+        it "allows configuration of a doc_generator" do
+          Pact.configuration.doc_generator = :markdown
+          expect(Pact.configuration.doc_generators).to eq [Pact::Doc::Markdown::Generator]
+        end
+      end
+
+      context "with anything that responds to 'call'" do
+
+        it "allows configuration of a doc_generator" do
+          Pact.configuration.doc_generator = lambda { | pact_dir, doc_dir | "doc" }
+          expect(Pact.configuration.doc_generators.size).to be 1
+          expect(Pact.configuration.doc_generators.first.call('doc','pacts')).to eq ("doc")
+        end
+
+      end
+
+      context "with something that does not respond to call and doesn't have a matching doc_generator" do
+        it "raises an error" do
+          expect { Pact.configuration.doc_generator = Object.new }.to raise_error "Pact.configuration.doc_generator needs to respond to call, or be in the preconfigured list: [:markdown]"
+        end
+      end
+
+    end
+
+    describe "#diff_formatter_for_content_type" do
+
+      let(:subject) { Pact::Configuration.new }
+
+      it "returns the Pact::Matchers::UnixDiffFormatter by default" do
+        expect(subject.diff_formatter_for_content_type 'anything').to eq(Pact::Matchers::UnixDiffFormatter)
+      end
+
+      Pact::Configuration::DIFF_FORMATTERS.each_pair do | key, diff_formatter |
+
+        context "when set to :#{key}" do
+
+          before do
+            subject.diff_formatter = key
+          end
+
+          it "sets the diff_formatter to #{diff_formatter}" do
+            expect(subject.diff_formatter_for_content_type nil).to be diff_formatter
+          end
+        end
+
+      end
+
+      context "when set to an object that responds to call" do
+
+        let(:diff_formatter) { lambda{ | diff| } }
+
+        before do
+          subject.diff_formatter = diff_formatter
+        end
+
+        it "sets the diff_formatter to the object" do
+          expect(subject.diff_formatter_for_content_type nil).to be diff_formatter
+        end
+      end
+
+      context "when set to an object that does not respond to call and isn't a known default option" do
+        it "raises an error" do
+          expect { subject.diff_formatter = Object.new }.to raise_error "Pact diff_formatter needs to respond to call, or be in the preconfigured list: [:embedded, :unix, :list]"
+          expect { subject.diff_formatter = Object.new }.to raise_error "Pact diff_formatter needs to respond to call, or be in the preconfigured list: [:embedded, :unix, :list]"
+        end
+      end
+
+    end
+
+    describe "diff_formatter_for_content_type" do
+      let(:diff_formatter) { lambda { |expected, actual| }}
+      context "with the default configuration" do
+        context "when the content type is nil" do
+          it "returns the UnixDiffFormatter" do
+            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
+          end
+        end
+        context "when the content type is application/json" do
+          it "returns the UnixDiffFormatter" do
+            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
+          end
+        end
+        context "when the content type is text/plain" do
+          it "returns the UnixDiffFormatter" do
+            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq Pact::Matchers::UnixDiffFormatter
+          end
+        end
+      end
+      context "with a custom diff_formatter registered for nil content type" do
+        context "when the content_type is nil" do
+          it "returns the custom diff_formatter" do
+            Pact.configuration.register_diff_formatter nil, diff_formatter
+            expect(Pact.configuration.diff_formatter_for_content_type nil).to eq diff_formatter
+          end
+        end
+      end
+      context "with a custom diff_formatter registered for json content type" do
+        context "when the content_type is application/json" do
+          it "returns the custom diff_formatter" do
+            Pact.configuration.register_diff_formatter /json/, diff_formatter
+            expect(Pact.configuration.diff_formatter_for_content_type 'application/json').to eq diff_formatter
+          end
+        end
+      end
+    end
+
+    describe "register_body_differ" do
+
+      let(:differ) { lambda{ |expected, actual| } }
+
+      context "with a string for a content type" do
+        it "configures the differ for the given content type" do
+          Pact.configure do | config |
+            config.register_body_differ 'application/xml', differ
+          end
+
+          expect(Pact.configuration.body_differ_for_content_type 'application/xml').to be differ
+        end
+      end
+
+      context "with a regexp for a content type" do
+        it "returns a matching differ" do
+          Pact.configuration.register_body_differ /application\/.*xml/, differ
+          expect(Pact.configuration.body_differ_for_content_type 'application/hal+xml').to be differ
+        end
+      end
+
+      context "when a non string or regexp is used to register a differ" do
+        it "raises an error" do
+          expect { Pact.configuration.register_body_differ 1, differ }.to raise_error /Invalid/
+        end
+      end
+
+      context "when something that does not respond to call is sumbitted as a differ" do
+        it "raises an error" do
+          expect { Pact.configuration.register_body_differ 'thing', Object.new }.to raise_error /responds to call/
+        end
+      end
+
+      context "when a nil content type is registered for responses without a content type header" do
+        it "returns that differ if the differ for a nil content type is requested" do
+          Pact.configuration.register_body_differ nil, differ
+          expect(Pact.configuration.body_differ_for_content_type(nil)).to be differ
+        end
+      end
+
+    end
+
+    describe "body_differ_for_content_type" do
+
+      let(:differ) { lambda { |expected, actual| }}
+
+      context "when 2 potentially matching content types have a differ registered" do
+        let(:differ_1) { lambda{ |expected, actual| } }
+        let(:differ_2) { lambda{ |expected, actual| } }
+
+        it "returns the differ that was configured first" do
+          Pact.configuration.register_body_differ /application\/.*xml/, differ_2
+          Pact.configuration.register_body_differ /application\/hal\+xml/, differ_1
+          expect(Pact.configuration.body_differ_for_content_type 'application/hal+xml').to be differ_2
+        end
+      end
+
+      context "when a nil content type is given" do
+        it "returns the text differ" do
+          expect(Pact.configuration.body_differ_for_content_type nil).to be Pact::TextDiffer
+        end
+      end
+
+      context "when no matching content type is found" do
+        it "returns the text differ" do
+          expect(Pact.configuration.body_differ_for_content_type 'blah').to be Pact::TextDiffer
+        end
+      end
+
+      context "when the nil content type has a custom differ configured" do
+        it "returns the custom differ" do
+          Pact.configuration.register_body_differ nil, differ
+          expect(Pact.configuration.body_differ_for_content_type(nil)).to be differ
+        end
+      end
+
+      context "when a custom differ is registered for a content type that has a default differ" do
+        it "returns the custom differ" do
+          Pact.configuration.register_body_differ /application\/json/, differ
+          expect(Pact.configuration.body_differ_for_content_type 'application/json').to be differ
+        end
+      end
+    end
+
+    describe "pactfile_write_mode" do
+      context "when @pactfile_write_mode is :overwrite" do
+        it 'returns :overwrite' do
+          configuration.pactfile_write_mode = :overwrite
+          expect(configuration.pactfile_write_mode).to eq :overwrite
+        end
+      end
+      context "when @pactfile_write_mode is :update" do
+        it 'returns :overwrite' do
+          configuration.pactfile_write_mode = :update
+          expect(configuration.pactfile_write_mode).to eq :update
+        end
+      end
+      context "when @pactfile_write_mode is :smart" do
+        before do
+          configuration.pactfile_write_mode = :smart
+          expect(configuration).to receive(:is_rake_running?).and_return(is_rake_running)
+        end
+        context "when rake is running" do
+          let(:is_rake_running) { true }
+          it "returns :overwrite" do
+            expect(configuration.pactfile_write_mode).to eq :overwrite
+          end
+        end
+        context "when rake is not running" do
+          let(:is_rake_running) { false }
+          it "returns :update" do
+            expect(configuration.pactfile_write_mode).to eq :update
+          end
+        end
+      end
     end
   end
+    describe "default_configuration" do
+      it "should have a default pact_dir" do
+        expect(Pact.configuration.pact_dir).to eql File.expand_path('./spec/pacts')
+      end
+      it "should have a default log_dir" do
+        expect(Pact.configuration.log_dir).to eql File.expand_path('./log')
+      end
+      it "should have a default logger configured" do
+        expect(Pact.configuration.logger).to be_instance_of Logger
+      end
+    end
+
 end

data/spec/lib/pact/consumer/app_manager_spec.rb

@@ -8,20 +8,20 @@ module Pact::Consumer
 
     describe "start_service_for" do
       before do
-        AppRegistration.any_instance.stub(:spawn) # Don't want process actually spawning during the tests
+        allow_any_instance_of(AppRegistration).to receive(:spawn) # Don't want process actually spawning during the tests
       end
       let(:name) { 'some_service'}
       context "for http://localhost" do
         let(:url) { 'http://localhost:1234'}
         it "starts a mock service at the given port on localhost" do
-          AppRegistration.any_instance.should_receive(:spawn)
+          expect_any_instance_of(AppRegistration).to receive(:spawn)
           AppManager.instance.register_mock_service_for name, url
           AppManager.instance.spawn_all
         end
 
         it "registers the mock service as running on the given port" do
           AppManager.instance.register_mock_service_for name, url
-          AppManager.instance.app_registered_on?(1234).should be_true
+          expect(AppManager.instance.app_registered_on?(1234)).to eq true
         end
       end
       context "for https://" do

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'pact/consumer/configuration'
+
+module Pact::Consumer::Configuration
+
+   describe MockService do
+
+      let(:world) { Pact::Consumer::World.new }
+      before do
+         Pact.clear_configuration
+         allow(Pact::Consumer::AppManager.instance).to receive(:register_mock_service_for)
+         allow(Pact).to receive(:consumer_world).and_return(world)
+      end
+
+      describe "configure_consumer_contract_builder" do
+         let(:consumer_name) {'consumer'}
+         subject {
+            MockService.build :mock_service, consumer_name, provider_name do
+               port 1234
+               standalone true
+               verify true
+            end
+         }
+
+         let(:provider_name) { 'Mock Provider' }
+         let(:consumer_contract_builder) { instance_double('Pact::Consumer::ConsumerContractBuilder') }
+         let(:url) { "http://localhost:1234" }
+
+         it "adds a verification to the Pact configuration" do
+            allow(Pact::Consumer::ConsumerContractBuilder).to receive(:new).and_return(consumer_contract_builder)
+            subject.finalize
+            expect(consumer_contract_builder).to receive(:verify)
+            Pact.configuration.provider_verifications.first.call
+         end
+
+         context "when standalone" do
+            it "does not register the app with the AppManager" do
+               expect(Pact::Consumer::AppManager.instance).to_not receive(:register_mock_service_for)
+               subject.finalize
+            end
+         end
+         context "when not standalone" do
+            subject {
+               MockService.build :mock_service, consumer_name, provider_name do
+                  port 1234
+                  standalone false
+                  verify true
+               end
+            }
+            it "registers the app with the AppManager" do
+               expect(Pact::Consumer::AppManager.instance).to receive(:register_mock_service_for).with(provider_name, url)
+               subject.finalize
+            end
+         end
+      end
+   end
+end

data/spec/lib/pact/consumer/consumer_contract_builder_spec.rb

@@ -3,85 +3,67 @@ require 'fileutils'
 require 'pathname'
 
 module Pact
-	module Consumer
-		describe ConsumerContractBuilder do
+  module Consumer
+    describe ConsumerContractBuilder do
 
-		   describe "initialize" do
-			   before do
-			      Pact.clear_configuration
-			      Pact.configuration.stub(:pact_dir).and_return(File.expand_path(tmp_pact_dir))
-			      FileUtils.rm_rf tmp_pact_dir
-			      FileUtils.mkdir_p tmp_pact_dir
-			      FileUtils.cp './spec/support/a_consumer-a_producer.json', "#{tmp_pact_dir}/a_consumer-a_producer.json"
-			   end
+      let(:consumer_name) { 'a consumer' }
+      let(:provider_name) { 'a provider' }
 
-			   let(:tmp_pact_dir) {"./tmp/pacts"}
+      describe "handle_interaction_fully_defined" do
 
-			   let(:consumer_name) { 'a consumer' }
-			   let(:producer_name) { 'a producer' }
-			   let(:consumer_contract_builder) { 
-			      Pact::Consumer::ConsumerContractBuilder.new(
-			         :pactfile_write_mode => pactfile_write_mode,
-			         :consumer_name => consumer_name,
-			         :producer_name => producer_name,
-			         :port => 1234)}
+        subject {
+          Pact::Consumer::ConsumerContractBuilder.new(:consumer_name => 'blah', :provider_name => 'blah', :port => 2222)
+        }
 
-			   context "when overwriting pact" do
-			      let(:pactfile_write_mode) {:overwrite}
-			      it "it overwrites the existing pact file" do
-			         expect(consumer_contract_builder.consumer_contract.interactions).to eq []
-			      end
-			   end
+        let(:interaction_hash) {
+          {
+            description: 'Test request',
+            request: {
+              method: 'post',
+              path: '/foo',
+              body: Term.new(generate: 'waffle', matcher: /ffl/),
+              headers: { 'Content-Type' => 'application/json' },
+              query: "",
+            },
+            response: {
+              baz: 'qux',
+              wiffle: 'wiffle'
+            }
+          }
+        }
 
-			   context "when updating pact" do
-			      let(:pactfile_write_mode) {:update}
-			      it "updates the existing pact file" do
-			         expect(consumer_contract_builder.consumer_contract.interactions.size).to eq 2
-			      end
-			   end		   	
-		   end			
+        let(:interaction_json) { {} }
 
-			describe "handle_interaction_fully_defined" do
+        let(:interaction) { Pact::Interaction.from_hash(JSON.load(interaction_hash.to_json)) }
 
-				subject { 
-					Pact::Consumer::ConsumerContractBuilder.new({:consumer_name => 'blah', :producer_name => 'blah', :port => 2222})
-				}
+        before do
+          stub_request(:post, 'localhost:2222/interactions')
+        end
 
-				let(:interaction_hash) {
-					{
-		            description: 'Test request',
-		            request: {
-		              method: 'post',
-		              path: '/foo',
-		              body: Term.new(generate: 'waffle', matcher: /ffl/),
-		              headers: { 'Content-Type' => 'application/json' },
-		              query: "",
-		            },
-		            response: {
-		              baz: 'qux',
-		              wiffle: 'wiffle'
-		            }
-	          	}
-				}
+        it "posts the interaction with generated response to the mock service" do
+          subject.handle_interaction_fully_defined interaction
+          expect(WebMock).to have_requested(:post, 'localhost:2222/interactions').with(body: interaction_json)
+        end
 
-				let(:interaction_json) { JSON.dump(interaction_hash) }
+        it "resets the interaction_builder to nil" do
+          expect(subject).to receive(:interaction_builder=).with(nil)
+          subject.handle_interaction_fully_defined interaction
+        end
+      end
 
-				let(:interaction) { Pact::Consumer::Interaction.from_hash(JSON.parse(interaction_json)) }
+      describe "#mock_service_base_url" do
 
-				before do
-					stub_request(:post, 'localhost:2222/interactions')
-				end
+      	subject {
+      		ConsumerContractBuilder.new(
+      			:pactfile_write_mode => :overwrite,
+            :consumer_name => consumer_name,
+            :provider_name => provider_name,
+        		:port => 1234) }
 
-	        	it "posts the interaction with generated response to the mock service" do
-	          	subject.handle_interaction_fully_defined interaction
-	          	WebMock.should have_requested(:post, 'localhost:2222/interactions').with(body: interaction_json)
-	        	end
-
-	        	it "updates the Producer's Pactfile" do
-	        		subject.consumer_contract.should_receive(:update_pactfile)
-	        		subject.handle_interaction_fully_defined interaction
-	        	end
-			end
-		end
-	end
-end
+      	it "returns the mock service base URL" do
+      		expect(subject.mock_service_base_url).to eq("http://localhost:1234")
+      	end
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer/interaction_builder_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'pact/consumer/interaction_builder'
+
+module Pact
+  module Consumer
+    describe InteractionBuilder do
+
+      subject { InteractionBuilder.new }
+      let(:interaction) { double('Interaction').as_null_object}
+
+      before do
+        expect(Interaction).to receive(:new).and_return(interaction)
+      end
+
+      describe "given" do
+        context "with a string provider state" do
+          it "sets the provider_state on the interaction" do
+            expect(interaction).to receive(:provider_state=).with('blah')
+            subject.given('blah')
+          end
+        end
+
+        context "with a symbol provider state" do
+          it "sets the provider_state on the interaction as a string" do
+            expect(interaction).to receive(:provider_state=).with('some_symbol')
+            subject.given(:some_symbol)
+          end
+        end
+
+        it "returns itself" do
+          expect(subject.given(nil)).to be(subject)
+        end
+      end
+
+      describe "upon_receiving" do
+        it "sets the description on the interaction" do
+          expect(interaction).to receive(:description=).with('blah')
+          subject.upon_receiving('blah')
+        end
+
+        it "returns itself" do
+          expect(subject.given(nil)).to be(subject)
+        end
+      end
+
+      describe "with" do
+
+        let(:request) { {a: 'request'} }
+        let(:expected_request) { {an: 'expected_request'} }
+
+        it "sets the request on the interaction as a instance of Request::Expected" do
+          expect(Pact::Request::Expected).to receive(:from_hash).with(request).and_return(expected_request)
+          expect(interaction).to receive(:request=).with(expected_request)
+          subject.with(request)
+        end
+
+        it "returns itself" do
+          expect(subject.given(nil)).to be(subject)
+        end
+      end 
+
+      describe "will_respond_with" do
+        let(:response) { {a: 'response'} }
+
+        let(:provider) do
+          double(callback: nil)
+        end
+
+        before do
+          subject.on_interaction_fully_defined do | interaction |
+            provider.callback interaction
+          end
+        end
+
+        it "sets the response on the interaction" do
+          expect(interaction).to receive(:response=).with(response)
+          subject.will_respond_with(response)
+        end
+
+        it "returns itself" do
+          expect(subject.given(nil)).to be(subject)
+        end
+
+        it "invokes the 'on_interaction_fully_defined' callback" do
+          expect(provider).to receive(:callback).with(interaction)
+          subject.will_respond_with response
+        end          
+      end
+    end
+  end
+end

data/spec/lib/pact/consumer/interactions_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'pact/consumer/interactions_filter'
+
+module Pact::Consumer
+
+   describe 'Interactions' do
+      let(:interaction) { InteractionFactory.create }
+      let(:indentical_interaction) { InteractionFactory.create }
+      let(:interaction_with_diff_request) { InteractionFactory.create :request => {:path => '/different'} }
+      let(:interaction_with_diff_description) { InteractionFactory.create :description => 'blah' }
+      let(:interaction_with_diff_provider_state) { InteractionFactory.create :provider_state => 'blah' }
+      let(:interactions) { [interaction] }
+
+      shared_examples_for 'interactions' do
+
+         subject { described_class.new(interactions) }
+
+         describe "<<" do
+            context "when an interaction with the same provider state and description is not already included" do
+               it "adds the interaction" do
+                  subject << interaction_with_diff_description
+                  expect(interactions).to eq [interaction, interaction_with_diff_description]
+               end
+            end
+         end
+      end
+
+      describe UpdatableInteractionsFilter do
+         context "which, by default, is used when running rspec" do
+            include_examples 'interactions'
+            describe "<<" do
+               context "when an interaction with the same provider state and description is already included" do
+                  it "overwrites the existing interaction, as the user has most likely just updated a test, and is rerunning the one spec" do
+                     subject << interaction_with_diff_request
+                     expect(interactions).to eq [interaction_with_diff_request]
+                  end
+               end 
+            end
+         end
+      end
+
+      describe DistinctInteractionsFilter do
+         context "which, by default, this is used when running rake" do
+            include_examples 'interactions'
+            describe "<<" do
+               context "when an interaction with the same provider state and description is already included" do
+                  context "when the interactions are not equal" do
+                     it "raises an error as the user has most likely copy/pasted an existing interaction and forgotten to update the description or provider state" do
+                        expect{ subject << interaction_with_diff_request }.to raise_error 'Interaction with same description (a description) and provider state (a thing exists) already exists'
+                     end
+                  end
+                  context "when the interactions are equal" do
+                     it "does not add the interaction as it already exists" do
+                        subject << indentical_interaction
+                        expect(interactions).to eq [interaction]
+                     end
+                  end
+               end          
+            end
+         end
+      end   
+   end
+
+end