pact-mock_service 0.0.1

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

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

@@ -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/rack_request_helper_spec.rb

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

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

@@ -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

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

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

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

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'fakefs/spec_helpers'
+require 'rspec'
+require 'pact/support'
+require 'webmock/rspec'
+require 'support/factories'
+require 'support/spec_support'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+require './spec/support/active_support_if_configured'
+
+RSpec.configure do | config |
+  config.include(FakeFS::SpecHelpers, :fakefs => true)
+end
+

data/spec/support/a_consumer-a_producer.json

@@ -0,0 +1,32 @@
+{
+  "producer": {
+    "name": "an old producer"
+  },
+  "consumer": {
+    "name": "a consumer"
+  },
+  "interactions": [
+    {
+      "description": "request one",
+      "request": {
+        "method": "get",
+        "path": "/path_one"
+      },
+      "response": {
+      },
+      "producer_state": "state one"
+    },
+    {
+      "description": "request two",
+      "request": {
+        "method": "get",
+        "path": "/path_two"
+      },
+      "response": {
+      }
+    }
+  ],
+  "metadata": {
+    "pactSpecificationVersion": "1.0"
+  }
+}

data/spec/support/a_consumer-a_provider.json

@@ -0,0 +1,32 @@
+{
+  "provider": {
+    "name": "a provider"
+  },
+  "consumer": {
+    "name": "a consumer"
+  },
+  "interactions": [
+    {
+      "description": "request one",
+      "request": {
+        "method": "get",
+        "path": "/path_one"
+      },
+      "response": {
+      },
+      "provider_state": "state one"
+    },
+    {
+      "description": "request two",
+      "request": {
+        "method": "get",
+        "path": "/path_two"
+      },
+      "response": {
+      }
+    }
+  ],
+  "metadata": {
+    "pactSpecificationVersion": "1.0"
+  }
+}

data/spec/support/active_support_if_configured.rb

@@ -0,0 +1,6 @@
+if ENV['LOAD_ACTIVE_SUPPORT']
+   puts 'LOADING ACTIVE SUPPORT!!!! Hopefully it all still works'
+   require 'active_support/all'
+   require 'active_support'
+   require 'active_support/json'
+end

data/spec/support/app_for_config_ru.rb

@@ -0,0 +1,4 @@
+class AppForConfigRu
+  def call env
+  end
+end