pact_broker-client 1.75.3 → 1.75.4

data/spec/lib/pact_broker/client/hal/http_client_spec.rb

@@ -1,238 +0,0 @@
-require 'pact_broker/client/hal/http_client'
-require "faraday"
-require "faraday/retry"
-
-module PactBroker::Client
-  module Hal
-    describe HttpClient do
-      subject { HttpClient.new(username: 'foo', password: 'bar') }
-
-      describe "get" do
-        before do
-          allow(subject).to receive(:until_truthy_or_max_times) { |&block| block.call }
-        end
-
-        let!(:request) do
-          stub_request(:get, "http://example.org/").
-            with(  headers: {
-              'Accept'=>'application/hal+json',
-              'Authorization'=>'Basic Zm9vOmJhcg=='
-              }).
-            to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
-        end
-
-        let(:response_body) { {some: 'json'}.to_json }
-        let(:do_get) { subject.get('http://example.org') }
-
-        it "performs a get request" do
-          do_get
-          expect(request).to have_been_made
-        end
-
-        context "with get params" do
-          let!(:request) do
-            stub_request(:get, "http://example.org/?foo=hello+world&bar=wiffle").
-              to_return(status: 200)
-          end
-
-          let(:do_get) { subject.get('http://example.org', { 'foo' => 'hello world', 'bar' => 'wiffle' }) }
-
-          it "correctly converts and encodes get params" do
-             do_get
-             expect(request).to have_been_made
-          end
-        end
-
-        it "retries on failure" do
-          expect(subject).to receive(:until_truthy_or_max_times)
-          do_get
-        end
-
-        it "returns a response" do
-          expect(do_get.body).to eq({"some" => "json"})
-        end
-
-      end
-
-      describe "post" do
-        before do
-          allow(subject).to receive(:until_truthy_or_max_times) { |&block| block.call }
-        end
-
-        let!(:request) do
-          stub_request(:post, "http://example.org/").
-            with(  headers: {
-              'Accept'=>'application/hal+json',
-              'Authorization'=>'Basic Zm9vOmJhcg==',
-              'Content-Type'=>'application/json'
-              },
-              body: request_body).
-            to_return(status: 200, body: response_body, headers: {'Content-Type' => 'application/json'})
-        end
-
-        let(:request_body) { {some: 'data'}.to_json }
-        let(:response_body) { {some: 'json'}.to_json }
-
-        let(:do_post) { subject.post('http://example.org/', request_body) }
-
-        it "performs a post request" do
-          do_post
-          expect(request).to have_been_made
-        end
-
-        it "calls Retry.until_truthy_or_max_times" do
-          expect(subject).to receive(:until_truthy_or_max_times)
-          do_post
-        end
-
-        it "returns a response" do
-          expect(do_post.body).to eq({"some" => "json"})
-        end
-
-        context "with custom headers" do
-          let!(:request) do
-            stub_request(:post, "http://example.org/").
-              with(  headers: {
-                'Accept'=>'foo'
-                }).
-              to_return(status: 200)
-          end
-
-          let(:do_post) { subject.post('http://example.org/', request_body, {"Accept" => "foo"} ) }
-
-          it "performs a post request with custom headers" do
-            do_post
-            expect(request).to have_been_made
-          end
-        end
-      end
-
-      describe "integration test" do
-        before do
-          allow(subject).to receive(:sleep)
-        end
-
-        let(:do_get) { subject.get('http://example.org') }
-
-        context "with a 50x error is returned less than the max number of tries" do
-          let!(:request) do
-            stub_request(:get, "http://example.org").
-              to_return({ status: 500 }, { status: 502 }, { status: 503 }, { status: 200 })
-          end
-
-          it "retries" do
-            expect(do_get.status).to eq 200
-          end
-        end
-
-        context "with a 50x error is returned more than the max number of tries" do
-          let!(:request) do
-            stub_request(:get, "http://example.org").
-              to_return({ status: 500 }, { status: 501 }, { status: 502 }, { status: 503 }, { status: 504 })
-          end
-
-          it "retries and returns the last 50x response" do
-            expect(do_get.status).to eq 504
-          end
-        end
-
-        context "when exceptions are raised" do
-          before do
-            allow($stderr).to receive(:puts)
-          end
-
-          let!(:request) do
-            stub_request(:get, "http://example.org")
-              .to_raise(Errno::ECONNREFUSED)
-          end
-
-          it "logs the error" do
-            expect($stderr).to receive(:puts).with(/Errno::ECONNREFUSED/)
-            begin
-              do_get
-            rescue Errno::ECONNREFUSED
-            end
-          end
-
-          it "retries and raises the last exception" do
-            expect { do_get }.to raise_error(Errno::ECONNREFUSED)
-          end
-        end
-      end
-
-      describe "x509 certificate" do
-        FAKE_SERVER_URL = 'https://localhost:4444'
-        X509_CERT_FILE_PATH = './spec/fixtures/certificates/client_cert.pem'
-        X509_KEY_FILE_PATH = './spec/fixtures/certificates/key.pem'
-        UNSIGNED_X509_CERT_FILE_PATH = './spec/fixtures/certificates/unsigned_cert.pem'
-        UNSIGNED_X509_KEY_FILE_PATH = './spec/fixtures/certificates/unsigned_key.pem'
-
-        def wait_for_server_to_start
-          Faraday.new(
-            url: FAKE_SERVER_URL,
-            ssl: {
-              verify: false,
-              client_cert: OpenSSL::X509::Certificate.new(File.read(X509_CERT_FILE_PATH)),
-              client_key: OpenSSL::PKey::RSA.new(File.read(X509_KEY_FILE_PATH))
-            }
-          ) do |builder|
-            builder.request :retry, max: 20, interval: 0.5, exceptions: [StandardError]
-            builder.adapter :net_http
-          end.get
-        end
-
-        let(:do_get) { subject.get(FAKE_SERVER_URL) }
-
-        before(:all) do
-          @pipe = IO.popen("bundle exec ruby ./spec/support/ssl_server.rb")
-          ENV['SSL_CERT_FILE'] = "./spec/fixtures/certificates/ca_cert.pem"
-
-          wait_for_server_to_start()
-        end
-
-        context "with valid x509 client certificates" do
-          before do
-            ENV['X509_CLIENT_CERT_FILE'] = X509_CERT_FILE_PATH
-            ENV['X509_CLIENT_KEY_FILE'] = X509_KEY_FILE_PATH
-          end
-
-          it "succeeds" do
-            expect(do_get.status).to eq 200
-          end
-        end
-
-        context "when invalid x509 certificates are set" do
-          before do
-            ENV['X509_CLIENT_CERT_FILE'] = UNSIGNED_X509_CERT_FILE_PATH
-            ENV['X509_CLIENT_KEY_FILE'] = UNSIGNED_X509_KEY_FILE_PATH
-          end
-
-          it "fails raising SSL error" do
-            expect { do_get }
-              .to raise_error { |error|
-                expect([OpenSSL::SSL::SSLError, Errno::ECONNRESET]).to include(error.class)
-              }
-          end
-        end
-
-        context "when no x509 certificates are set" do
-          before do
-            ENV['X509_CLIENT_CERT_FILE'] = nil
-            ENV['X509_CLIENT_KEY_FILE'] = nil
-          end
-
-          it "fails raising SSL error" do
-            expect { do_get }
-              .to raise_error { |error|
-                expect([OpenSSL::SSL::SSLError, Errno::ECONNRESET]).to include(error.class)
-              }
-          end
-        end
-
-        after(:all) do
-          Process.kill "KILL", @pipe.pid
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/hal/link_spec.rb

@@ -1,127 +0,0 @@
-require 'pact_broker/client/hal/link'
-require 'pact_broker/client/hal/entity'
-require 'pact_broker/client/hal/http_client'
-
-module PactBroker::Client
-  module Hal
-    describe Link do
-      before do
-        allow(response).to receive(:header).with("Content-Type").and_return(content_type)
-      end
-
-      let(:http_client) do
-        instance_double('PactBroker::Client::Hal::HttpClient', post: response)
-      end
-
-      let(:response) do
-        instance_double('PactBroker::Client::Hal::HttpClient::Response', success?: success, body: response_body, raw_body: response_body.to_json)
-      end
-
-      let(:success) { true }
-
-      let(:entity) do
-        instance_double('PactBroker::Client::Hal::Entity')
-      end
-
-      let(:attrs) do
-        {
-          'href' => 'http://foo/{bar}',
-          'title' => 'title',
-          method: :post
-        }
-      end
-
-      let(:response_body) do
-        {
-          'some' => 'body'
-        }
-      end
-
-      let(:content_type) { nil }
-
-      subject { Link.new(attrs, http_client) }
-
-      before do
-        allow(PactBroker::Client::Hal::Entity).to receive(:new).and_return(entity)
-      end
-
-      describe "#run" do
-        let(:do_run) { subject.run('foo' => 'bar') }
-
-        it "executes the configured http request" do
-          expect(http_client).to receive(:post)
-          do_run
-        end
-
-        it "creates an Entity" do
-          expect(PactBroker::Client::Hal::Entity).to receive(:new).with("http://foo/{bar}", response_body, http_client, response)
-          do_run
-        end
-
-        it "returns an Entity" do
-          expect(do_run).to eq entity
-        end
-
-        context "when an error response is returned" do
-          before do
-            allow(PactBroker::Client::Hal::ErrorEntity).to receive(:new).and_return(entity)
-          end
-
-          let(:success) { false }
-
-          it "creates an ErrorEntity" do
-            expect(PactBroker::Client::Hal::ErrorEntity).to receive(:new).with("http://foo/{bar}", response_body.to_json, http_client, response)
-            do_run
-          end
-
-          context "when a JSON error is returned" do
-            let(:content_type) { "application/json" }
-
-            it "parses the response body" do
-              expect(PactBroker::Client::Hal::ErrorEntity).to receive(:new).with("http://foo/{bar}", response_body, http_client, response)
-              do_run
-            end
-          end
-        end
-      end
-
-      describe "#get" do
-        before do
-          allow(http_client).to receive(:get).and_return(response)
-        end
-
-        let(:do_get) { subject.get({ 'foo' => 'bar' }) }
-
-        it "executes an HTTP Get request" do
-          expect(http_client).to receive(:get).with('http://foo/{bar}', { 'foo' => 'bar' }, {})
-          do_get
-        end
-      end
-
-      describe "#post" do
-        let(:do_post) { subject.post({ 'foo' => 'bar' }, { 'Accept' => 'foo' }) }
-
-        context "with custom headers" do
-          it "executes an HTTP Post request with the custom headers" do
-            expect(http_client).to receive(:post).with('http://foo/{bar}', '{"foo":"bar"}', { 'Accept' => 'foo' })
-            do_post
-          end
-        end
-      end
-
-      describe "#expand" do
-        it "returns a duplicate Link with the expanded href" do
-          expect(subject.expand(bar: 'wiffle').href).to eq "http://foo/wiffle"
-        end
-
-        it "returns a duplicate Link with the expanded href with URL escaping" do
-          expect(subject.expand(bar: 'wiffle meep').href).to eq "http://foo/wiffle%20meep"
-        end
-
-        it "returns a duplicate Link with the expanded href with URL escaping for forward slashes" do
-          expect(subject.expand(bar: 'wiffle/meep').href).to eq "http://foo/wiffle%2Fmeep"
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/matrix/abbreviate_version_number_spec.rb

@@ -1,42 +0,0 @@
-
-require 'pact_broker/client/matrix/abbreviate_version_number'
-
-module PactBroker
-  module Client
-    describe Matrix::AbbreviateVersionNumber do
-      describe '.call' do
-        subject(:result) { described_class.call(version) }
-
-        context 'when version is nil' do
-          let(:version) { nil }
-          it { is_expected.to be_nil }
-        end
-
-        context 'when version is git sha' do
-          let(:version) { '182f9c6e4d7a5779c4507cb8b3e505ac927d0394' }
-          it { is_expected.to eq('182f9c6...') }
-        end
-
-        context 'when version is too long' do
-          let(:version) { '182f9c6e4d7a5779c4507cb8b3e505ac927d0394' * 2 }
-          it { is_expected.to eq(version[0...60] + '...') }
-        end
-
-        context 'when the version is something unknown and fits max length' do
-          let(:version) { '123' }
-          it { is_expected.to eq('123') }
-        end
-
-        context 'when version is embedded into semantic version v1' do
-          let(:version) { 'v1.3.4+182f9c6e4d7a5779c4507cb8b3e505ac927d0394' }
-          it { is_expected.to eq('v1.3.4+182f9c6...') }
-        end
-
-        context 'when version is embedded into semantic version v2' do
-          let(:version) { '1.3.4(182f9c6e4d7a5779c4507cb8b3e505ac927d0394)' }
-          it { is_expected.to eq('1.3.4(182f9c6...)') }
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/matrix/resource_spec.rb

@@ -1,70 +0,0 @@
-require 'pact_broker/client/matrix/resource'
-
-module PactBroker
-  module Client
-    class Matrix
-      describe Resource do
-
-        let(:matrix_hash) { JSON.parse(File.read('spec/support/matrix.json'), symbolize_names: true) }
-
-        subject { Resource.new(matrix_hash) }
-
-        describe "any_unknown?" do
-          context "when $summary.unknown is greater than 0" do
-            it "is true" do
-              expect(subject.any_unknown?).to be true
-            end
-          end
-
-          context "when $summary.unknown is 0" do
-            before do
-              matrix_hash[:summary][:unknown] = 0
-            end
-
-            it "is false" do
-              expect(subject.any_unknown?).to be false
-            end
-          end
-        end
-
-        describe "supports_unknown_count?" do
-          context "when $summary.unknown is present" do
-            it "is true" do
-              expect(subject.supports_unknown_count?).to be true
-            end
-          end
-
-          context "when $summary.unknown is nil" do
-            before do
-              matrix_hash[:summary][:unknown] = nil
-            end
-
-            it "is false" do
-              expect(subject.supports_unknown_count?).to be false
-            end
-          end
-
-          context "when $summary.unknown is not an Integer" do
-            before do
-              matrix_hash[:summary][:unknown] = true
-            end
-
-            it "is false" do
-              expect(subject.supports_unknown_count?).to be false
-            end
-          end
-
-          context "when $summary.unknown is not present" do
-            before do
-              matrix_hash[:summary].delete(:unknown)
-            end
-
-            it "is false" do
-              expect(subject.supports_unknown_count?).to be false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/matrix/text_formatter_spec.rb

@@ -1,63 +0,0 @@
-require 'pact_broker/client/matrix/resource'
-require 'pact_broker/client/matrix/text_formatter'
-
-module PactBroker
-  module Client
-    describe Matrix::TextFormatter do
-      let(:matrix) { PactBroker::Client::Matrix::Resource.new(JSON.parse(File.read('spec/support/matrix.json'), symbolize_names: true)) }
-      let(:expected_matrix_lines) { File.read('spec/support/matrix.txt') }
-
-      # SublimeText removes whitespace from the end of files when you save them,
-      # so removing trailing whitespace before comparing
-      def strip_trailing_whitespace(text)
-        text.split("\n").collect(&:strip).join("\n")
-      end
-
-      subject { strip_trailing_whitespace(Matrix::TextFormatter.call(matrix)) }
-
-      context "with valid data" do
-        it "it has the right text" do
-          expect(subject).to start_with expected_matrix_lines
-        end
-      end
-
-      context "with invalid data" do
-        let(:expected_matrix_lines) { File.read('spec/support/matrix_error.txt') }
-        let(:matrix) { PactBroker::Client::Matrix::Resource.new(matrix: [{}]) }
-
-        it "doesn't blow up" do
-          expect(subject).to eq expected_matrix_lines
-        end
-      end
-
-      context "when some rows have a verification result URL and some don't" do
-        let(:matrix_lines) do
-          line_creator = -> { JSON.parse(File.read('spec/support/matrix.json'), symbolize_names: true)[:matrix].first }
-          line_1 = line_creator.call
-          line_2 = line_creator.call
-          line_3 = line_creator.call
-
-          # ensure the data is as expected
-          expect(line_1.dig(:consumer, :version, :number)).to_not be nil
-          expect(line_1.dig(:provider, :version, :number)).to_not be nil
-
-          line_1[:consumer][:version][:number] = "4"
-          line_2[:consumer][:version][:number] = "3"
-          line_3[:consumer][:version][:number] = "5"
-
-          line_2[:verificationResult] = nil
-          line_3[:verificationResult][:success] = false
-          [line_1, line_2, line_3].shuffle
-        end
-
-        let(:matrix) { PactBroker::Client::Matrix::Resource.new(matrix: matrix_lines) }
-
-        let(:expected_matrix_lines) { File.read('spec/support/matrix_with_results.txt') }
-
-        it "only provides a result number for the lines that have a result URL" do
-          expect(subject).to eq expected_matrix_lines
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/matrix_spec.rb

@@ -1,17 +0,0 @@
-require 'pact_broker/client/matrix'
-
-module PactBroker
-  module Client
-    describe Matrix do
-      let(:matrix) { Matrix.new(base_url: 'http://example.org') }
-
-      context "when the matrix resource is not found because the broker is the wrong version" do
-        let!(:request) { stub_request(:get, /matrix/).to_return(status: 404) }
-
-        it "raises a helpful error" do
-          expect { matrix.get([{name: "Foo", version: "1"}]) }.to raise_error PactBroker::Client::Error, %r{Matrix resource not found at http://example.org/matrix}
-        end
-      end
-    end
-  end
-end