pact 1.3.3 → 1.4.0

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

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

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

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

@@ -1,329 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract/request'
-require 'pact/consumer/request'
-require 'support/shared_examples_for_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

data/spec/lib/pact/doc/generator_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require 'pact/doc/generator'
-require 'fileutils'
-
-module Pact
-  module Doc
-    describe Generator do
-
-      let(:doc_dir) { './tmp/doc' }
-      let(:pact_dir) { './tmp/pacts' }
-      let(:file_name) { "Some Consumer - Some Provider#{file_extension}" }
-      let(:consumer_contract_renderer) { double("ConsumerContractRenderer", :call => doc_content) }
-      let(:doc_content) { "doc_content" }
-      let(:index_content) { "index_content" }
-      let(:expected_doc_path) { "#{doc_dir}/#{doc_type}/#{file_name}" }
-      let(:expected_index_path) { "#{doc_dir}/#{doc_type}/#{index_name}#{file_extension}" }
-      let(:doc_type) { 'markdown' }
-      let(:file_extension) { ".md" }
-      let(:actual_file_contents) { File.read(expected_doc_path) }
-      let(:actual_index_contents) { File.read(expected_index_path)}
-      let(:index_renderer) { double("IndexRenderer", :call => index_content)}
-      let(:index_name) { 'README' }
-      let(:after_hook) { double("hook", :call => nil)}
-
-      before do
-        FileUtils.rm_rf doc_dir
-        FileUtils.rm_rf pact_dir
-        FileUtils.mkdir_p doc_dir
-        FileUtils.mkdir_p pact_dir
-        FileUtils.cp './spec/support/markdown_pact.json', pact_dir
-      end
-
-      let(:options) { { consumer_contract_renderer: consumer_contract_renderer, doc_type: doc_type, file_extension: file_extension, index_renderer: index_renderer, index_name: index_name } }
-
-      subject { Generator.new(pact_dir, doc_dir, options) }
-
-      context "when there are existing files" do
-        let(:existing_doc_file_path) { File.join(doc_dir, doc_type, "leftover") }
-
-        before do
-          FileUtils.mkdir_p File.dirname(existing_doc_file_path)
-          FileUtils.touch existing_doc_file_path
-        end
-
-        it "clears the existing files" do
-          expect(File.exist?(existing_doc_file_path)).to be true
-          subject.call
-          expect(File.exist?(existing_doc_file_path)).to be false
-        end
-      end
-
-
-      it "creates an index" do
-        expect(index_renderer).to receive(:call).with("Some Consumer", {"Some Provider"=>"Some Consumer - Some Provider.md"})
-        subject.call
-        expect(actual_index_contents).to eq(index_content)
-      end
-
-      it "creates documentation" do
-        subject.call
-        expect(actual_file_contents).to eq(doc_content)
-      end
-
-      context "with an after hook specified" do
-
-        subject { Generator.new(pact_dir, doc_dir, options.merge(:after => after_hook)) }
-
-        it "executes the hook" do
-          expect(after_hook).to receive(:call).with(pact_dir, "#{doc_dir}/#{doc_type}", instance_of(Array))
-          subject.call
-        end
-
-        it "passes in the consumer_contracts" do
-          expect(after_hook).to receive(:call) do | _, _, consumer_contracts |
-            expect(consumer_contracts.first).to be_instance_of(Pact::ConsumerContract)
-          end
-          subject.call
-        end
-
-      end
-
-    end
-  end
-end