pact-support 1.9.0 → 1.15.0

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