pact 1.3.3 → 1.4.0

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

@@ -1,142 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service/verification_get'
-
-module Pact
-  module Consumer
-    describe VerificationGet do
-
-      let(:interaction_list) { instance_double("Pact::Consumer::InteractionList")}
-      let(:logger) { double("Logger").as_null_object }
-      let(:log_description) { "/log/pact.log" }
-
-      subject { VerificationGet.new('VerificationGet', logger, interaction_list, log_description) }
-
-      describe "request_path" do
-        it "is /interactions/verification" do
-          expect(subject.request_path).to eq '/interactions/verification'
-        end
-      end
-
-      describe "request_method" do
-        it "is GET" do
-          expect(subject.request_method).to eq 'GET'
-        end
-      end
-
-      describe "#respond" do
-        let(:env) { {
-          "QUERY_STRING" => "example_description=a description"
-        } }
-
-        before do
-          allow(interaction_list).to receive(:all_matched?).and_return(all_matched)
-        end
-
-        let(:response) { subject.respond env }
-
-        context "when all interactions have been matched" do
-          let(:all_matched) { true }
-
-          it "returns a 200 status" do
-            expect(response.first).to eq 200
-          end
-
-          it "returns a Content-Type of text/plain" do
-            expect(response[1]).to eq 'Content-Type' => 'text/plain'
-          end
-
-          it "returns a nice message" do
-            expect(response.last).to eq ['Interactions matched']
-          end
-
-          it "logs the success" do
-            expect(logger).to receive(:info).with(/Verifying - interactions matched.*a description/)
-            response
-          end
-        end
-
-        context "when all interactions not been matched" do
-          let(:all_matched) { false }
-          let(:failure_message) { "this is a failure message"}
-
-          before do
-            allow_any_instance_of(VerificationGet::FailureMessage).to receive(:to_s).and_return(failure_message)
-          end
-
-          it "returns a 500 status" do
-            expect(response.first).to eq 500
-          end
-
-          it "returns a Content-Type of text/plain" do
-            expect(response[1]).to eq 'Content-Type' => 'text/plain'
-          end
-
-          it "returns a message" do
-            expect(response.last.first).to include "Actual interactions do not match"
-            expect(response.last.first).to include failure_message
-            expect(response.last.first).to include log_description
-          end
-
-          it "logs the failure message" do
-            expect(logger).to receive(:warn).with(/Verifying - actual interactions do not match/)
-            expect(logger).to receive(:warn).with(failure_message)
-            response
-          end
-
-        end
-
-      end
-
-      describe "FailureMessage" do
-        let(:missing_interactions_summaries) { ["Blah", "Thing"]}
-        let(:interaction_mismatches_summaries) { []}
-        let(:unexpected_requests_summaries) { []}
-        let(:interaction_list) { instance_double("Pact::Consumer::InteractionList") }
-        subject { VerificationGet::FailureMessage.new(interaction_list).to_s }
-
-        before do
-          allow(interaction_list).to receive(:missing_interactions_summaries).and_return(missing_interactions_summaries)
-          allow(interaction_list).to receive(:interaction_mismatches_summaries).and_return(interaction_mismatches_summaries)
-          allow(interaction_list).to receive(:unexpected_requests_summaries).and_return(unexpected_requests_summaries)
-        end
-
-        context "with only a missing interactions" do
-
-          let(:expected_string) { <<-EOS
-Missing requests:
-\tBlah
-\tThing
-
-EOS
-}
-          it "only includes missing interactions" do
-            expect(subject).to eq expected_string
-          end
-        end
-
-        context "with missing, mismatches and unexpected interactions" do
-
-          let(:interaction_mismatches_summaries) { ["wiffle"]}
-          let(:unexpected_requests_summaries) { ["moose"]}
-
-          let(:expected_string) { <<-EOS
-Incorrect requests:
-\twiffle
-
-Missing requests:
-\tBlah
-\tThing
-
-Unexpected requests:
-\tmoose
-
-EOS
-}
-          it "includes all the things" do
-            expect(subject).to eq expected_string
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-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

@@ -1,54 +0,0 @@
-require 'spec_helper'
-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)}
-    let(:response) { double('response') }
-    let(:generated_response ) { double('generated_response', :to_json => 'generated_response') }
-    let(:interaction) { instance_double('Pact::Interaction', :description => 'description', :request => request, :response => response, :provider_state => 'some state') }
-    subject { described_class.new(interaction)}
-    let(:expected_hash) { {:response => generated_response, :request => as_json_with_options, :description => '' } }
-
-    before do
-      allow(Pact::Reification).to receive(:from_term).with(response).and_return(generated_response)
-    end
-
-    it "includes the response" do
-      expect(subject.as_json[:response]).to eq response
-    end
-
-    it "includes the options in the request" do
-      expect(subject.as_json[:request]).to eq request_as_json
-    end
-
-    it "includes the provider state" do
-      expect(subject.as_json[:provider_state]).to eq 'some state'
-    end
-
-    it "includes the description" do
-      expect(subject.as_json[:description]).to eq 'description'
-    end
-
-    it "doesn't have any other keys" do
-      expect(subject.as_json.keys).to eq [:description, :provider_state, :request, :response]
-    end
-
-    context "without options" do
-      it "does not include the options key" do
-        expect(subject.as_json.key?(:options)).to be false
-      end
-    end
-
-    context "with options" do
-      let(:options) { {:opts => 'blah'} }
-      it "includes the options in the request hash" do
-        expect(subject.as_json[:request][:options]).to eq options
-      end
-    end
-  end
-
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples_for_request'
-
-module Pact
-  describe Consumer::Request::Actual do
-    it_behaves_like "a request"
-
-    let(:raw_request) do
-      {
-        'method' => 'get',
-        'path' => '/mallory'
-      }
-    end
-
-    describe "from_hash" do
-      context "when field are not defined" do
-        subject { described_class.from_hash(raw_request) }
-        it "raises an error" do
-          expect{subject}.to raise_error KeyError
-        end
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-module Pact
-   describe ServiceConsumer do
-      describe "as_json" do
-         it "returns a hash representation of the object" do
-            expect(ServiceConsumer.new(:name => "Bob").as_json).to eq :name => "Bob"
-         end
-      end
-   end
-end   

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

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'pact/shared/active_support_support'
-
-module Pact
-  describe ActiveSupportSupport do
-
-    include ActiveSupportSupport
-
-
-    describe "fix_regexp" do
-      let(:regexp) { /moose/ }
-
-      subject { fix_regexp regexp }
-
-      it "returns the original regexp" do
-        expect(subject).to be(regexp)
-      end
-
-      it "fixes the as_json method for Regexp that ActiveSupport tramples beneath its destructive hooves of destruction" do
-        expect(subject.to_json).to eq("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"moose\"}")
-      end
-    end
-
-    describe "fix_all_the_things" do
-      let(:hash) do
-        { 'body' => Pact::Term.new(matcher: /a*b/, generate: 'abba'), array: [/blah/], thing: /alligator/ }
-      end
-
-      subject { fix_all_the_things(hash) }
-
-      it "returns the original object" do
-        expect(subject).to be(hash)
-      end
-
-      it "finds all the Regexp objects in hashes or Pact class attributes and fixes the as_json method" do
-        json = subject.to_json
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}")
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"blah\"}")
-        expect(json).to include("{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"alligator\"}")
-      end
-    end
-
-    describe "fix_json_formatting" do
-      let(:active_support_affected_pretty_generated_json) { "{\"json_class\":\"Regexp\",\"o\":0,\"s\":\"a*b\"}" }
-      let(:pretty_generated_json) do
-'{
-  "json_class": "Regexp",
-  "o": 0,
-  "s": "a*b"
-}'
-      end
-
-      it "pretty formats the json that has been not pretty formatted because of ActiveSupport" do
-        expect(fix_json_formatting(active_support_affected_pretty_generated_json)).to eq (pretty_generated_json.strip)
-      end
-    end
-  end
-end

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

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract'
-
-module Pact
-  describe ConsumerContract do
-    describe "as_json" do
-
-      class MockInteraction
-        def as_json(options ={})
-          {:mock => "interaction"}
-        end
-      end
-
-      before do
-        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'}) }
-      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=>{:pactSpecificationVersion=> "1.0.0" }} }
-
-      it "should return a hash representation of the Pact" do
-        expect(pact.as_json).to eq expected_as_json
-      end
-
-    end
-
-    describe ".from_json" do
-      let(:loaded_pact) { ConsumerContract.from_json(string) }
-      context "when the top level object is a ConsumerContract" do
-        let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
-
-        it "should create a Pact" do
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
-
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
-
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
-
-        it "should have a provider" do
-          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
-          expect(loaded_pact).to be_instance_of ConsumerContract
-        end
-
-        it "should have interactions" do
-          expect(loaded_pact.interactions).to be_instance_of Array
-        end
-
-        it "should have a consumer" do
-          expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-        end
-
-        it "should have a provider" do
-          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
-          expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
-        end
-      end
-    end
-
-    describe "find_interactions" do
-      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
-        expect(interaction).to 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(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(criteria)).to eql [interaction]
-          end
-        end
-      end
-    end
-
-    describe "find_interaction" do
-      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
-        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) }
-      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 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(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(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) do <<-eos
-{
-  "provider": {
-    "name": "test_service"
-  },
-  "consumer": {
-    "name": "test_consumer"
-  },
-  "interactions": [
-    "something"
-  ],
-  "metadata": {
-    "pactSpecificationVersion": "1.0.0"
-  }
-}
-eos
-      end
-      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, :provider => provider, :interactions => interactions) }
-      before do
-        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
-        expect(File.exist?(expected_pact_path)).to eq true
-      end
-
-      it "should write the interactions to the file" do
-        expect(File.read(expected_pact_path)).to eql expected_pact_string.strip
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-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