pact-mock_service 0.2.2 → 0.2.3.pre.rc1

data/spec/features/mock_multiple_responses_spec.rb

@@ -1,120 +0,0 @@
-require 'pact/consumer/mock_service/app'
-require 'rack/test'
-
-describe Pact::Consumer::MockService do
-
-  include Rack::Test::Methods
-
-  let(:app) { Pact::Consumer::MockService.new(log_file: StringIO.new) }
-
-  # NOTE: the admin_headers are Rack headers, they will be converted
-  # to X-Pact-Mock-Service and Content-Type by the framework
-  let(:admin_headers) { {'HTTP_X_PACT_MOCK_SERVICE' => 'true', 'CONTENT_TYPE' => 'application/json'} }
-
-  let(:expected_interaction) do
-    {
-      description: "a request for alligators",
-      provider_state: "alligators exist",
-      request: {
-        method: :get,
-        path: '/alligators',
-        headers: { 'Accept' => 'application/json' },
-      },
-      response: {
-        status: 200,
-        headers: { 'Content-Type' => 'application/json' },
-        body: [{ name: 'Mary' }]
-      }
-    }.to_json
-  end
-
-  context "when more than one response has been mocked" do
-    context "when the actual request matches one expected request" do
-
-      let(:another_expected_interaction) do
-        {
-          description: "a request for zebras",
-          provider_state: "there are zebras",
-          request: {
-            method: :get,
-            path: '/zebras',
-            headers: { 'Accept' => 'application/json' },
-          },
-          response: {
-            status: 200,
-            headers: { 'Content-Type' => 'application/json' },
-            body: [{ name: 'Xena Zebra' }]
-          }
-        }.to_json
-      end
-
-      it "returns the expected response" do
-        # Set up expected interaction
-        post "/interactions", expected_interaction, admin_headers
-
-        # Set up another expected interaction
-        post "/interactions", another_expected_interaction, admin_headers
-
-        # Invoke the actual request
-        get "/alligators", nil, { 'HTTP_ACCEPT' => 'application/json' }
-
-        # Ensure that the response we get back was the one we expected
-        expect(last_response.status).to eq 200
-        expect(last_response.headers['Content-Type']).to eq 'application/json'
-        expect(JSON.parse(last_response.body)).to eq([{ 'name' => 'Mary' }])
-
-        # Invoke the /zebras request
-        get "/zebras", nil, { 'HTTP_ACCEPT' => 'application/json' }
-
-        # Ensure we got the zebra response back
-        expect(JSON.parse(last_response.body)).to eq([{ 'name' => 'Xena Zebra' }])
-
-        # Verify
-        get "/interactions/verification", nil, admin_headers
-        expect(last_response.status).to eq 200
-
-      end
-    end
-
-    context "when the actual request matches more than one expected request" do
-
-      let(:another_expected_interaction) do
-        {
-          description: "a request for alligators",
-          provider_state: "there are no alligators",
-          request: {
-            method: :get,
-            path: '/alligators',
-            headers: { 'Accept' => 'application/json' },
-          },
-          response: {
-            status: 200,
-            headers: { 'Content-Type' => 'application/json' },
-            body: []
-          }
-        }.to_json
-      end
-
-      it "returns an error response" do
-        # Set up expected interaction
-        post "/interactions", expected_interaction, admin_headers
-
-        # Set up another expected interaction
-        post "/interactions", another_expected_interaction, admin_headers
-
-        # Invoke the actual request
-        get "/alligators", nil, { 'HTTP_ACCEPT' => 'application/json' }
-
-        # A 500 is returned as both interactions match the actual request
-        expect(last_response.status).to eq 500
-        expect(last_response.body).to include 'Multiple interaction found'
-
-        # Verification will be false
-        get "/interactions/verification", nil, admin_headers
-        expect(last_response.status).to eq 500
-        expect(last_response.body).to include 'Actual interactions do not match expected interactions'
-      end
-    end
-  end
-
-end

data/spec/features/mock_response_spec.rb

@@ -1,71 +0,0 @@
-require 'pact/consumer/mock_service/app'
-require 'rack/test'
-
-describe Pact::Consumer::MockService do
-
-  include Rack::Test::Methods
-
-  let(:app) { Pact::Consumer::MockService.new(log_file: StringIO.new) }
-
-  # NOTE: the admin_headers are Rack headers, they will be converted
-  # to X-Pact-Mock-Service and Content-Type by the framework
-  let(:admin_headers) { {'HTTP_X_PACT_MOCK_SERVICE' => 'true', 'CONTENT_TYPE' => 'application/json'} }
-
-  let(:expected_interaction) do
-    {
-      description: "a request for alligators",
-      provider_state: "alligators exist",
-      request: {
-        method: :get,
-        path: '/alligators',
-        headers: { 'Accept' => 'application/json' },
-      },
-      response: {
-        status: 200,
-        headers: { 'Content-Type' => 'application/json' },
-        body: [{ name: 'Mary' }]
-      }
-    }.to_json
-  end
-
-  context "when a response has been mocked" do
-    context "when the actual request matches the expected request" do
-      it "returns the expected response" do
-        # Set up expected interaction
-        post "/interactions", expected_interaction, admin_headers
-
-        # Invoke the actual request
-        get "/alligators", nil, { 'HTTP_ACCEPT' => 'application/json' }
-
-        # Ensure that the response we get back was the one we expected
-        expect(last_response.status).to eq 200
-        expect(last_response.headers['Content-Type']).to eq 'application/json'
-        expect(JSON.parse(last_response.body)).to eq([{ 'name' => 'Mary' }])
-
-        # Verify that all the expected interactions were executed, and no extras were made
-        get "/interactions/verification", nil, admin_headers
-        expect(last_response.status).to eq 200
-      end
-    end
-
-    context "when the actual request does not match the expected request" do
-      it "returns an error response" do
-        # Set up expected interaction
-        post "/interactions", expected_interaction, admin_headers
-
-        # Invoke the actual request
-        get "/alligators", nil, { 'HTTP_ACCEPT' => 'application/xml' }
-
-        # A 500 is returned as the headers don't match
-        expect(last_response.status).to eq 500
-        expect(last_response.body).to include 'No interaction found'
-
-        # Verification will be false
-        get "/interactions/verification", nil, admin_headers
-        expect(last_response.status).to eq 500
-        expect(last_response.body).to include 'Actual interactions do not match expected interactions'
-      end
-    end
-  end
-
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer/app_manager'
-
-module Pact::Consumer
-  describe AppManager do
-    before do
-      AppManager.instance.clear_all
-    end
-
-    describe "start_service_for" do
-      before do
-        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
-          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
-          expect(AppManager.instance.app_registered_on?(1234)).to eq true
-        end
-      end
-      context "for https://" do
-        let(:url) { 'https://localhost:1234'}
-        it "should throw an unsupported error" do
-          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only http is supported"
-        end
-      end
-      context "for a host other than localhost" do
-        let(:url) { 'http://aserver:1234'}
-        it "should throw an unsupported error" do
-          expect { AppManager.instance.register_mock_service_for name, url }.to raise_error "Currently only services on localhost are supported"
-        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

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