pact-support 1.9.0 → 1.15.0

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

@@ -1,142 +0,0 @@
-require 'spec_helper'
-require 'pact/consumer_contract'
-
-module Pact
-  describe ConsumerContract do
-    describe "from_uri" do
-      context "when the URL does not point to a valid pact" do
-        subject { ConsumerContract.from_uri('spec/fixtures/not-a-pact.json') }
-
-        it "raises a helpful error" do
-          expect { subject }.to raise_error UnrecognizePactFormatError, /Please check that spec/
-        end
-      end
-    end
-
-    describe "from_hash" do
-      context "when the hash is not a valid pact" do
-        subject { ConsumerContract.from_hash({'foo' => 'bar'}) }
-
-        it "raises a helpful error" do
-          expect { subject }.to raise_error UnrecognizePactFormatError, 'This document does not use a recognised Pact format: {"foo"=>"bar"}'
-        end
-      end
-    end
-
-    describe ".from_json" do
-
-      let(:loaded_pact) { ConsumerContract.from_json(string) }
-
-      context "with an HTTP contract" do
-        context "when the top level object is a ConsumerContract" do
-          let(:string) { '{"interactions":[{"request": {"path":"/path", "method" : "get"}, "response": {"status" : 200}}], "consumer": {"name" : "Bob"} , "provider": {"name" : "Mary"} }' }
-
-          it "should create a Pact" do
-            expect(loaded_pact).to be_instance_of ConsumerContract
-          end
-
-          it "should have interactions" do
-            expect(loaded_pact.interactions).to be_instance_of Array
-          end
-
-          it "should have a consumer" do
-            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-          end
-
-          it "should have a provider" do
-            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-          end
-        end
-
-        context "with old 'producer' key" do
-          let(:string) { File.read('./spec/support/a_consumer-a_producer.json')}
-          it "should create a Pact" do
-            expect(loaded_pact).to be_instance_of ConsumerContract
-          end
-
-          it "should have interactions" do
-            expect(loaded_pact.interactions).to be_instance_of Array
-          end
-
-          it "should have a consumer" do
-            expect(loaded_pact.consumer).to be_instance_of Pact::ServiceConsumer
-          end
-
-          it "should have a provider" do
-            expect(loaded_pact.provider).to be_instance_of Pact::ServiceProvider
-            expect(loaded_pact.provider.name).to eq "an old producer"
-          end
-
-          it "should have a provider_state" do
-            expect(loaded_pact.interactions.first.provider_state).to eq 'state one'
-          end
-        end
-      end
-    end
-
-    describe "find_interactions" do
-      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
-      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
-      let(:interaction) { double('Pact::Interaction') }
-      subject { ConsumerContract.new(:interactions => [interaction], :consumer => consumer, :provider => provider) }
-      let(:criteria) { {:description => /blah/} }
-      before do
-        expect(interaction).to receive(:matches_criteria?).with(criteria).and_return(matches)
-      end
-      context "by description" do
-        context "when no interactions are found" do
-          let(:matches) { false }
-          it "returns an empty array" do
-            expect(subject.find_interactions(criteria)).to eql []
-          end
-        end
-        context "when interactions are found" do
-          let(:matches) { true }
-          it "returns an array of the matching interactions" do
-            expect(subject.find_interactions(criteria)).to eql [interaction]
-          end
-        end
-      end
-    end
-
-    describe "find_interaction" do
-      let(:consumer) { double('Pact::ServiceConsumer', :name => 'Consumer')}
-      let(:provider) { double('Pact::ServiceProvider', :name => 'Provider')}
-      let(:interaction1) { double('Pact::Interaction') }
-      let(:interaction2) { double('Pact::Interaction') }
-      let(:criteria) { {:description => /blah/} }
-
-      before do
-        expect(interaction1).to receive(:matches_criteria?).with(criteria).and_return(matches1)
-        expect(interaction2).to receive(:matches_criteria?).with(criteria).and_return(matches2)
-      end
-
-      subject { ConsumerContract.new(:interactions => [interaction1, interaction2], :consumer => consumer, :provider => provider) }
-      context "by description" do
-        context "when a match is found" do
-          let(:matches1) { true }
-          let(:matches2) { false }
-
-          it "returns the interaction" do
-            expect(subject.find_interaction criteria).to eql interaction1
-          end
-        end
-        context "when more than one match is found" do
-          let(:matches1) { true }
-          let(:matches2) { true }
-          it "raises an error" do
-            expect{ subject.find_interaction(criteria) }.to raise_error "Found more than 1 interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
-          end
-        end
-        context "when a match is not found" do
-          let(:matches1) { false }
-          let(:matches2) { false }
-          it "raises an error" do
-            expect{ subject.find_interaction(criteria) }.to raise_error "Could not find interaction matching {:description=>/blah/} in pact file between Consumer and Provider."
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'pact/consumer_contract/file_name'
-
-module Pact
-  describe FileName do
-    describe "file_path" do
-
-      subject { FileName.file_path 'foo', 'bar', 'tmp/pacts' }
-      it { is_expected.to eq 'tmp/pacts/foo-bar.json' }
-
-      context "when unique is true" do
-        subject { FileName.file_path 'foo', 'bar', 'tmp/pacts', unique: true }
-        it { is_expected.to match %r{tmp/pacts/foo-bar-\d+.json} }
-      end
-
-      context "when the path includes backslashes" do
-        subject { FileName.file_path 'foo', 'bar', 'c:\tmp\pacts' }
-
-        it "changes them to forward slashes" do
-          expect(subject).to eq "c:/tmp/pacts/foo-bar.json"
-        end
-      end
-    end
-  end
-end

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/http_consumer_contract_parser_spec.rb

@@ -1,25 +0,0 @@
-require 'pact/consumer_contract/http_consumer_contract_parser'
-
-module Pact
-  describe HttpConsumerContractParser do
-    describe "#call integration test" do
-      subject { HttpConsumerContractParser.new.call(pact_hash) }
-
-      context "with a v2 pact" do
-        let(:pact_hash) { load_json_fixture('pact-http-v2.json') }
-
-        it "correctly parses the pact" do
-          expect(subject.interactions.first.response.headers['Content-Type']).to be_a(Pact::Term)
-        end
-      end
-
-      context "with a v3 pact" do
-        let(:pact_hash) { load_json_fixture('pact-http-v3.json') }
-
-        it "correctly parses the pact" do
-          expect(subject.interactions.first.response.body['foo']).to be_a(Pact::SomethingLike)
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'pact/consumer_contract/interaction_parser'
-
-module Pact
-  describe InteractionParser do
-    describe ".call" do
-
-      let(:request) { {method: 'get', path: 'path'} }
-      let(:response) { {} }
-
-      context "when providerState has been used instead of provider_state" do
-
-        subject { InteractionParser.call('response' => response, 'request' => request, 'providerState' => 'some state') }
-
-        it "recognises the provider state" do
-          expect(subject.provider_state).to eq 'some state'
-        end
-      end
-
-      context "when there are matching rules" do
-        let(:hash) { load_json_fixture 'interaction-with-matching-rules.json' }
-
-        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("2")) }
-
-        it "merges the rules with the example for the request" do
-          expect(subject.request.body['name']).to be_instance_of(Pact::Term)
-        end
-
-        it "merges the rules with the example for the response" do
-          expect(subject.response.body['_links']['self']['href']).to be_instance_of(Pact::Term)
-        end
-      end
-
-      context "when the request body is a String" do
-        let(:hash) { { 'request' => request, 'response' => response } }
-        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
-
-        let(:request) { { 'method' => 'get', 'path' => 'path' , 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
-
-        it "returns an interaction with an StringWithMatchingRules in the request" do
-          expect(subject.request.body).to be_a(Pact::StringWithMatchingRules)
-          expect(subject.request.body).to eq "<xml></xml>"
-          expect(subject.request.body.matching_rules).to eq "foo" => "bar"
-          expect(subject.request.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
-        end
-      end
-
-      context "when the response body is a String" do
-        let(:hash) { { 'request' => request, 'response' => response } }
-        subject { InteractionParser.call(hash, pact_specification_version: Pact::SpecificationVersion.new("3")) }
-
-        let(:response) { { 'status' => '200', 'body' => "<xml></xml>", 'matchingRules' => {"body" => {"foo" => "bar"} } } }
-
-        it "returns an interaction with an StringWithMatchingRules in the response" do
-          expect(subject.response.body).to be_a(Pact::StringWithMatchingRules)
-          expect(subject.response.body).to eq "<xml></xml>"
-          expect(subject.response.body.matching_rules).to eq "foo" => "bar"
-          expect(subject.response.body.pact_specification_version).to eq Pact::SpecificationVersion.new("3")
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +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
-        context "with a SomethingLike" do
-          let(:response)       { {body: {age: SomethingLike.new(20)}  } }
-          let(:other_response) { {body: {age: SomethingLike.new(20)}  } }
-          let(:other)          { InteractionFactory.create(response: other_response) }
-          subject              { InteractionFactory.create response: response }
-
-          it "returns true" do
-            expect(subject == other).to be true
-          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 "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
-
-      describe "#validate!" do
-        let(:interaction) { InteractionFactory.create }
-
-        context "when it lacks necessary data" do
-          before { interaction.description = nil }
-
-          it "raises Pact::InvalidInteractionError" do
-            expect { interaction.validate! }.to(raise_error(Pact::InvalidInteractionError) do |e|
-              expect(e.message).to include("description")
-              expect(e.message).not_to include("request")
-            end)
-          end
-        end
-
-        context "when it has all necessary data" do
-          it "does not raise any errors" do
-            expect { interaction.validate! }.not_to raise_error
-          end
-        end
-      end
-    end
-  end
-end