pact-support 1.11.0 → 1.12.0

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

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

@@ -1,54 +0,0 @@
-require 'pact/consumer_contract/interaction_v2_parser'
-
-module Pact
-  describe InteractionV2Parser do
-    describe ".call" do
-      let(:interaction_hash) do
-        {
-          "description" => "description",
-          "request" => { "method" => "GET", "path" => "/" },
-          "response" => { "status" => 200 },
-          "providerState" => "foo"
-        }
-      end
-
-      let(:options) do
-        {
-          pact_specification_version: Pact::SpecificationVersion.new("3.0")
-        }
-      end
-
-      subject { InteractionV2Parser.call(interaction_hash, options) }
-
-      describe "provider_states" do
-        it "returns an array of provider states with size 1" do
-          expect(subject.provider_states.size).to eq 1
-        end
-
-        it "sets the name of the provider state to the string provided" do
-          expect(subject.provider_states.first.name)
-        end
-
-        it "sets the params to an empty hash" do
-          expect(subject.provider_states.first.params).to eq({})
-        end
-
-        context "when the providerState is nil" do
-          before do
-            interaction_hash["providerState"] = nil
-          end
-
-          it "returns an empty list" do
-            expect(subject.provider_states).to be_empty
-          end
-        end
-      end
-
-      describe "provider_state" do
-        it "sets the name from the hash" do
-          expect(subject.provider_state).to eq "foo"
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'pact/consumer_contract/interaction_v3_parser'
-
-module Pact
-  describe InteractionV3Parser do
-    describe ".call" do
-
-      let(:interaction_hash) do
-        {
-          "description" => "description",
-          "request" => { "method" => "GET", "path" => "/" },
-          "response" => { "status" => 200 },
-          "providerStates" => [{
-            "name" => "foo",
-            "params" => {"a" => "b"}
-          }]
-        }
-      end
-
-      let(:options) do
-        {
-          pact_specification_version: Pact::SpecificationVersion.new("3.0")
-        }
-      end
-
-      subject { InteractionV3Parser.call(interaction_hash, options) }
-
-      describe "provider_states" do
-        it "parses the array of provider states" do
-          expect(subject.provider_states.size).to eq 1
-        end
-
-        it "parses the name of each" do
-          expect(subject.provider_states.first.name)
-        end
-
-        it "parses the params of each" do
-          expect(subject.provider_states.first.params).to eq "a" => "b"
-        end
-      end
-
-      describe "provider_state" do
-        it "sets the provider_state string to the name of the first providerState for backwards compatibility while we implement v3" do
-          expect(subject.provider_state).to eq "foo"
-        end
-      end
-    end
-  end
-end

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

@@ -1,204 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-require 'pact/consumer_contract/pact_file'
-require 'base64' # XXX: https://github.com/bblimke/webmock/pull/611
-
-module Pact
-  describe PactFile do
-    describe 'render_pact' do
-      let(:uri_without_userinfo) { 'http://pactbroker.com'}
-      let(:pact_content) { 'api contract'}
-
-      describe 'from a local file URI' do
-        let(:temp_file) { Tempfile.new('local-pact-file') }
-        let(:file_uri) { temp_file.path }
-        let(:local_pact_content) { 'local pact content' }
-        before do
-          File.write file_uri, local_pact_content
-        end
-        after do
-          temp_file.unlink
-        end
-
-        it 'reads from the local file system' do
-          expect(PactFile.render_pact(file_uri, {})).to eq(local_pact_content)
-        end
-      end
-
-      describe 'with backslashes to a local path' do
-        let(:windows_path) { 'spec\support\a_consumer-a_provider.json' }
-        let(:unix_path) { 'spec/support/a_consumer-a_provider.json' }
-
-        it 'transforms them to forward slashes' do
-          expect(PactFile.read(windows_path)).to eq PactFile.read(unix_path)
-        end
-      end
-
-      context 'without basic authentication' do
-        before do
-          stub_request(:get, uri_without_userinfo).to_return(body: pact_content)
-        end
-
-        it 'should open uri to get pact file content' do
-          expect(PactFile.render_pact(uri_without_userinfo, {})).to eq(pact_content)
-        end
-      end
-
-      context 'basic authentication' do
-        let(:username) { 'brokeruser'}
-        let(:password) { 'brokerpassword'}
-        let(:options) do
-          { username: username, password: password }
-        end
-        before do
-          stub_request(:get, uri_without_userinfo).with(basic_auth: [username, password]).to_return(body: pact_content)
-        end
-
-        context 'when userinfo is specified in the option' do
-          it 'should open uri to get pact file content with userinfo in the options' do
-            expect(PactFile.render_pact(uri_without_userinfo, options)).to eq(pact_content)
-          end
-
-          let(:uri_with_userinfo) { 'http://dummyuser:dummyps@pactbroker.com'}
-
-          it 'should use userinfo in options which overwrites userinfo in url' do
-            expect(PactFile.render_pact(uri_with_userinfo, options)).to eq(pact_content)
-          end
-        end
-
-        context 'when user info is specified in url' do
-          let(:uri_with_userinfo) { "http://#{username}:#{password}@pactbroker.com"}
-
-          it 'should open uri to get pact file content with userinfo in the uri' do
-            expect(PactFile.render_pact(uri_with_userinfo, {})).to eq(pact_content)
-          end
-        end
-      end
-
-      context 'with a token' do
-        let(:token) { 'askfjlksjf'}
-        let(:options) { { token: token } }
-
-        let!(:request) do
-          stub_request(:get, uri_without_userinfo).with(headers: {'Authorization' => 'Bearer askfjlksjf'}).to_return(body: pact_content)
-        end
-
-        it 'sets the Bearer Authorization header' do
-          PactFile.render_pact(uri_without_userinfo, options)
-          expect(request).to have_been_made
-        end
-
-      end
-
-      describe 'retry feature' do
-        before { allow(PactFile).to receive(:delay_retry).with(kind_of(Integer)) }
-
-        def render_pact(options = {})
-          PactFile.render_pact(uri_without_userinfo, options)
-        end
-
-        context 'with client error' do
-          before { stub_request(:get, uri_without_userinfo).to_return(status: 400) }
-
-          it 'raises client error without retrying' do
-            expect(PactFile).not_to receive(:delay_retry)
-            expect { render_pact }.to raise_error(PactFile::HttpError, /status=400/)
-          end
-        end
-
-        context 'with single server error' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_return(status: 500).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect(render_pact).to eq(pact_content)
-          end
-        end
-
-        context 'with continuous server errors' do
-          before { stub_request(:get, uri_without_userinfo).to_return(status: 500) }
-
-          it 'retries but failed by retry limit' do
-            expect { render_pact }.to raise_error(PactFile::HttpError, /status=500/)
-          end
-        end
-
-        context 'with single open timeout' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_raise(Net::OpenTimeout).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect(render_pact).to eq(pact_content)
-          end
-        end
-
-        context 'with continuous open timeouts' do
-          before { stub_request(:get, uri_without_userinfo).to_raise(Net::OpenTimeout) }
-
-          it 'retries but failed by retry limit' do
-            expect { render_pact }.to raise_error(Net::OpenTimeout)
-          end
-        end
-
-        context 'with single read timeout' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_raise(Net::ReadTimeout).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect(render_pact).to eq(pact_content)
-          end
-        end
-
-        context 'with continuous read timeout' do
-          before { stub_request(:get, uri_without_userinfo).to_raise(Net::ReadTimeout) }
-
-          it 'retries but failed by retry limit' do
-            expect { render_pact }.to raise_error(Net::ReadTimeout)
-          end
-        end
-
-        context 'with retry_limit option and server error' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_return(status: 500).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect { render_pact(retry_limit: 0) }.to raise_error(PactFile::HttpError, /status=500/)
-          end
-        end
-
-        context 'with retry_limit option and open timeout error' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_raise(Net::OpenTimeout).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect { render_pact(retry_limit: 0) }.to raise_error(Net::OpenTimeout)
-          end
-        end
-
-        context 'with retry_limit option which is greater than default retry limit' do
-          before do
-            stub_request(:get, uri_without_userinfo).to_return(status: 500).
-              then.to_return(status: 500).
-              then.to_return(status: 500).
-              then.to_return(status: 500).
-              then.to_return(status: 200, body: pact_content)
-          end
-
-          it 'retries and succeeds' do
-            expect(render_pact(retry_limit: 4)).to eq(pact_content)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,154 +0,0 @@
-require 'pact/consumer_contract/query_hash'
-require 'pact/consumer_contract/query_string'
-
-module Pact
-  describe QueryHash do
-
-    subject { QueryHash.new(query) }
-
-    let(:query) { { param: 'thing' } }
-    let(:query_with_array) { { param: ['thing'] } }
-
-    describe "difference" do
-      context "when the other is the same" do
-
-        let(:other) { QueryString.new('param=thing') }
-
-        it 'returns an empty diff' do
-          expect(subject.difference(other)).to be_empty
-        end
-      end
-
-      context "when the other is different" do
-        let(:other) { QueryString.new('param=thing1') }
-
-        it 'returns the diff' do
-          expect(subject.difference(other)).to_not be_empty
-        end
-      end
-
-      context "when the other has an extra param" do
-        let(:other) { QueryString.new('param=thing&param2=blah') }
-
-        it 'returns the diff' do
-          expect(subject.difference(other)).to_not be_empty
-        end
-      end
-
-      context "with nested query" do
-        let(:query) { { param: { a: { aa: '11', bb: '22' }, b: '2' } } }
-
-        context "when the other is same" do
-          let(:other) { QueryString.new('param[b]=2&param[a][aa]=11&param[a][bb]=22') }
-
-          it 'returns an empty diff' do
-            expect(subject.difference(other)).to be_empty
-          end
-        end
-
-        context "when the other has extra param" do
-          let(:other) { QueryString.new('param[b]=2&param[c]=1') }
-
-          it 'returns the diff' do
-            expect(subject.difference(other)).not_to be_empty
-            expect(subject.difference(other).keys).to contain_exactly(:"param[a][aa]", :"param[a][bb]", :"param[c]")
-          end
-        end
-
-        context "when the other has different value with value difference" do
-          let(:other) { QueryString.new('param[b]=2&param[a][aa]=00&param[a][bb]=22') }
-
-          it 'returns the diff' do
-            expect(subject.difference(other)).not_to be_empty
-            expect(subject.difference(other).keys).to contain_exactly(:"param[a][aa]")
-          end
-        end
-
-        context "when the other has different value without structural difference" do
-          let(:other) { QueryString.new('param[b]=2&param[a]=11') }
-
-          it 'returns the diff' do
-            expect(subject.difference(other)).not_to be_empty
-            expect(subject.difference(other).keys).to contain_exactly(:"param[a]", :"param[a][aa]", :"param[a][bb]")
-          end
-        end
-
-        context "when there is an ArrayLike" do
-          let(:query) { { param: Pact.each_like("1") } }
-          let(:other) { QueryString.new('param=1&param=2') }
-
-          it 'returns an empty diff' do
-            expect(subject.difference(other)).to be_empty
-          end
-        end
-      end
-    end
-
-    describe "#as_json" do
-      it "returns the query as a Hash" do
-        expect(subject.as_json).to eq query_with_array
-      end
-    end
-
-    describe "#to_json" do
-      context "when the query contains an ArrayLike" do
-        let(:query) { { foo: Pact.each_like("1"), bar: "2" } }
-        let(:expected_json) do
-          {
-            foo: Pact.each_like("1"),
-            bar: ["2"]
-          }.to_json
-        end
-
-        it "serialises the ArrayLike without wrapping an array around it" do
-          expect(subject.to_json).to eq expected_json
-        end
-      end
-
-      context "when the query contains a Pact::Term" do
-        let(:term) { Pact::Term.new(generate: "thing", matcher: /th/) }
-        let(:query) { { param: term } }
-        let(:query_with_array) { { param: [term] } }
-
-        it "serialises the Pact::Term as Ruby specific JSON" do
-          expect(subject.to_json).to eq query_with_array.to_json
-        end
-      end
-    end
-
-    describe "#==" do
-      context "when the query is not an identical match" do
-        let(:other) { QueryHash.new(param: 'other thing')}
-        it "returns false" do
-          expect(subject == other).to be false
-        end
-      end
-
-      context "when the query is an identical match" do
-        let(:other) { QueryHash.new(query) }
-        it "returns true" do
-          expect(subject == other).to be true
-        end
-      end
-    end
-
-    describe "#to_s" do
-      it "returns the query Hash as a string" do
-        expect(subject.to_s).to eq query_with_array.to_s
-      end
-    end
-
-    describe "#as_json" do
-      it "returns the query Hash" do
-        expect(subject.as_json).to eq query_with_array
-      end
-    end
-
-    describe "#to_json" do
-      it "returns the query Hash as JSON" do
-        expect(subject.to_json).to eq query_with_array.to_json
-      end
-    end
-
-  end
-end