pact-support 0.0.1

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

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'pact/consumer_contract/headers'
+
+module Pact
+  describe Headers do
+
+    describe "initialize" do
+
+      context "with duplicate headers" do
+
+        subject { Headers.new('Content-Type' => 'application/hippo', 'CONTENT-TYPE' => 'application/giraffe') }
+
+        it "raises an error" do
+          expect { subject }.to raise_error DuplicateHeaderError, /Content\-Type.*CONTENT\-TYPE/
+        end
+
+      end
+
+      context "with a symbol as a header name" do
+
+        subject { Headers.new(:'content-type' => 'application/hippo') }
+
+        it "converts the header name to a String" do
+          expect( subject.to_hash ).to eq 'content-type' => 'application/hippo'
+        end
+
+      end
+
+      context "with a nil header name" do
+
+        subject { Headers.new(nil => 'application/hippo') }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error InvalidHeaderNameTypeError
+        end
+
+      end
+
+      context "with a boolean header name" do
+
+        subject { Headers.new(false => 'application/hippo') }
+
+        it "raises an error" do
+          expect{ subject }.to raise_error InvalidHeaderNameTypeError
+        end
+
+      end
+
+    end
+
+    describe "[]" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject['Content-Type']).to eq('application/hippo')
+        expect(subject['CONTENT-TYPE']).to eq('application/hippo')
+        expect(subject['content-type']).to eq('application/hippo')
+      end
+
+    end
+
+    describe "fetch" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.fetch('Content-Type')).to eq('application/hippo')
+        expect(subject.fetch('CONTENT-TYPE')).to eq('application/hippo')
+        expect(subject.fetch('content-type')).to eq('application/hippo')
+        expect(subject.fetch('Content-Length','1')).to eq('1')
+        expect { subject.fetch('Content-Length')}.to raise_error KeyError
+      end
+
+    end
+
+    describe "key?" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.key?('CONTENT-TYPE')).to be true
+        expect(subject.key?('CONTENT-LENGTH')).to be false
+      end
+    end
+
+    describe "has_key?" do
+
+      subject { Headers.new 'Content-Type' => 'application/hippo' }
+
+      it "is case insensitive as HTTP headers are case insensitive" do
+        expect(subject.has_key?('CONTENT-TYPE')).to be true
+        expect(subject.has_key?('CONTENT-LENGTH')).to be false
+      end
+    end
+
+    describe "[]=" do
+
+      subject { Headers.new }
+
+      it "does not allow modification" do
+        expect{ subject['Content-Type'] = 'application/hippo' }.to raise_error /frozen/
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'pact/reification'
+require 'pact/consumer_contract/interaction'
+
+module Pact
+  module Consumer
+
+    describe Interaction do
+
+      let(:request) { {method: 'get', path: 'path'} }
+      let(:response) { {} }
+
+      describe "==" do
+        subject { InteractionFactory.create }
+        context "when other is the same" do
+          let(:other) { InteractionFactory.create }
+          it "returns true" do
+            expect(subject == other).to be true
+          end
+        end
+        context "when other is not the same" do
+          let(:other) { InteractionFactory.create(:request => {:path => '/a_different_path'}) }
+          it "returns false" do
+            expect(subject == other).to be false
+          end
+        end
+      end
+
+      describe "matches_criteria?" do
+        subject { InteractionFactory.create(:description => 'a request for food') }
+        context "by description" do
+          context "when the interaction matches" do
+            it "returns true" do
+              expect(subject.matches_criteria?(:description => /request.*food/)).to be true
+            end
+          end
+          context "when the interaction does not match" do
+            it "returns false" do
+              expect(subject.matches_criteria?(:description => /blah/)).to be false
+            end
+          end
+        end
+      end
+
+      describe "from_hash" do
+        context "when providerState has been used instead of provider_state" do
+
+          subject { Interaction.from_hash('response' => response, 'request' => request, 'providerState' => 'some state') }
+
+          it "recognises the provider state" do
+            expect(subject.provider_state).to eq 'some state'
+          end
+        end
+      end
+
+      describe "to JSON" do
+        let(:request) do
+          {
+            method: 'post',
+            path: '/foo',
+            body: Term.new(generate: 'waffle', matcher: /ffl/),
+            headers: { 'Content-Type' => 'application/json' },
+            query: '',
+          }
+        end
+
+        let(:response) do
+          { baz: /qux/, wiffle: Term.new(generate: 'wiffle', matcher: /iff/) }
+        end
+
+        let(:parsed_result) do
+          JSON.load(subject.to_json)
+        end
+
+        subject { Interaction.from_hash('response' => response, 'request' => request) }
+
+        it "contains the request" do
+          expect(parsed_result['request']).to eq({
+              'method' => 'post',
+              'path' => '/foo',
+              'headers' => {
+                'Content-Type' => 'application/json'
+              },
+              'body' => Term.new(generate: 'waffle', matcher: /ffl/),
+              'query' => ''
+            })
+        end
+
+        describe "response" do
+
+          it "serialises regexes" do
+            expect(parsed_result['response']['baz']).to eql /qux/
+          end
+
+          it "serialises terms" do
+            term = Term.new(generate:'wiffle', matcher: /iff/)
+            parsed_term = parsed_result['response']['wiffle']
+            expect(term.matcher).to eql parsed_term.matcher
+            expect(term.generate).to eql parsed_term.generate
+          end
+
+        end
+
+      end
+
+      describe "request_modifies_resource_without_checking_response_body?" do
+
+        let(:interaction) { Interaction.new(request: request, response: response)}
+
+        subject { interaction.request_modifies_resource_without_checking_response_body?}
+
+        context "when the request modifies the resource and the response allows any value in body" do
+          let(:request) { instance_double(Pact::Request::Expected, modifies_resource?: true) }
+          let(:response) { instance_double(Pact::Response, body_allows_any_value?: true) }
+
+          it "returns true" do
+            expect(subject).to be true
+          end
+        end
+
+        context "when the request modifies the resource and the response does not allow any value in body" do
+          let(:request) { instance_double(Pact::Request::Expected, modifies_resource?: true) }
+          let(:response) { instance_double(Pact::Response, body_allows_any_value?: false) }
+
+          it "returns false" do
+            expect(subject).to be false
+          end
+        end
+
+        context "when the request does not modifies the resource and the response does not allow any value in body" do
+          let(:request) { instance_double(Pact::Request::Expected, modifies_resource?: false) }
+          let(:response) { instance_double(Pact::Response, body_allows_any_value?: false) }
+
+          it "returns false" do
+            expect(subject).to be false
+          end
+        end
+
+        context "when the request does not modifies the resource and the response allows any value in body" do
+          let(:request) { instance_double(Pact::Request::Expected, modifies_resource?: false) }
+          let(:response) { instance_double(Pact::Response, body_allows_any_value?: true) }
+
+          it "returns false" do
+            expect(subject).to be false
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,329 @@
+require 'spec_helper'
+require 'pact/consumer_contract/request'
+require 'support/shared_examples_for_request'
+require 'pact/consumer/request'
+
+module Pact
+
+  describe Request::Expected do
+    it_behaves_like "a request"
+
+    let(:raw_request) do
+      {
+        'method' => 'get',
+        'path' => '/mallory'
+      }
+    end
+
+    describe "from_hash" do
+      context "when optional field are not defined" do
+        subject { described_class.from_hash(raw_request) }
+        it "sets their values to NullExpectation" do
+          expect(subject.body).to be_instance_of(Pact::NullExpectation)
+          expect(subject.query).to be_instance_of(Pact::NullExpectation)
+          expect(subject.headers).to be_instance_of(Pact::NullExpectation)
+        end
+      end
+    end
+
+    describe "as_json" do
+      subject { Request::Expected.new(:get, '/path', {:header => 'value'}, {:body => 'yeah'}, "query", {some: 'options'}) }
+      context "with options" do
+        it "does not include the options because they are a temporary hack and should leave no trace of themselves in the pact file" do
+          expect(subject.as_json.key?(:options)).to be false
+        end
+      end
+    end
+
+    describe "matching to actual requests" do
+
+      subject { Request::Expected.new(expected_method, expected_path, expected_headers, expected_body, expected_query, options) }
+      let(:options) { {} }
+
+      let(:expected_method) { 'get' }
+      let(:expected_path) { '/foo' }
+      let(:expected_headers) { Pact::NullExpectation.new }
+      let(:expected_body) { Pact::NullExpectation.new }
+      let(:expected_query) { '' }
+
+      let(:actual_request) { Consumer::Request::Actual.new(actual_method, actual_path, actual_headers, actual_body, actual_query) }
+
+      let(:actual_method) { 'get' }
+      let(:actual_path) { '/foo' }
+      let(:actual_headers) { {} }
+      let(:actual_body) { '' }
+      let(:actual_query) { '' }
+
+      it "matches identical requests" do
+        expect(subject.matches? actual_request).to be true
+      end
+
+      context "when the methods are the same but one is symbolized" do
+        let(:expected_method) { :get }
+        let(:actual_method) { 'get' }
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the methods are different" do
+        let(:expected_method) { 'get' }
+        let(:actual_method) { 'post' }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the methods are the same but different case" do
+        let(:expected_method) { 'get' }
+        let(:actual_method) { 'GET' }
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the paths are different" do
+        let(:expected_path) { '/foo' }
+        let(:actual_path) { '/bar' }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the paths vary only by a trailing slash" do
+        let(:expected_path) { '/foo' }
+        let(:actual_path) { '/foo/' }
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the expected body is nil and the actual body is empty" do
+        let(:expected_body) { nil }
+        let(:actual_body) { '' }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the expected body has no expectation and the actual body is empty" do
+        let(:expected_body) { Pact::NullExpectation.new }
+        let(:actual_body) { '' }
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the expected body is nested and the actual body is nil" do
+        let(:expected_body) do
+          {
+            a: 'a'
+          }
+        end
+
+        let(:actual_body) { nil }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the bodies are different" do
+        let(:expected_body) { 'foo' }
+        let(:actual_body) { 'bar' }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the expected body contains matching regexes" do
+        let(:expected_body) do
+          {
+            name: 'Bob',
+            customer_id: /CN.*/
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the expected body contains non-matching regexes" do
+        let(:expected_body) do
+          {
+            name: 'Bob',
+            customer_id: /foo/
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the expected body contains matching terms" do
+        let(:expected_body) do
+          {
+            name: 'Bob',
+            customer_id: Term.new(matcher: /CN.*/, generate: 'CN789')
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "matches" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the expected body contains non-matching terms" do
+        let(:expected_body) do
+          {
+            name: 'Bob',
+            customer_id: Term.new(matcher: /foo/, generate: 'fooool')
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            customer_id: 'CN1234'
+          }
+        end
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when the expected body contains non-matching arrays" do
+        let(:expected_body) do
+          {
+            name: 'Robert',
+            nicknames: ['Bob', 'Bobert']
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Bob',
+            nicknames: ['Bob']
+          }
+        end
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+      context "when the expected body contains non-matching hash where one field contains a substring of the other" do
+          let(:expected_body) do
+            {
+              name: 'Robert',
+            }
+          end
+
+          let(:actual_body) do
+            {
+              name: 'Rob'
+            }
+          end
+
+          it "does not match" do
+            expect(subject.matches? actual_request).to be false
+          end
+      end
+
+      context "when the expected body contains matching arrays" do
+        let(:expected_body) do
+          {
+            name: 'Robert',
+            nicknames: ['Bob', 'Bobert']
+          }
+        end
+
+        let(:actual_body) do
+          {
+            name: 'Robert',
+            nicknames: ['Bob', 'Bobert']
+          }
+        end
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when the queries are different" do
+        let(:expected_query) { 'foo' }
+        let(:actual_query) { 'bar' }
+
+        it "does not match" do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context 'when there is no query expectation' do
+        let(:expected_query) { Pact::NullExpectation.new }
+        let(:actual_query) { 'bar' }
+
+        it 'matches' do
+          expect(subject.matches? actual_request).to be true
+        end
+      end
+
+      context "when a string is expected, but a number is found" do
+        let(:actual_body) { { thing: 123} }
+        let(:expected_body) { { thing: "123" } }
+
+        it 'does not match' do
+          expect(subject.matches? actual_request).to be false
+        end
+      end
+
+      context "when unexpected keys are found in the body" do
+        let(:expected_body) { {a: 1} }
+        let(:actual_body) { {a: 1, b: 2} }
+        context "when allowing unexpected keys" do
+          let(:options) { {'allow_unexpected_keys_in_body' => true} } #From json, these will be strings
+          it "matches" do
+            expect(subject.matches? actual_request).to be true
+          end
+        end
+        context "when not allowing unexpected keys" do
+          let(:options) { {'allow_unexpected_keys_in_body' => false} }
+          it "does not match" do
+            expect(subject.matches? actual_request).to be false
+          end
+        end
+      end
+    end
+  end
+end