pact 0.1.37 → 1.0.0

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

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'pact/consumer/dsl'
-require 'pact/consumer/configuration_dsl'
 
 module Pact::Consumer::DSL
 
@@ -18,7 +17,7 @@ module Pact::Consumer::DSL
             end
          }
 
-         let(:producer_name) { 'Mock Producer'}
+         let(:provider_name) { 'Mock Provider'}
          let(:consumer_contract_builder) { double('Pact::Consumer::ConsumerContractBuilder').as_null_object}
          let(:url) { "http://localhost:1234"}
 
@@ -26,7 +25,7 @@ module Pact::Consumer::DSL
             Pact::Consumer::ConsumerContractBuilder.stub(:new).and_return(consumer_contract_builder)
             subject.configure_consumer_contract_builder({})
             consumer_contract_builder.should_receive(:verify)
-            Pact.configuration.producer_verifications.first.call
+            Pact.configuration.provider_verifications.first.call
          end
 
          context "when standalone" do
@@ -44,8 +43,8 @@ module Pact::Consumer::DSL
                end
             }            
             it "registers the app with the AppManager" do
-               Pact::Consumer::AppManager.instance.should_receive(:register_mock_service_for).with(producer_name, url)
-               subject.configure_consumer_contract_builder({:producer_name => producer_name })
+               Pact::Consumer::AppManager.instance.should_receive(:register_mock_service_for).with(provider_name, url)
+               subject.configure_consumer_contract_builder({:provider_name => provider_name })
             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
+        Interaction.should_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
+            interaction.should_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
+            interaction.should_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
+          interaction.should_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
+          Request::Expected.should_receive(:from_hash).with(request).and_return(expected_request)
+          interaction.should_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
+          interaction.should_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
+          provider.should_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

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

@@ -4,15 +4,11 @@ require 'pact/consumer/mock_service'
 module Pact::Consumer
 
   describe InteractionList do
-    before do
-      InteractionList.instance.clear
-    end
-
     shared_context "unexpected requests and missed interactions" do
       let(:expected_call) { {request: 'blah'} }
       let(:unexpected_call) { Pact::Request::Actual.from_hash(path: '/path', method: 'get') }
       subject {
-        interactionList = InteractionList.instance
+        interactionList = InteractionList.new
         interactionList.add expected_call
         interactionList.register_unexpected unexpected_call
         interactionList
@@ -23,7 +19,7 @@ module Pact::Consumer
       let(:expected_call) { {request: 'blah'} }
       let(:unexpected_call) { Pact::Request::Actual.from_hash(path: '/path', method: 'get') }
       subject {
-        interactionList = InteractionList.instance
+        interactionList = InteractionList.new
         interactionList.add expected_call
         interactionList.register_matched expected_call
         interactionList

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Pact::Consumer
+module Pact
    describe ServiceConsumer do
       describe "as_json" do
          it "returns a hash representation of the object" do

data/spec/lib/pact/{consumer_contract_spec.rb → consumer_contract/consumer_contract_spec.rb}

@@ -27,9 +27,9 @@ module Pact
       end
 
       let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
-      let(:service_producer) { double('ServiceProducer', :as_json => {:a => 'producer'}) }
-      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :producer => service_producer }) }
-      let(:expected_as_json) { {:producer=>{:a=>"producer"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pact_gem=>{:version=>"1.0"}}} }
+      let(:service_provider) { double('ServiceProvider', :as_json => {:a => 'provider'}) }
+      let(:pact) { ConsumerContract.new({:interactions => [MockInteraction.new], :consumer => service_consumer, :provider => service_provider }) }
+      let(:expected_as_json) { {:provider=>{:a=>"provider"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pact_gem=>{:version=>"1.0"}}} }
 
       it "should return a hash representation of the Pact" do
         pact.as_json.should eq expected_as_json
@@ -56,67 +56,111 @@ module Pact
         end
 
         it "should have a consumer" do
-          loaded_pact.consumer.should be_instance_of Pact::Consumer::ServiceConsumer
+          loaded_pact.consumer.should be_instance_of Pact::ServiceConsumer
         end
 
-        it "should have a producer" do
-          loaded_pact.producer.should be_instance_of Pact::Consumer::ServiceProducer
+        it "should have a provider" do
+          loaded_pact.provider.should be_instance_of Pact::ServiceProvider
+        end
+      end
+
+      context "with old 'producer' key" do
+        let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
+        it "should create a Pact" do
+          loaded_pact.should be_instance_of ConsumerContract
+        end
+
+        it "should have interactions" do
+          loaded_pact.interactions.should be_instance_of Array
+        end
+
+        it "should have a consumer" do
+          loaded_pact.consumer.should be_instance_of Pact::ServiceConsumer
+        end
+
+        it "should have a provider" do
+          loaded_pact.provider.should be_instance_of Pact::ServiceProvider
+          loaded_pact.provider.name.should eq "an old producer"
+        end
+
+        it "should have a provider_state" do
+          loaded_pact.interactions.first.provider_state.should eq 'state one'
         end
       end
     end
 
     describe "find_interactions" do
-      let(:consumer) { double('ServiceConsumer', :name => 'Consumer')}
-      let(:producer) { double('ServiceProducer', :name => 'Producer')}
-      let(:interaction1) { Pact::Consumer::Interaction.new(:description => 'a request for food') }
-      let(:interaction2) { Pact::Consumer::Interaction.new(:description => 'a request for drink') }
-      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :producer => producer) }
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction) { double('Pact::Interaction') }
+      subject { ConsumerContract.new(:interactions => [interaction], :consumer => consumer, :provider => provider) }
+      let(:criteria) { {:description => /blah/} }
+      before do
+        interaction.should_receive(:matches_criteria?).with(criteria).and_return(matches)
+      end
       context "by description" do
         context "when no interactions are found" do
+          let(:matches) { false }
           it "returns an empty array" do
-            expect(subject.find_interactions(:description => /blah/)).to eql []
+            expect(subject.find_interactions(criteria)).to eql []
           end
         end
         context "when interactions are found" do
+          let(:matches) { true }
           it "returns an array of the matching interactions" do
-            expect(subject.find_interactions(:description => /request/)).to eql [interaction1, interaction2]
+            expect(subject.find_interactions(criteria)).to eql [interaction]
           end
         end
       end
     end
+
     describe "find_interaction" do
-      let(:consumer) { double('ServiceConsumer', :name => 'Consumer')}
-      let(:producer) { double('ServiceProducer', :name => 'Producer')}
-      # Should be stubbing these
-      let(:interaction1) { Pact::Consumer::Interaction.new(:description => 'a request for food') }
-      let(:interaction2) { Pact::Consumer::Interaction.new(:description => 'a request for drink') }
-      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :producer => producer) }
+      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
+      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
+      let(:interaction1) { double('Pact::Interaction') }
+      let(:interaction2) { double('Pact::Interaction') }
+      let(:criteria) { {:description => /blah/} }
+
+      before do
+        interaction1.should_receive(:matches_criteria?).with(criteria).and_return(matches1)
+        interaction2.should_receive(:matches_criteria?).with(criteria).and_return(matches2)
+      end
+
+      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
       context "by description" do
         context "when a match is found" do
+          let(:matches1) { true }
+          let(:matches2) { false }
+
           it "returns the interaction" do
-            expect(subject.find_interaction :description => /request.*food/).to eql interaction1
+            expect(subject.find_interaction criteria).to eql interaction1
           end
         end
         context "when more than one match is found" do
+          let(:matches1) { true }
+          let(:matches2) { true }
           it "raises an error" do
-            expect{ subject.find_interaction(:description => /request/) }.to raise_error "Found more than 1 interaction matching {:description=>/request/} in pact file between Consumer and Producer."
+            expect{ subject.find_interaction(criteria) }.to raise_error "Found more than 1 interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
           end
         end
         context "when a match is not found" do
+          let(:matches1) { false }
+          let(:matches2) { false }
           it "raises an error" do
-            expect{ subject.find_interaction(:description => /blah/) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Producer."
+            expect{ subject.find_interaction(criteria) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
           end
         end
       end
     end
+
     describe "update_pactfile" do
       let(:pacts_dir) { Pathname.new("./tmp/pactfiles") }
       let(:expected_pact_path) { pacts_dir + "test_consumer-test_service.json" }
       let(:expected_pact_string) { 'the_json' }
-      let(:consumer) { Pact::Consumer::ServiceConsumer.new(:name => 'test_consumer')}
-      let(:producer) { Pact::Consumer::ServiceProducer.new(:name => 'test_service')}
+      let(:consumer) { Pact::ServiceConsumer.new(:name => 'test_consumer')}
+      let(:provider) { Pact::ServiceProvider.new(:name => 'test_service')}
       let(:interactions) { [double("interaction", as_json: "something")]}
-      subject { ConsumerContract.new(:consumer => consumer, :producer => producer, :interactions => interactions) }
+      subject { ConsumerContract.new(:consumer => consumer, :provider => provider, :interactions => interactions) }
       before do
         Pact.configuration.stub(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
         FileUtils.rm_rf pacts_dir
@@ -125,13 +169,13 @@ module Pact
         subject.update_pactfile
       end
 
-      it "should write to a file specified by the consumer and producer name" do
+      it "should write to a file specified by the consumer and provider name" do
         File.exist?(expected_pact_path).should be_true
       end
 
       it "should write the interactions to the file" do
         File.read(expected_pact_path).should eql expected_pact_string
       end
-    end    
-  end 
+    end
+  end
 end

data/spec/lib/pact/{consumer → consumer_contract}/interaction_spec.rb

@@ -1,44 +1,42 @@
 require 'spec_helper'
+require 'pact/reification'
+require 'pact/consumer_contract/interaction'
 
 module Pact
   module Consumer
-    describe InteractionBuilder do
 
-      subject { 
-        interaction_builder = InteractionBuilder.new('Test request', nil).with(request) 
-        interaction_builder.on_interaction_fully_defined do | interaction |
-          producer.callback interaction
-        end
-        interaction_builder
-      }
-
-      let(:pact_path) { File.expand_path('../../../../pacts/mock', __FILE__) }
-
-      let(:request) do
-        {
-          method: 'post',
-          path: '/foo',
-          body: Term.new(generate: 'waffle', matcher: /ffl/),
-          headers: { 'Content-Type' => 'application/json' },
-          query: '',
-        }
-      end
-
-      let(:response) do
-        { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
-      end
+    describe Interaction do
 
-      let(:producer) do
-        double(callback: nil)
+      describe "==" do
+        subject { InteractionFactory.create }
+        context "when other is the same" do
+          let(:other) { InteractionFactory.create }
+          it "returns true" do
+            expect(subject == other).to be_true
+          end
+        end
+        context "when other is not the same" do
+          let(:other) { InteractionFactory.create(:request => {:path => '/a_different_path'}) }
+          it "returns false" do
+            expect(subject == other).to be_false
+          end
+        end
       end
 
-      describe "setting up responses" do
-
-        it "invokes the callback" do
-          producer.should_receive(:callback).with(subject.interaction)
-          subject.will_respond_with response
+      describe "matches_criteria?" do
+        subject { InteractionFactory.create(:description => 'a request for food') }
+        context "by description" do
+          context "when the interaction matches" do
+            it "returns true" do
+              expect(subject.matches_criteria?(:description => /request.*food/)).to be_true 
+            end
+          end
+          context "when the interaction does not match" do
+            it "returns false" do
+              expect(subject.matches_criteria?(:description => /blah/)).to be_false
+            end
+          end
         end
-
       end
 
       describe "as_json_for_mock_service" do
@@ -46,7 +44,7 @@ module Pact
         let(:request) { double(Pact::Request::Expected, :as_json_with_options => {:opts => 'blah'})}
         let(:response) { double('response') }
         let(:generated_response ) { double('generated_response', :to_json => 'generated_response') }
-        subject { Interaction.new(:description => 'description', :request => request, :response => response, :producer_state => 'some state')}
+        subject { Interaction.new(:description => 'description', :request => request, :response => response, :provider_state => 'some state')}
         let(:expected_hash) { {:response => generated_response, :request => as_json_with_options, :description => '' } }
 
         before do
@@ -62,8 +60,8 @@ module Pact
           expect(subject.as_json_for_mock_service[:request]).to eq as_json_with_options
         end
 
-        it "includes the producer state" do
-          expect(subject.as_json_for_mock_service[:producer_state]).to eq 'some state'
+        it "includes the provider state" do
+          expect(subject.as_json_for_mock_service[:provider_state]).to eq 'some state'
         end
 
         it "includes the description" do
@@ -71,19 +69,30 @@ module Pact
         end
 
         it "doesn't have any other keys" do
-          expect(subject.as_json_for_mock_service.keys).to eq [:response, :request, :description, :producer_state]
+          expect(subject.as_json_for_mock_service.keys).to eq [:response, :request, :description, :provider_state]
         end
       end
 
       describe "to JSON" do
+        let(:request) do
+          {
+            method: 'post',
+            path: '/foo',
+            body: Term.new(generate: 'waffle', matcher: /ffl/),
+            headers: { 'Content-Type' => 'application/json' },
+            query: '',
+          }
+        end
+
+        let(:response) do
+          { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
+        end        
 
         let(:parsed_result) do
-          JSON.load(JSON.dump(subject.interaction))
+          JSON.load(JSON.dump(subject))
         end
 
-        before do
-          subject.will_respond_with response
-        end
+        subject { Interaction.from_hash('response' => response, 'request' => request) }
 
         it "contains the request" do
           expect(parsed_result['request']).to eq({
@@ -112,30 +121,6 @@ module Pact
 
         end
 
-        context "with a producer_state" do
-          context "described with a string" do
-            subject { 
-              interaction_builder = InteractionBuilder.new('Test request', "there are no alligators").with(request) 
-              interaction_builder.on_interaction_fully_defined {}
-              interaction_builder
-            }
-
-            it "includes the state name as a string" do
-              expect(parsed_result['producer_state']).to eql("there are no alligators")
-            end
-          end
-          context "described with a symbol" do
-            subject { 
-              interaction_builder = InteractionBuilder.new('Test request', :there_are_no_alligators).with(request) 
-              interaction_builder.on_interaction_fully_defined {}
-              interaction_builder
-            }
-
-            it "includes the state name as a symbol" do
-              expect(parsed_result['producer_state']).to eql("there_are_no_alligators")
-            end
-          end
-        end
       end
     end
   end