pact 1.1.1 → 1.2.1.rc1

data/spec/integration/pact/consumer_configuration_spec.rb

@@ -10,12 +10,14 @@ describe "consumer side" do
     end
 
     let(:application) { double("App")}
+    let(:world) { Pact::Consumer::World.new }
 
     before do
       Pact.clear_configuration
       Pact::Consumer::AppManager.instance.clear_all
-      #Don't want processes actually spawning
-      Pact::Consumer::AppRegistration.any_instance.stub(:spawn)
+      # Don't want processes actually spawning
+      allow_any_instance_of(Pact::Consumer::AppRegistration).to receive(:spawn)
+      allow(Pact).to receive(:consumer_world).and_return(world)
 
       my_app = application
 
@@ -40,40 +42,23 @@ describe "consumer side" do
 
     end
 
-    describe "consumer" do
-
-      subject { TestHelper.new.my_service.consumer_contract.consumer }
-
-      it "should be configured" do
-        expect(subject).to be_instance_of Pact::ServiceConsumer
-      end
-
-      it "should have the right name" do
-        expect(subject.name).to eq "My Consumer"
-      end
-
-      it "should have registered the app" do
-        Pact::Consumer::AppManager.instance.app_registered_on?(1111).should be true
-      end
-    end
-
     describe "providers" do
 
       subject { TestHelper.new.my_service }
 
       it "should have defined methods in MockServices for the providers" do
-        subject.should be_instance_of Pact::Consumer::ConsumerContractBuilder
+        expect(subject).to be_instance_of(Pact::Consumer::ConsumerContractBuilder)
       end
 
       context "when standalone is true" do
         it "is not registerd with the AppManager" do
-          Pact::Consumer::AppManager.instance.app_registered_on?(1234).should be false
+          expect(Pact::Consumer::AppManager.instance.app_registered_on?(1234)).to eq false
         end
       end
 
       context "when standalone is false" do
         it "should register the MockServices on their given ports if they are not" do
-          Pact::Consumer::AppManager.instance.app_registered_on?(1235).should be true
+          expect(Pact::Consumer::AppManager.instance.app_registered_on?(1235)).to eq true
         end
       end
     end

data/spec/lib/pact/app_spec.rb

@@ -16,9 +16,9 @@ module Pact
 
       context "when ENV variables are defined" do
         before do
-          ENV.stub(:[])
-          ENV.stub(:[]).with("PACT_DESCRIPTION").and_return(env_description)
-          ENV.stub(:[]).with("PACT_PROVIDER_STATE").and_return(env_provider_state)
+          allow(ENV).to receive(:[])
+          allow(ENV).to receive(:[]).with("PACT_DESCRIPTION").and_return(env_description)
+          allow(ENV).to receive(:[]).with("PACT_PROVIDER_STATE").and_return(env_provider_state)
         end
 
         it "returns the env vars as regexes" do
@@ -34,8 +34,8 @@ module Pact
 
       context "when provider state is an empty string" do
         before do
-          ENV.stub(:[]).with(anything).and_return(nil)
-          ENV.stub(:[]).with("PACT_PROVIDER_STATE").and_return('')
+          allow(ENV).to receive(:[]).with(anything).and_return(nil)
+          allow(ENV).to receive(:[]).with("PACT_PROVIDER_STATE").and_return('')
         end
 
         it "returns a nil provider state so that it matches a nil provider state on the interaction" do

data/spec/lib/pact/configuration_spec.rb

@@ -143,7 +143,7 @@ describe Pact do
       context "when @pactfile_write_mode is :smart" do
         before do
           configuration.pactfile_write_mode = :smart
-          configuration.should_receive(:is_rake_running?).and_return(is_rake_running)
+          expect(configuration).to receive(:is_rake_running?).and_return(is_rake_running)
         end
         context "when rake is running" do
           let(:is_rake_running) { true }

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

@@ -4,9 +4,12 @@ require 'pact/consumer/configuration'
 module Pact::Consumer::Configuration
 
    describe MockService do
+
+      let(:world) { Pact::Consumer::World.new }
       before do
          Pact.clear_configuration
-         Pact::Consumer::AppManager.instance.stub(:register_mock_service_for)
+         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
@@ -19,20 +22,20 @@ module Pact::Consumer::Configuration
             end
          }
 
-         let(:provider_name) { 'Mock Provider'}
-         let(:consumer_contract_builder) { instance_double('Pact::Consumer::ConsumerContractBuilder')}
-         let(:url) { "http://localhost:1234"}
+         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
-            Pact::Consumer::ConsumerContractBuilder.stub(:new).and_return(consumer_contract_builder)
+            allow(Pact::Consumer::ConsumerContractBuilder).to receive(:new).and_return(consumer_contract_builder)
             subject.finalize
-            consumer_contract_builder.should_receive(:verify)
+            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
-               Pact::Consumer::AppManager.instance.should_not_receive(:register_mock_service_for)
+               expect(Pact::Consumer::AppManager.instance).to_not receive(:register_mock_service_for)
                subject.finalize
             end
          end
@@ -45,7 +48,7 @@ module Pact::Consumer::Configuration
                end
             }
             it "registers the app with the AppManager" do
-               Pact::Consumer::AppManager.instance.should_receive(:register_mock_service_for).with(provider_name, url)
+               expect(Pact::Consumer::AppManager.instance).to receive(:register_mock_service_for).with(provider_name, url)
                subject.finalize
             end
          end

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

@@ -9,98 +9,10 @@ module Pact
       let(:consumer_name) { 'a consumer' }
       let(:provider_name) { 'a provider' }
 
-      describe "initialize" do
-        SUPPORT_PACT_FILE = './spec/support/a_consumer-a_provider.json'
-        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 SUPPORT_PACT_FILE, "#{tmp_pact_dir}/a_consumer-a_provider.json"
-        end
-
-        let(:expected_interactions) { ConsumerContract.from_json(File.read(SUPPORT_PACT_FILE)).interactions }
-
-        let(:tmp_pact_dir) {"./tmp/pacts"}
-
-        let(:consumer_contract_builder) {
-          Pact::Consumer::ConsumerContractBuilder.new(
-            :pactfile_write_mode => pactfile_write_mode,
-            :consumer_name => consumer_name,
-            :provider_name => provider_name,
-        :port => 1234)}
-
-        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
-
-          it "uses an DistinctInteractionsFilter to handle new interactions" do
-            Pact::Consumer::DistinctInteractionsFilter.should_receive(:new).with([])
-            consumer_contract_builder
-          end
-        end
-
-        context "when updating pact" do
-          before do
-
-          end
-          let(:pactfile_write_mode) {:update}
-          it "loads the interactions from the existing pact file" do
-            ConsumerContractBuilder.any_instance.stub(:info_and_puts)
-            expect(consumer_contract_builder.consumer_contract.interactions).to eq expected_interactions
-          end
-
-          it "uses an UpdatableInteractionsFilter to handle new interactions" do
-            ConsumerContractBuilder.any_instance.stub(:info_and_puts)
-            Pact::Consumer::UpdatableInteractionsFilter.should_receive(:new).with(expected_interactions)
-            consumer_contract_builder
-          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
-            $stdout.should_receive(:puts).with(line0).twice
-            $stdout.should_receive(:puts).with(line1)
-            $stdout.should_receive(:puts).with(line2)
-            $stdout.should_receive(:puts).with(line3)
-            Pact.configuration.logger.should_receive(:info).with(line0).twice
-            Pact.configuration.logger.should_receive(:info).with(line1)
-            Pact.configuration.logger.should_receive(:info).with(line2)
-            Pact.configuration.logger.should_receive(:info).with(line3)
-            consumer_contract_builder
-          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
-            ConsumerContract.stub(:from_json).and_raise(error)
-            $stderr.should_receive(:puts).with(line1)
-            $stderr.should_receive(:puts).with(line2)
-            Pact.configuration.logger.should_receive(:warn).with(line1)
-            Pact.configuration.logger.should_receive(:warn).with(line2)
-          end
-          it "logs the error" do
-            consumer_contract_builder
-          end
-
-          it "continues with a new file" do
-            expect(consumer_contract_builder.consumer_contract.interactions).to eq []
-          end
-        end
-      end
-
       describe "handle_interaction_fully_defined" do
 
         subject {
-          Pact::Consumer::ConsumerContractBuilder.new({:consumer_name => 'blah', :provider_name => 'blah', :port => 2222})
+          Pact::Consumer::ConsumerContractBuilder.new(:consumer_name => 'blah', :provider_name => 'blah', :port => 2222)
         }
 
         let(:interaction_hash) {
@@ -130,21 +42,11 @@ module Pact
 
         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 "adds the interaction to the consumer contract" do
-          subject.handle_interaction_fully_defined interaction
-          expect(subject.consumer_contract.interactions).to eq [interaction]
-        end
-
-        it "updates the provider's pactfile" do
-          subject.consumer_contract.should_receive(:update_pactfile)
-          subject.handle_interaction_fully_defined interaction
+          expect(WebMock).to have_requested(:post, 'localhost:2222/interactions').with(body: interaction_json)
         end
 
         it "resets the interaction_builder to nil" do
-          subject.should_receive(:interaction_builder=).with(nil)
+          expect(subject).to receive(:interaction_builder=).with(nil)
           subject.handle_interaction_fully_defined interaction
         end
       end

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

@@ -9,20 +9,20 @@ module Pact
       let(:interaction) { double('Interaction').as_null_object}
 
       before do
-        Interaction.should_receive(:new).and_return(interaction)
+        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
-            interaction.should_receive(:provider_state=).with('blah')
+            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
-            interaction.should_receive(:provider_state=).with('some_symbol')
+            expect(interaction).to receive(:provider_state=).with('some_symbol')
             subject.given(:some_symbol)
           end
         end
@@ -34,7 +34,7 @@ module Pact
 
       describe "upon_receiving" do
         it "sets the description on the interaction" do
-          interaction.should_receive(:description=).with('blah')
+          expect(interaction).to receive(:description=).with('blah')
           subject.upon_receiving('blah')
         end
 
@@ -49,8 +49,8 @@ module Pact
         let(:expected_request) { {an: 'expected_request'} }
 
         it "sets the request on the interaction as a instance of Request::Expected" do
-          Pact::Request::Expected.should_receive(:from_hash).with(request).and_return(expected_request)
-          interaction.should_receive(:request=).with(expected_request)
+          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
 
@@ -73,7 +73,7 @@ module Pact
         end
 
         it "sets the response on the interaction" do
-          interaction.should_receive(:response=).with(response)
+          expect(interaction).to receive(:response=).with(response)
           subject.will_respond_with(response)
         end
 
@@ -82,7 +82,7 @@ module Pact
         end
 
         it "invokes the 'on_interaction_fully_defined' callback" do
-          provider.should_receive(:callback).with(interaction)
+          expect(provider).to receive(:callback).with(interaction)
           subject.will_respond_with response
         end          
       end

data/spec/lib/pact/consumer/mock_service/app_spec.rb

@@ -25,8 +25,8 @@ module Pact
         let(:interaction_replay) { double(InteractionReplay, :match? => true)}
 
         before do
-          InteractionReplay.stub(:new).and_return(interaction_replay)
-          interaction_replay.stub(:respond).and_raise("an error")
+          expect(InteractionReplay).to receive(:new).and_return(interaction_replay)
+          expect(interaction_replay).to receive(:respond).and_raise("an error")
         end
 
         subject { get "/" }

data/spec/lib/pact/consumer/mock_service/interaction_mismatch_spec.rb

@@ -15,8 +15,8 @@ module Pact
       let(:diff_2) { {} }
 
       before do
-        expected_request_1.stub(:difference).with(actual_request).and_return(diff_1)
-        expected_request_2.stub(:difference).with(actual_request).and_return(diff_2)
+        allow(expected_request_1).to receive(:difference).with(actual_request).and_return(diff_1)
+        allow(expected_request_2).to receive(:difference).with(actual_request).and_return(diff_2)
       end
 
       describe "short_summary" do

data/spec/lib/pact/consumer/mock_service/interaction_replay_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'pact/consumer/mock_service/interaction_replay'
+
+module Pact
+  module Consumer
+
+    describe InteractionReplay do
+
+
+    end
+  end
+end

data/spec/lib/pact/consumer/mock_service/verification_get_spec.rb

@@ -12,8 +12,8 @@ module Pact
       subject { VerificationGet.new('VerificationGet', logger, interaction_list, log_description) }
 
       describe "request_path" do
-        it "is /verify" do
-          expect(subject.request_path).to eq '/verify'
+        it "is /interactions/verification" do
+          expect(subject.request_path).to eq '/interactions/verification'
         end
       end
 

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'pact/consumer/mock_service_client'
+
+module Pact
+  module Consumer
+    describe MockServiceClient do
+
+      subject { MockServiceClient.new(4444) }
+
+      let(:administration_headers) { {'X-Pact-Mock-Service' => 'true'} }
+
+      describe "#add_expected_interaction" do
+        let(:interaction) { InteractionFactory.create }
+        let(:request_body) { MockServiceInteractionExpectation.new(interaction).to_json }
+
+        context "when successful" do
+          let!(:post_interaction) do
+            stub_request(:post, "localhost:4444/interactions").
+              with(body: request_body, headers: administration_headers.merge('Content-Type' => "application/json")).
+              to_return(status: 200)
+          end
+
+          it "sets up the expected interaction on the mock server" do
+            subject.add_expected_interaction interaction
+            expect(post_interaction).to have_been_made
+          end
+        end
+
+      end
+
+      describe "#verify" do
+
+        context "when all interactions are successfully verified" do
+
+          let!(:get_verification) do
+            stub_request(:get, "localhost:4444/interactions/verification?example_description=some%20example").
+              with(headers: administration_headers).
+              to_return(status: 200)
+          end
+
+          it "does not throw an error" do
+            subject.verify "some example"
+            expect(get_verification).to have_been_made
+          end
+        end
+      end
+
+      describe ".clear_interactions" do
+        let!(:delete_verifications) do
+          stub_request(:delete, "localhost:4444/interactions?example_description=some%20example").
+            with(headers: administration_headers).
+            to_return(status: 200)
+        end
+
+        it "deletes the interactions" do
+          MockServiceClient.clear_interactions 4444, "some example"
+          expect(delete_verifications).to have_been_made
+        end
+      end
+
+      describe "#write_pact" do
+        let(:consumer_contract_details) { {consumer: {name: 'Consumer'}, provider: {name: 'Provider'}, pactfile_write_mode: 'update'} }
+        let(:pact) { {a: 'pact'}.to_json }
+
+        let!(:post_pact) do
+          stub_request(:post, "localhost:4444/pact").
+            with(headers: administration_headers.merge('Content-Type' => "application/json"), body: consumer_contract_details).
+            to_return(status: 200, body: pact)
+        end
+
+        it "deletes the interactions" do
+          expect(subject.write_pact(consumer_contract_details)).to eq pact
+          expect(post_pact).to have_been_made
+        end
+
+      end
+
+      describe "#log" do
+        it "sends a log request to the mock server"
+      end
+
+      describe "#wait_for_interactions" do
+        it "waits until there are no missing interactions"
+      end
+    end
+  end
+end
+

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

@@ -3,6 +3,7 @@ require 'pact/consumer/mock_service_interaction_expectation'
 
 describe Pact::Consumer::MockServiceInteractionExpectation do
   describe "as_json" do
+
     let(:options ) { {} }
     let(:request_as_json) { {a: 'request'} }
     let(:request) { instance_double('Pact::Request::Expected', :as_json => request_as_json, :options => options)}
@@ -13,12 +14,11 @@ describe Pact::Consumer::MockServiceInteractionExpectation do
     let(:expected_hash) { {:response => generated_response, :request => as_json_with_options, :description => '' } }
 
     before do
-      Pact::Reification.stub(:from_term).with(response).and_return(generated_response)
+      allow(Pact::Reification).to receive(:from_term).with(response).and_return(generated_response)
     end
 
-    it "generates an actual response" do
-      Pact::Reification.should_receive(:from_term).with(response).and_return(generated_response)
-      expect(subject.as_json[:response]).to eq generated_response
+    it "includes the response" do
+      expect(subject.as_json[:response]).to eq response
     end
 
     it "includes the options in the request" do

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

@@ -12,7 +12,7 @@ module Pact
       end
 
       before do
-        DateTime.stub(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
+        allow(DateTime).to receive(:now).and_return(DateTime.strptime("2013-08-15T13:27:13+10:00"))
       end
 
       let(:service_consumer) { double('ServiceConsumer', :as_json => {:a => 'consumer'}) }
@@ -21,7 +21,7 @@ module Pact
       let(:expected_as_json) { {:provider=>{:a=>"provider"}, :consumer=>{:a=>"consumer"}, :interactions=>[{:mock=>"interaction"}], :metadata=>{:pactSpecificationVersion=> "1.0.0" }} }
 
       it "should return a hash representation of the Pact" do
-        pact.as_json.should eq expected_as_json
+        expect(pact.as_json).to eq expected_as_json
       end
 
     end
@@ -32,43 +32,43 @@ module Pact
         let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
 
         it "should create a Pact" do
-          loaded_pact.should be_instance_of ConsumerContract
+          expect(loaded_pact).to be_instance_of ConsumerContract
         end
 
         it "should have interactions" do
-          loaded_pact.interactions.should be_instance_of Array
+          expect(loaded_pact.interactions).to be_instance_of Array
         end
 
         it "should have a consumer" do
-          loaded_pact.consumer.should be_instance_of Pact::ServiceConsumer
+          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
         end
 
         it "should have a provider" do
-          loaded_pact.provider.should be_instance_of Pact::ServiceProvider
+          expect(loaded_pact.provider).to 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
+          expect(loaded_pact).to be_instance_of ConsumerContract
         end
 
         it "should have interactions" do
-          loaded_pact.interactions.should be_instance_of Array
+          expect(loaded_pact.interactions).to be_instance_of Array
         end
 
         it "should have a consumer" do
-          loaded_pact.consumer.should be_instance_of Pact::ServiceConsumer
+          expect(loaded_pact.consumer).to 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"
+          expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
+          expect(loaded_pact.provider.name).to eq "an old producer"
         end
 
         it "should have a provider_state" do
-          loaded_pact.interactions.first.provider_state.should eq 'state one'
+          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
         end
       end
     end
@@ -80,7 +80,7 @@ module Pact
       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)
+        expect(interaction).to receive(:matches_criteria?).with(criteria).and_return(matches)
       end
       context "by description" do
         context "when no interactions are found" do
@@ -106,8 +106,8 @@ module Pact
       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)
+        expect(interaction1).to receive(:matches_criteria?).with(criteria).and_return(matches1)
+        expect(interaction2).to receive(:matches_criteria?).with(criteria).and_return(matches2)
       end
 
       subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
@@ -162,18 +162,18 @@ eos
       let(:interactions) { [double("interaction", as_json: "something")]}
       subject { ConsumerContract.new(:consumer => consumer, :provider => provider, :interactions => interactions) }
       before do
-        Pact.configuration.stub(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
+        allow(Pact.configuration).to receive(:pact_dir).and_return(Pathname.new("./tmp/pactfiles"))
         FileUtils.rm_rf pacts_dir
         FileUtils.mkdir_p pacts_dir
         subject.update_pactfile
       end
 
       it "should write to a file specified by the consumer and provider name" do
-        File.exist?(expected_pact_path).should be true
+        expect(File.exist?(expected_pact_path)).to eq true
       end
 
       it "should write the interactions to the file" do
-        File.read(expected_pact_path).should eql expected_pact_string.strip
+        expect(File.read(expected_pact_path)).to eql expected_pact_string.strip
       end
     end
   end