pact 0.1.28 → 1.3.3

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

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

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

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

@@ -0,0 +1,24 @@
+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,6 +1,6 @@
 require 'spec_helper'
 
-module Pact::Consumer
+module Pact
    describe ServiceConsumer do
       describe "as_json" do
          it "returns a hash representation of the object" do

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

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