pact 1.3.3 → 1.4.0

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

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

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-require 'pathname'
-
-module Pact
-  module Consumer
-    describe ConsumerContractBuilder do
-
-      let(:consumer_name) { 'a consumer' }
-      let(:provider_name) { 'a provider' }
-
-      describe "handle_interaction_fully_defined" do
-
-        subject {
-          Pact::Consumer::ConsumerContractBuilder.new(:consumer_name => 'blah', :provider_name => 'blah', :port => 2222)
-        }
-
-        let(:interaction_hash) {
-          {
-            description: 'Test request',
-            request: {
-              method: 'post',
-              path: '/foo',
-              body: Term.new(generate: 'waffle', matcher: /ffl/),
-              headers: { 'Content-Type' => 'application/json' },
-              query: "",
-            },
-            response: {
-              baz: 'qux',
-              wiffle: 'wiffle'
-            }
-          }
-        }
-
-        let(:interaction_json) { {} }
-
-        let(:interaction) { Pact::Interaction.from_hash(JSON.load(interaction_hash.to_json)) }
-
-        before do
-          stub_request(:post, 'localhost:2222/interactions')
-        end
-
-        it "posts the interaction with generated response to the mock service" do
-          subject.handle_interaction_fully_defined interaction
-          expect(WebMock).to have_requested(:post, 'localhost:2222/interactions').with(body: interaction_json)
-        end
-
-        it "resets the interaction_builder to nil" do
-          expect(subject).to receive(:interaction_builder=).with(nil)
-          subject.handle_interaction_fully_defined interaction
-        end
-      end
-
-      describe "#mock_service_base_url" do
-
-      	subject {
-      		ConsumerContractBuilder.new(
-      			:pactfile_write_mode => :overwrite,
-            :consumer_name => consumer_name,
-            :provider_name => provider_name,
-        		:port => 1234) }
-
-      	it "returns the mock service base URL" do
-      		expect(subject.mock_service_base_url).to eq("http://localhost:1234")
-      	end
-      end
-    end
-  end
-end

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

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

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

@@ -1,64 +0,0 @@
-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/app_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'rack/test'
-require 'tempfile'
-
-module Pact
-  module Consumer
-
-    describe MockService do
-
-      include Rack::Test::Methods
-
-      def app
-        MockService.new(log_file: temp_file)
-      end
-
-      let(:temp_file) { Tempfile.new('log') }
-
-      after do
-        temp_file.close
-        temp_file.unlink
-      end
-
-      context "when a StandardError is encountered" do
-        let(:response) { JSON.parse(last_response.body)}
-        let(:interaction_replay) { double(InteractionReplay, :match? => true)}
-
-        before do
-          expect(InteractionReplay).to receive(:new).and_return(interaction_replay)
-          expect(interaction_replay).to receive(:respond).and_raise("an error")
-        end
-
-        subject { get "/" }
-
-        it "returns a json error" do
-          subject
-          expect(last_response.content_type).to eq 'application/json'
-        end
-
-        it "includes the error message" do
-          subject
-          expect(response['message']).to eq "an error"
-        end
-
-        it "includes the backtrace" do
-          subject
-          expect(response['backtrace']).to be_instance_of Array
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service/interaction_list'
-
-module Pact::Consumer
-
-  describe InteractionList do
-    shared_context "unexpected requests and missed interactions" do
-      let(:expected_interaction) { InteractionFactory.create }
-      let(:unexpected_request) { RequestFactory.create_actual method: 'put' }
-      let(:candidate_interaction) { double("Pact::Interaction") }
-      let(:candidate_interactions) { [candidate_interaction] }
-      let(:interaction_mismatch) { instance_double("Pact::Consumer::InteractionMismatch", :short_summary => 'blah', :candidate_interactions => candidate_interactions)}
-      subject {
-        interactionList = InteractionList.new
-        interactionList.add expected_interaction
-        interactionList.register_unexpected_request unexpected_request
-        interactionList.register_interaction_mismatch interaction_mismatch
-        interactionList
-       }
-    end
-
-    shared_context "no unexpected requests or missed interactions exist" do
-      let(:expected_interaction) { InteractionFactory.create }
-      subject {
-        interactionList = InteractionList.new
-        interactionList.add expected_interaction
-        interactionList.register_matched expected_interaction
-        interactionList
-       }
-    end
-
-    describe "interaction_diffs" do
-      context "when unexpected requests and missed interactions exist" do
-        include_context "unexpected requests and missed interactions"
-        let(:expected_diff) {
-          {:missing_interactions=>["GET /path"],
-            :unexpected_requests=>["PUT /path?query"],
-            :interaction_mismatches => ['blah']}
-        }
-        it "returns the unexpected requests and missed interactions" do
-          expect(subject.interaction_diffs).to eq expected_diff
-        end
-      end
-
-      context "when no unexpected requests or missed interactions exist" do
-        include_context "no unexpected requests or missed interactions exist"
-        let(:expected_diff) {
-          {}
-        }
-        it "returns an empty hash" do
-          expect(subject.interaction_diffs).to eq expected_diff
-        end
-      end
-    end
-
-    describe "all_matched?" do
-      context "when unexpected requests or missed interactions exist" do
-        include_context "unexpected requests and missed interactions"
-        it "returns false" do
-          expect(subject.all_matched?).to be false
-        end
-      end
-      context "when unexpected requests or missed interactions do not exist" do
-        include_context "no unexpected requests or missed interactions exist"
-        it "returns false" do
-          expect(subject.all_matched?).to be true
-        end
-      end
-    end
-
-    describe "missing_interactions_summaries" do
-      include_context "unexpected requests and missed interactions"
-      it "returns a list of the method and paths for each missing interaction" do
-        expect(subject.missing_interactions_summaries).to eq ["GET /path"]
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service/interaction_mismatch'
-
-module Pact
-  module Consumer
-    describe InteractionMismatch do
-      let(:content_type) { 'some/content' }
-      let(:actual_request) { instance_double('Pact::Consumer::Request::Actual', :method_and_path => 'GET /path') }
-      let(:expected_request_1) { instance_double('Pact::Request::Expected', :content_type => content_type) }
-      let(:expected_request_2) { instance_double('Pact::Request::Expected', :content_type => content_type) }
-      let(:candidate_1) { instance_double('Pact::Interaction', request: expected_request_1, description_with_provider_state_quoted: "desc 1") }
-      let(:candidate_2) { instance_double('Pact::Interaction', request: expected_request_2, description_with_provider_state_quoted: "desc 2") }
-      let(:candidate_interactions) { [candidate_1, candidate_2] }
-      subject { InteractionMismatch.new(candidate_interactions, actual_request) }
-      let(:diff_1) { {body: 'diff'} }
-      let(:diff_2) { {} }
-
-      before do
-        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
-        it "includes the method and path" do
-          expect(subject.short_summary).to match /GET \/path \(.*\)/
-        end
-        context "when the body does not match" do
-          let(:diff_1) { {body: nil} }
-
-          it "returns a message indicating that the body does not match" do
-            expect(subject.short_summary).to include "(request body did not match)"
-          end
-        end
-        context "when the headers do not match" do
-          let(:diff_1) { {headers: nil} }
-          it "returns a message indicating that the body does not match" do
-            expect(subject.short_summary).to include "(request headers did not match)"
-          end
-        end
-        context "when the headers and body do not match" do
-          let(:diff_1) { {body: nil, headers: nil} }
-          let(:diff_2) { {body: nil, headers: nil} }
-          it "returns a message indicating that the headers and body do not match" do
-            expect(subject.short_summary).to include "(request body and headers did not match)"
-          end
-        end
-      end
-
-      describe "to_s" do
-        let(:expected_message) { "Diff with interaction: desc 1\ndiff 1\nDiff with interaction: desc 2\ndiff 2" }
-
-        let(:diff_formatter) { double("diff_formatter")}
-        before do
-          allow(Pact.configuration).to receive(:diff_formatter_for_content_type).with(content_type).and_return(diff_formatter)
-          allow(diff_formatter).to receive(:call).and_return("diff 1", "diff 2")
-        end
-
-        it "creates diff output using the configured diff_formatter" do
-          expect(diff_formatter).to receive(:call).with(diff_1, colour: false)
-          expect(diff_formatter).to receive(:call).with(diff_2, colour: false)
-          subject.to_s
-        end
-
-        it "includes a diff output in the string output" do
-          expect(subject.to_s).to eq expected_message
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-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/rack_request_helper_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/mock_service/rack_request_helper'
-
-module Pact::Consumer
-
-  describe RackRequestHelper do
-    class TestSubject
-      include RackRequestHelper
-    end
-
-    let(:rack_env) {
-      {
-             "CONTENT_LENGTH" => "16",
-               "CONTENT_TYPE" => content_type,
-          "GATEWAY_INTERFACE" => "CGI/1.1",
-                  "PATH_INFO" => "/donuts",
-               "QUERY_STRING" => "",
-                "REMOTE_ADDR" => "127.0.0.1",
-                "REMOTE_HOST" => "localhost",
-             "REQUEST_METHOD" => "POST",
-                "REQUEST_URI" => "http://localhost:4321/donuts",
-                "SCRIPT_NAME" => "",
-                "SERVER_NAME" => "localhost",
-                "SERVER_PORT" => "4321",
-            "SERVER_PROTOCOL" => "HTTP/1.1",
-            "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/1.9.3/2013-02-22)",
-                "HTTP_ACCEPT" => "text/plain",
-            "HTTP_USER_AGENT" => "Ruby",
-                  "HTTP_HOST" => "localhost:4321",
-           "HTTP_X_SOMETHING" => "1, 2",
-               "rack.version" => [1, 2 ],
-                 "rack.input" => StringIO.new(body),
-                "rack.errors" => nil,
-           "rack.multithread" => true,
-          "rack.multiprocess" => false,
-              "rack.run_once" => false,
-            "rack.url_scheme" => "http",
-               "HTTP_VERSION" => "HTTP/1.1",
-               "REQUEST_PATH" => "/donuts"
-      }
-     }
-
-     let(:content_type) { "" }
-     let(:body) { '' }
-
-    subject { TestSubject.new }
-
-    let(:expected_request) {
-      {
-            :query => "",
-           :method => "post",
-             :body => expected_body,
-             :path => "/donuts",
-          :headers => {
-              "Content-Type" => content_type,
-              "Content-Length" => "16",
-                    "Accept" => "text/plain",
-                "User-Agent" => "Ruby",
-                      "Host" => "localhost:4321",
-                   "Version" => "HTTP/1.1",
-                   "X-Something" => "1, 2"
-          }
-      }
-    }
-
-    context "with a text body" do
-      let(:content_type) { "application/x-www-form-urlencoded" }
-      let(:body) { 'this is the body' }
-      let(:expected_body) { body }
-
-      it "extracts the body" do
-        expect(subject.request_as_hash_from(rack_env)).to eq expected_request
-      end
-    end
-
-    context "with a json body" do
-      let(:content_type) { "application/json" }
-      let(:body) { '{"a" : "body" }' }
-      let(:expected_body) { {"a" => "body"} }
-
-      it "extracts the body" do
-        expect(subject.request_as_hash_from(rack_env)).to eq expected_request
-      end
-    end
-
-
-  end
-end