pact-support 1.11.0 → 1.12.0

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples_for_request'
-require 'pact/consumer/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_contract/active_support_support_spec.rb

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

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