pact 1.1.1 → 1.2.1.rc1

data/spec/lib/pact/consumer_contract/consumer_contract_writer_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'pact/consumer_contract/consumer_contract_writer'
+
+module Pact
+
+  describe ConsumerContractWriter do
+
+    let(:support_pact_file) { './spec/support/a_consumer-a_provider.json' }
+    let(:consumer_name) { 'a consumer' }
+    let(:provider_name) { 'a provider' }
+
+    before do
+      Pact.clear_configuration
+      allow(Pact.configuration).to receive(:pact_dir).and_return(File.expand_path(tmp_pact_dir))
+      FileUtils.rm_rf tmp_pact_dir
+      FileUtils.mkdir_p tmp_pact_dir
+      FileUtils.cp support_pact_file, "#{tmp_pact_dir}/a_consumer-a_provider.json"
+    end
+
+    let(:existing_interactions) { ConsumerContract.from_json(File.read(support_pact_file)).interactions }
+    let(:new_interactions) { [InteractionFactory.create] }
+    let(:tmp_pact_dir) {"./tmp/pacts"}
+    let(:logger) { double("logger").as_null_object }
+    let(:pactfile_write_mode) {:overwrite}
+    let(:consumer_contract_details) {
+      {
+          consumer: {name: consumer_name},
+          provider: {name: provider_name},
+          pactfile_write_mode: pactfile_write_mode,
+          interactions: new_interactions
+      }
+    }
+
+    let(:consumer_contract_writer) { ConsumerContractWriter.new(consumer_contract_details, logger) }
+
+    describe "consumer_contract" do
+
+      let(:subject) { consumer_contract_writer.consumer_contract }
+
+      context "when overwriting pact" do
+
+        it "it uses only the interactions from the current test run" do
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq new_interactions
+        end
+
+      end
+
+      context "when updating pact" do
+
+        let(:pactfile_write_mode) {:update}
+
+        it "merges the interactions from the current test run with the interactions from the existing file" do
+          allow_any_instance_of(ConsumerContractWriter).to receive(:info_and_puts)
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq  existing_interactions + new_interactions
+        end
+
+        let(:line0) { /\*/ }
+        let(:line1) { /Updating existing file/ }
+        let(:line2) { /Only interactions defined in this test run will be updated/ }
+        let(:line3) { /As interactions are identified by description and provider state/ }
+
+        it "logs a description message" do
+          expect($stdout).to receive(:puts).with(line0).twice
+          expect($stdout).to receive(:puts).with(line1)
+          expect($stdout).to receive(:puts).with(line2)
+          expect($stdout).to receive(:puts).with(line3)
+          expect(logger).to receive(:info).with(line0).twice
+          expect(logger).to receive(:info).with(line1)
+          expect(logger).to receive(:info).with(line2)
+          expect(logger).to receive(:info).with(line3)
+          consumer_contract_writer.consumer_contract
+        end
+      end
+
+      context "when an error occurs deserializing the existing pactfile" do
+
+        let(:pactfile_write_mode) {:update}
+        let(:error) { RuntimeError.new('some error')}
+        let(:line1) { /Could not load existing consumer contract from .* due to some error/ }
+        let(:line2) {'Creating a new file.'}
+
+        before do
+          allow(ConsumerContract).to receive(:from_json).and_raise(error)
+          allow($stderr).to receive(:puts)
+          allow(logger).to receive(:puts)
+        end
+
+        it "logs the error" do
+          expect($stderr).to receive(:puts).with(line1)
+          expect($stderr).to receive(:puts).with(line2)
+          expect(logger).to receive(:warn).with(line1)
+          expect(logger).to receive(:warn).with(line2)
+          consumer_contract_writer.consumer_contract
+        end
+
+        it "uses the new interactions" do
+          expect(consumer_contract_writer.consumer_contract.interactions).to eq new_interactions
+        end
+      end
+    end
+
+    describe "write" do
+      it "writes the pact file" do
+        expect_any_instance_of(ConsumerContract).to receive(:update_pactfile)
+        consumer_contract_writer.write
+      end
+    end
+
+  end
+
+end

data/spec/lib/pact/provider/configuration/pact_verification_spec.rb

@@ -20,7 +20,7 @@ module Pact
             end
 
             it "creates a Verification" do
-              Pact::Provider::PactVerification.should_receive(:new).with(consumer_name, url, ref)
+              expect(Pact::Provider::PactVerification).to receive(:new).with(consumer_name, url, ref)
               subject
             end
           end

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

@@ -29,7 +29,7 @@ module Pact::Provider
         context "the pact_helper is stored in #{dir}" do
           it "finds the pact_helper" do
             make_pactfile dir
-            expect(subject).to eq "#{Dir.pwd}#{dir}/pact_helper.rb"
+            expect(subject).to eq File.join(Dir.pwd, dir, 'pact_helper.rb')
           end
         end
       end
@@ -38,7 +38,7 @@ module Pact::Provider
         it "returns the one that matches the most explict search pattern" do
           make_pactfile '/spec/consumer'
           FileUtils.touch 'pact_helper.rb'
-          expect(subject).to eq "#{Dir.pwd}/spec/consumer/pact_helper.rb"
+          expect(subject).to eq File.join(Dir.pwd, '/spec/consumer/pact_helper.rb')
         end
       end
 

data/spec/lib/pact/provider/rspec/{formatter_spec.rb → formatter_rspec_2_spec.rb}

@@ -1,12 +1,22 @@
 require 'spec_helper'
-require 'pact/provider/rspec/formatter'
+require 'pact/provider/rspec/formatter_rspec_2'
 require './spec/support/factories'
 require './spec/support/spec_support'
 
 module Pact
   module Provider
     module RSpec
-      describe Formatter do
+      describe Formatter2 do
+
+        Pact::RSpec.with_rspec_3 do
+
+          # These methods don't exist in RSpec3
+          class Formatter2
+            def failure_color arg ; arg; end
+            def detail_color arg ; arg; end
+          end
+
+        end
 
         let(:interaction) { InteractionFactory.create 'provider_state' => 'a state', 'description' => 'a description'}
         let(:pactfile_uri) { 'pact_file_uri' }
@@ -18,14 +28,14 @@ module Pact
         let(:rerun_command) { "rake pact:verify:at[pact_file_uri] PACT_DESCRIPTION=\"a description\" PACT_PROVIDER_STATE=\"a state\" # an interaction" }
         let(:missing_provider_states) { 'missing_provider_states'}
 
-        subject { Formatter.new output }
+        subject { Formatter2.new output }
 
         let(:output_result) { Pact::SpecSupport.remove_ansicolor output.string }
 
         before do
           allow(PrintMissingProviderStates).to receive(:call)
           allow(subject).to receive(:failed_examples).and_return(failed_examples)
-          allow(Pact.world.provider_states).to receive(:missing_provider_states).and_return(missing_provider_states)
+          allow(Pact.provider_world.provider_states).to receive(:missing_provider_states).and_return(missing_provider_states)
           subject.dump_commands_to_rerun_failed_examples
         end
 

data/spec/lib/pact/provider/rspec/formatter_rspec_3_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'pact/provider/rspec/formatter_rspec_3'
+require './spec/support/factories'
+require './spec/support/spec_support'
+
+Pact::RSpec.with_rspec_3 do
+  module Pact
+    module Provider
+      module RSpec
+        describe Formatter do
+
+          let(:interaction) { InteractionFactory.create 'provider_state' => 'a state', 'description' => 'a description'}
+          let(:pactfile_uri) { 'pact_file_uri' }
+          let(:description) { 'an interaction' }
+          let(:metadata) { {pact_interaction: interaction, pactfile_uri: pactfile_uri, pact_interaction_example_description: description}}
+          let(:metadata_2) { metadata.merge(pact_interaction_example_description: 'another interaction')}
+          let(:example) { double("Example", metadata: metadata) }
+          let(:example_2) { double("Example", metadata: metadata_2) }
+          let(:failed_examples) { [example, example] }
+          let(:examples) { [example, example, example_2]}
+          let(:output) { StringIO.new }
+          let(:rerun_command) { "rake pact:verify:at[pact_file_uri] PACT_DESCRIPTION=\"a description\" PACT_PROVIDER_STATE=\"a state\" # an interaction" }
+          let(:missing_provider_states) { 'missing_provider_states'}
+          let(:summary) { double("summary", failure_count: 1, failed_examples: failed_examples, examples: examples)}
+
+          subject { Formatter.new output }
+
+          let(:output_result) { Pact::SpecSupport.remove_ansicolor output.string }
+
+          before do
+            allow(PrintMissingProviderStates).to receive(:call)
+            allow(subject).to receive(:failed_examples).and_return(failed_examples)
+            allow(Pact.provider_world.provider_states).to receive(:missing_provider_states).and_return(missing_provider_states)
+            subject.dump_summary summary
+          end
+
+          describe "#dump_summary" do
+            it "prints a list of rerun commands" do
+              expect(output_result).to include(rerun_command)
+            end
+
+            it "only prints unique commands" do
+              expect(output_result.scan(rerun_command).size).to eq 1
+            end
+
+            it "prints a message about the logs" do
+              expect(output_result).to include("For assistance debugging failures")
+            end
+
+            it "prints the number of interactions" do
+              expect(output_result).to include("2 interactions")
+            end
+
+            it "prints the number of failures" do
+              expect(output_result).to include("1 failure")
+            end
+
+            it "prints missing provider states" do
+              expect(PrintMissingProviderStates).to receive(:call).with(missing_provider_states, output)
+              subject.dump_summary summary
+            end
+          end
+
+        end
+
+      end
+
+    end
+  end
+end
+
+

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

@@ -1,7 +1,10 @@
 require 'pact/provider/rspec'
+require 'pact/provider/rspec/matchers'
 
 describe "the match_term matcher" do
 
+  include Pact::RSpec::Matchers
+
   it 'does not match a hash to an array' do
     expect({}).to_not match_term([])
   end

data/spec/lib/pact/provider/state/provider_state_manager_spec.rb

@@ -10,7 +10,7 @@ module Pact::Provider::State
 
     before do
       PROVIDER_STATE_MESSAGES.clear
-      Pact.clear_world
+      Pact.clear_provider_world
 
       Pact.set_up do
         PROVIDER_STATE_MESSAGES << :global_base_set_up

data/spec/lib/pact/provider/state/provider_state_proxy_spec.rb

@@ -16,13 +16,13 @@ module Pact
         subject { provider_state_proxy.get name, options }
 
         before do
-          ProviderStates.stub(:get).and_return(provider_state)
+          allow(ProviderStates).to receive(:get).and_return(provider_state)
         end
 
         context "when the provider state exists" do
 
           it "retrieves the provider state from ProviderState" do
-            ProviderStates.should_receive(:get).with(name, options).and_return(provider_state)
+            expect(ProviderStates).to receive(:get).with(name, options).and_return(provider_state)
             subject
           end
 
@@ -61,13 +61,13 @@ module Pact
       describe "get_base" do
 
         before do
-          ProviderStates.stub(:get_base).and_return(provider_state)
+          allow(ProviderStates).to receive(:get_base).and_return(provider_state)
         end
 
         subject { provider_state_proxy.get_base options }
 
         it "calls through to ProviderStates" do
-          ProviderStates.should_receive(:get_base).with(options)
+          expect(ProviderStates).to receive(:get_base).with(options)
           subject
         end
 

data/spec/lib/pact/provider/state/provider_state_spec.rb

@@ -33,26 +33,26 @@ module Pact
         describe 'set_up' do
           it 'should call the block passed to set_up' do
             subject.set_up
-            MESSAGES.should eq ['set_up']
+            expect(MESSAGES).to 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']
+            expect(MESSAGES).to eq ['tear_down']
           end
         end
 
         describe '.get' do
           context 'when the name is a matching symbol' do
             it 'will return the ProviderState' do
-              ProviderStates.get('no_alligators').should_not be_nil
+              expect(ProviderStates.get('no_alligators')).to_not be_nil
             end
           end
           context 'when the name is a matching string' do
             it 'will return the ProviderState' do
-              ProviderStates.get('some alligators').should_not be_nil
+              expect(ProviderStates.get('some alligators')).to_not be_nil
             end
           end
         end
@@ -121,11 +121,11 @@ module Pact
         describe '.get' do
           context 'for a consumer' do
             it 'has a namespaced name' do
-              ProviderStates.get('the weather is sunny', :for => 'a consumer').should_not be_nil
+              expect(ProviderStates.get('the weather is sunny', :for => 'a consumer')).to_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
-              ProviderStates.get('the weather is cloudy', :for => 'a consumer').should_not be_nil
+              expect(ProviderStates.get('the weather is cloudy', :for => 'a consumer')).to_not be_nil
             end
           end
 
@@ -135,7 +135,7 @@ module Pact
           context 'for a consumer' do
             it 'runs its own setup' do
               ProviderStates.get('the weather is sunny', :for => 'a consumer').set_up
-              NAMESPACED_MESSAGES.should eq ['sunny!']
+              expect(NAMESPACED_MESSAGES).to eq ['sunny!']
             end
           end
         end

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

@@ -1,21 +1,21 @@
 require 'spec_helper'
-require 'pact/provider/world'
+load 'pact/provider/world.rb'
 
 describe Pact do
-  describe ".world" do
+  describe ".provider_world" do
     it "returns a world" do
-      expect(Pact.world).to be_instance_of Pact::Provider::World
+      expect(Pact.provider_world).to be_instance_of Pact::Provider::World
     end
     it "returns the same world each time" do
-      expect(Pact.world).to be Pact.world
+      expect(Pact.provider_world).to be Pact.provider_world
     end
   end
 
-  describe ".clear_world" do
+  describe ".clear_provider_world" do
     it "clears the world" do
-      original_world = Pact.world
-      Pact.clear_world
-      expect(original_world).to_not be Pact.world
+      original_world = Pact.provider_world
+      Pact.clear_provider_world
+      expect(original_world).to_not be Pact.provider_world
     end
   end
 

data/spec/lib/pact/tasks/verification_task_spec.rb

@@ -30,12 +30,12 @@ module Pact
     describe '.initialize' do
       context 'with an explict pact_helper' do
         it 'creates the tasks' do
-          Rake::Task.tasks.should include_task @task_name
+          expect(Rake::Task.tasks).to include_task @task_name
         end
       end
       context 'with no explict pact_helper' do
         it 'creates the tasks' do
-          Rake::Task.tasks.should include_task @task_name_with_explict_pact_helper
+          expect(Rake::Task.tasks).to include_task @task_name_with_explict_pact_helper
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,11 +1,10 @@
 require 'rspec'
-require 'rspec/fire'
 require 'fakefs/spec_helpers'
 require 'rspec'
 require 'pact'
 require 'webmock/rspec'
-require_relative 'support/factories'
-require_relative 'support/spec_support'
+require 'support/factories'
+require 'support/spec_support'
 require 'pact/provider/rspec'
 
 WebMock.disable_net_connect!(allow_localhost: true)
@@ -14,7 +13,6 @@ require './spec/support/active_support_if_configured'
 
 RSpec.configure do | config |
   config.include(FakeFS::SpecHelpers, :fakefs => true)
-  config.include(RSpec::Fire)
 
   config.extend Pact::Provider::RSpec::ClassMethods
   config.include Pact::Provider::RSpec::InstanceMethods

data/spec/support/factories.rb

@@ -27,20 +27,20 @@ class InteractionFactory
 
   extend Pact::HashUtils
 
-  DEFAULTS = Hash[
-    'request' => {
-      'path' => '/path',
-      'method' => 'get',
-    },
-    'response' => {
-      'body' => {a: 'response body'}
-    },
-    'description' => 'a description',
-    'provider_state' => 'a thing exists'
-  ]
-
   def self.create hash = {}
-    Pact::Interaction.from_hash(stringify_keys(deep_merge(DEFAULTS, stringify_keys(hash))))
+    defaults = {
+        'description' => 'a description',
+        'provider_state' => 'a thing exists',
+        'request' => {
+            'path' => '/path',
+            'method' => 'get',
+        },
+        'response' => {
+            'status' => 200,
+            'body' => {a: 'response body'}
+        }
+    }
+    Pact::Interaction.from_hash(stringify_keys(deep_merge(defaults, stringify_keys(hash))))
   end
 end
 

data/spec/support/spec_support.rb

@@ -1,3 +1,5 @@
+require 'pact/rspec'
+
 module Pact
   module SpecSupport
 
@@ -6,5 +8,13 @@ module Pact
     def remove_ansicolor string
       string.gsub(/\e\[(\d+)m/, '')
     end
+
+    Pact::RSpec.with_rspec_2 do
+
+      def instance_double *args
+        double(*args)
+      end
+
+    end
   end
 end

data/spec/support/stubbing_using_allow.rb

@@ -24,10 +24,6 @@ end
 # Include the ExampleMethods module after the provider states are declared
 # to ensure the ordering doesn't matter
 
-Pact.configure do | config |
-  config.include RSpec::Mocks::ExampleMethods
-end
-
 Pact.service_provider 'Provider' do
   app { App }
 end

data/tasks/pact-test.rake

@@ -2,10 +2,6 @@ require 'pact/tasks/verification_task'
 require 'open3'
 
 Pact::VerificationTask.new(:stubbing) do | pact |
-	pact.uri './spec/support/stubbing.json', :pact_helper => './spec/support/stubbing'
-end
-
-Pact::VerificationTask.new(:stubbing_using_allow) do | pact |
 	pact.uri './spec/support/stubbing.json', :pact_helper => './spec/support/stubbing_using_allow.rb'
 end
 
@@ -45,7 +41,6 @@ namespace :pact do
 	desc "All the verification tests"
 	task "tests:all" do
 		Rake::Task['pact:verify:stubbing'].execute
-		Rake::Task['pact:verify:stubbing_using_allow'].execute
 		Rake::Task['spec:standalone:pass'].execute
 		Rake::Task['pact:verify'].execute
 		Rake::Task['pact:verify:test_app:pass'].execute
@@ -57,6 +52,14 @@ namespace :pact do
 		Rake::Task['pact:tests:all'].execute
 	end
 
+	desc "Ensure pact file is written"
+	task 'test:pactfile' do
+		pact_path = './spec/pacts/standalone_consumer-standalone_provider.json'
+		FileUtils.rm_rf pact_path
+		Rake::Task['spec:standalone:pass'].execute
+		fail "Did not find expected pact file at #{pact_path}" unless File.exist?(pact_path)
+	end
+
 	desc 'Runs pact tests against a sample application, testing failure and success.'
 	task 'test:fail' do
 
@@ -80,15 +83,16 @@ namespace :pact do
 		result = nil
 		Open3.popen3(command) {|stdin, stdout, stderr, wait_thr|
 		  result = wait_thr.value
-		  ensure_patterns_present(options, stdout, stderr) if options[:with]
+		  ensure_patterns_present(command, options, stdout, stderr) if options[:with]
 		}
 		result.success?
 	end
 
-	def ensure_patterns_present options, stdout, stderr
+	def ensure_patterns_present command, options, stdout, stderr
+		require 'term/ansicolor'
 		output = stdout.read + stderr.read
 		options[:with].each do | pattern |
-			raise (::Term::ANSIColor.red("Could not find #{pattern.inspect} in output of #{command}").red + "\n\n#{output}") unless output =~ pattern
+			raise (::Term::ANSIColor.red("Could not find #{pattern.inspect} in output of #{command}") + "\n\n#{output}") unless output =~ pattern
 		end
 	end