pact_broker-client 1.75.3 → 1.75.4

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

@@ -1,198 +0,0 @@
-require 'pact_broker/client/merge_pacts'
-
-module PactBroker
-  module Client
-    describe MergePacts do
-      describe ".call" do
-        describe "with a pact with interactions" do
-          let(:pact_hash_1) do
-            {
-              other: 'info',
-              interactions: [
-                { providerState: 1, description: 1, foo: 'bar' }
-              ]
-            }
-          end
-
-          let(:pact_hash_2) do
-            {
-              interactions: [
-                { providerState: 2, description: 2, foo: 'wiffle' }
-              ]
-            }
-          end
-
-          let(:pact_hash_3) do
-            {
-              interactions: [
-                { providerState: 3, description: 3, foo: 'meep' },
-                { providerState: 1, description: 1, foo: 'bar' }
-              ]
-            }
-          end
-
-          let(:pact_hashes) { [pact_hash_1, pact_hash_2, pact_hash_3] }
-
-          let(:expected_merge) do
-            {
-              other: 'info',
-              interactions: [
-                { providerState: 1, description: 1, foo: 'bar' },
-                { providerState: 2, description: 2, foo: 'wiffle' },
-                { providerState: 3, description: 3, foo: 'meep' }
-              ]
-            }
-          end
-
-          subject { MergePacts.call(pact_hashes) }
-
-          it "merges the interactions by consumer/provider" do
-            expect(subject).to eq expected_merge
-          end
-
-          context "when an interaction is found with the same state and description but has a difference elsewhere" do
-            let(:pact_hash_3) do
-              {
-                interactions: [
-                  { providerState: 3, description: 3, foo: 'meep' },
-                  { providerState: 1, description: 1, foo: 'different' }
-                ]
-              }
-            end
-
-            it "raises an error" do
-              expect { subject }.to raise_error PactMergeError, /foo.*different/
-            end
-          end
-        end
-
-        describe "with a pact with messages" do
-          let(:pact_hash_1) do
-            {
-              other: 'info',
-              messages: [
-                { providerState: 1, description: 1, foo: 'bar' }
-              ]
-            }
-          end
-
-          let(:pact_hash_2) do
-            {
-              messages: [
-                { providerState: 2, description: 2, foo: 'wiffle' }
-              ]
-            }
-          end
-
-          let(:pact_hash_3) do
-            {
-              messages: [
-                { providerState: 3, description: 3, foo: 'meep' },
-                { providerState: 1, description: 1, foo: 'bar' }
-              ]
-            }
-          end
-
-          let(:pact_hashes) { [pact_hash_1, pact_hash_2, pact_hash_3] }
-
-          let(:expected_merge) do
-            {
-              other: 'info',
-              messages: [
-                { providerState: 1, description: 1, foo: 'bar' },
-                { providerState: 2, description: 2, foo: 'wiffle' },
-                { providerState: 3, description: 3, foo: 'meep' }
-              ]
-            }
-          end
-
-          subject { MergePacts.call(pact_hashes) }
-
-          it "merges the messages by consumer/provider" do
-            expect(subject).to eq expected_merge
-          end
-
-          context "when an interaction is found with the same state and description but has a difference elsewhere" do
-            let(:pact_hash_3) do
-              {
-                messages: [
-                  { providerState: 3, description: 3, foo: 'meep' },
-                  { providerState: 1, description: 1, foo: 'different' }
-                ]
-              }
-            end
-
-            it "raises an error" do
-              expect { subject }.to raise_error PactMergeError, /foo.*different/
-            end
-          end
-        end
-
-        describe "with a pact with messages and a pact with interactions" do
-          let(:pact_hash_1) do
-            {
-              other: 'info',
-              messages: [
-                { providerState: 1, description: 1, foo: 'bar' }
-              ]
-            }
-          end
-
-          let(:pact_hash_2) do
-            {
-              interactions: [
-                { providerState: 2, description: 2, foo: 'wiffle' }
-              ]
-            }
-          end
-
-          let(:pact_hashes) { [pact_hash_1, pact_hash_2] }
-
-          let(:expected_merge) do
-            {
-              other: 'info',
-              messages: [
-                { providerState: 1, description: 1, foo: 'bar' }
-              ],
-              interactions: [
-                { providerState: 2, description: 2, foo: 'wiffle' }
-              ]
-            }
-          end
-
-          subject { MergePacts.call(pact_hashes) }
-
-          it "merges the messages by consumer/provider" do
-            expect(subject).to eq expected_merge
-          end
-        end
-
-        describe "with v3 pacts" do
-          let(:pact_hash_1) { JSON.parse(File.read("spec/fixtures/MyConsumer-MyProvider.json"), symbolize_names: true) }
-          let(:pact_hash_2) { JSON.parse(File.read("spec/fixtures/MyConsumer-MyProvider (1).json"), symbolize_names: true) }
-          let(:pact_hashes) { [pact_hash_1, pact_hash_2] }
-
-          subject { MergePacts.call(pact_hashes) }
-
-          context "when there are no conflicts and no duplicates" do
-            it "adds all the interactions to the merged file" do
-              expect(subject[:interactions].size).to eq 2
-            end
-          end
-
-          context "when there is a conflict" do
-            let(:pact_hash_2) do
-              hash = JSON.parse(File.read("spec/fixtures/MyConsumer-MyProvider.json"), symbolize_names: true)
-              hash[:interactions].first[:request][:path] = "/a-different-path"
-              hash
-            end
-
-            it "raises an error with a message that contains the provider states of the conflicting interactions" do
-              expect { subject }.to raise_error PactMergeError, /state 1/
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-require 'pact_broker/client'
-
-module PactBroker::Client
-  describe PactBrokerClient do
-
-    let(:client_options) do
-      { some_option: 'option value'}
-    end
-    let(:base_url) { 'https://blah' }
-
-    describe 'initialize' do
-      subject { PactBrokerClient.new }
-      it 'sets the base_uri to http://pact-broker by default' do
-        expect(subject.base_url).to eq('http://pact-broker')
-      end
-
-      it 'sets the client options to empty hash by default' do
-        expect(subject.client_options).to eq({})
-      end
-
-      it 'allows configuration of the base_uri' do
-        expect(PactBrokerClient.new(base_url: base_url).base_url).to eq(base_url)
-      end
-
-      it 'allows configuration of the client options' do
-        expect(PactBrokerClient.new(client_options: client_options).client_options).to eq(client_options)
-      end
-    end
-
-    describe 'pacticipants' do
-      it 'initializes pacticipants with base url and client options' do
-        expect(PactBroker::Client::Pacticipants).to receive(:new).with(base_url: base_url, client_options: client_options)
-        PactBrokerClient.new(base_url: base_url, client_options: client_options).pacticipants
-      end
-    end
-
-    describe 'pacts' do
-      it 'initializes [act] with base url and client options' do
-        expect(PactBroker::Client::Pacts).to receive(:new).with(base_url: base_url, client_options: client_options)
-        PactBrokerClient.new(base_url: base_url, client_options: client_options).pacts
-      end
-    end
-  end
-
-end

data/spec/lib/pact_broker/client/pacticipants/create_spec.rb

@@ -1,31 +0,0 @@
-require 'pact_broker/client/pacticipants/create'
-
-module PactBroker
-  module Client
-    module Pacticipants2
-      describe Create do
-        describe ".call" do
-          before do
-            allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:sleep)
-          end
-          let(:pact_broker_client_options) { { pact_broker_base_url: broker_base_url} }
-          let(:broker_base_url) { "http://url" }
-          let(:params) { { name: 'Foo' } }
-
-          subject { Create.call(params, {}, pact_broker_client_options)}
-
-          context "when there is an http error" do
-            let!(:index_request) do
-              stub_request(:get, broker_base_url).to_return(status: 500, body: 'some error', headers: { "Content-Type" => "application/hal+json" }  )
-            end
-
-            it "returns a failure result" do
-              expect(subject.success).to be false
-              expect(subject.message).to include 'some error'
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-require 'pact_broker/client/pacticipants'
-module PactBroker
-  module Client
-    describe Pacticipants do
-      let(:client_options) do
-        { some_option: 'option value'}
-      end
-      let(:base_url) { 'https://blah' }
-
-      describe 'versions' do
-        it 'initializes versions with base url and client options' do
-          expect(PactBroker::Client::Versions).to receive(:new).with(base_url: base_url, client_options: client_options)
-          Pacticipants.new(base_url: base_url, client_options: client_options).versions
-        end
-      end
-    end
-  end
-end

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

@@ -1,272 +0,0 @@
-require 'spec_helper'
-require 'fakefs/safe'
-require 'pact_broker/client/publish_pacts_the_old_way'
-require 'json'
-
-module PactBroker
-  module Client
-    describe PublishPactsTheOldWay do
-
-      # The amount of stubbing that we have to do here indicates this class is doing
-      # TOO MUCH and needs to be split up!
-      before do
-        FakeFS.activate!
-        allow(pacts_client).to receive(:publish).and_return(latest_pact_url)
-        allow(PactBroker::Client::PactBrokerClient).to receive(:new).and_return(pact_broker_client)
-        allow(pact_broker_client).to receive_message_chain(:pacticipants, :versions).and_return(pact_versions_client)
-        allow(pact_broker_client).to receive_message_chain(:pacticipants, :versions, :pacts).and_return(pacts_client)
-        allow(pacts_client).to receive(:version_published?).and_return(false)
-        allow($stdout).to receive(:puts)
-        allow(Retry).to receive(:sleep)
-        allow(MergePacts).to receive(:call) { | pact_hashes | pact_hashes[0] }
-        FileUtils.mkdir_p "spec/pacts"
-        File.open("spec/pacts/consumer-provider.json", "w") { |file| file << pact_hash.to_json }
-        File.open("spec/pacts/consumer-provider-2.json", "w") { |file| file << pact_hash.to_json }
-        File.open("spec/pacts/foo-bar.json", "w") { |file| file << pact_hash_2.to_json }
-        allow_any_instance_of(PublishPactsTheOldWay).to receive(:create_index_entry_point).and_return(index_entry_point)
-      end
-
-      after do
-        FakeFS.deactivate!
-      end
-
-      let(:latest_pact_url) { 'http://example.org/latest/pact' }
-      let(:pact_broker_client) { double("PactBroker::Client")}
-      let(:pact_file_paths) { ['spec/pacts/consumer-provider.json']}
-      let(:consumer_version) { "1.2.3" }
-      let(:tags) { nil }
-      let(:branch) { nil }
-      let(:build_url) { nil }
-      let(:pact_hash) { { consumer: { name: 'Consumer'}, provider: { name: 'Provider' }, interactions: [] } }
-      let(:pact_hash_2) { {consumer: { name: 'Foo' }, provider: { name: 'Bar' }, interactions: [] } }
-      let(:pacts_client) { instance_double("PactBroker::ClientSupport::Pacts")}
-      let(:pact_versions_client) { instance_double("PactBroker::Client::Versions", tag: false) }
-      let(:pact_broker_base_url) { 'http://some-host'}
-      let(:consumer_version_params) do
-        {
-          number: consumer_version,
-          branch: branch,
-          tags: tags,
-          build_url: build_url
-        }
-      end
-      let(:pact_broker_client_options) do
-        {
-          basic_auth: {
-            username: 'user',
-            password: 'pass'
-          }
-        }
-      end
-      let(:index_entry_point) { instance_double("PactBroker::Client::Hal::EntryPoint", :get! => index_resource )}
-      let(:index_resource) { instance_double("PactBroker::Client::Hal::Entity", can?: can_create_version ) }
-      let(:can_create_version) { false }
-      let(:options) { {} }
-
-      subject { PublishPactsTheOldWay.new(pact_broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options) }
-
-      describe "call" do
-        it "creates a PactBroker Client" do
-          expect(PactBroker::Client::PactBrokerClient).to receive(:new).with(base_url: pact_broker_base_url, client_options: pact_broker_client_options)
-          subject.call
-        end
-
-        it "uses the pact_broker client to publish the given pact" do
-          expect(pacts_client).to receive(:publish).with(pact_hash: pact_hash, consumer_version: consumer_version)
-          subject.call
-        end
-
-        context "when publishing is successful" do
-          it "puts the location of the latest pact" do
-            allow($stdout).to receive(:puts)
-            expect($stdout).to receive(:puts).with(/#{latest_pact_url}/)
-            subject.call
-          end
-
-          it "returns true" do
-            expect(subject.call.success).to eq true
-          end
-        end
-
-        context "when publishing multiple files with the same consumer/provider" do
-          let(:pact_file_paths) { ['spec/pacts/consumer-provider.json','spec/pacts/consumer-provider-2.json']}
-          it "merges the files" do
-            expect(MergePacts).to receive(:call).with([pact_hash, pact_hash])
-            subject.call
-          end
-        end
-
-        context "when publishing multiple files with different consumers" do
-          let(:pact_file_paths) { ['spec/pacts/consumer-provider.json','spec/pacts/foo-bar.json']}
-          let(:tags) { ['dev'] }
-
-          it "tags each consumer" do
-            expect(pact_versions_client).to receive(:tag).with(
-              pacticipant: "Consumer",
-              version: consumer_version,
-              tag: "dev"
-            )
-            expect(pact_versions_client).to receive(:tag).with(
-              pacticipant: "Foo",
-              version: consumer_version,
-              tag: "dev"
-            )
-            subject.call
-          end
-        end
-
-        context "when publishing one or more pacts fails" do
-          let(:pact_file_paths) { ['spec/pacts/consumer-provider.json','spec/pacts/foo-bar.json']}
-
-          before do
-            allow(pacts_client).to receive(:publish).with(
-              pact_hash: pact_hash,
-              consumer_version: consumer_version
-            ).and_raise("an error")
-
-            allow($stderr).to receive(:puts)
-          end
-
-          it "logs an message to stderr" do
-            expect($stderr).to receive(:puts).with(/Failed to publish Consumer\/Provider pact/)
-            subject.call
-          end
-
-          it "continues publishing the rest" do
-            expect(pacts_client).to receive(:publish).with(
-              pact_hash: pact_hash_2, consumer_version: consumer_version)
-            subject.call
-          end
-
-          it "returns false" do
-            expect(subject.call.success).to be false
-          end
-        end
-
-        context "when no pact files are specified" do
-          let(:pact_file_paths) { [] }
-          it "raises a validation error" do
-            expect { subject.call }.to raise_error(/No pact files found/)
-          end
-        end
-
-        context "when consumer_version is blank" do
-          let(:consumer_version) { " " }
-          it "raises a validation error" do
-            expect { subject.call }.to raise_error(/Please specify the consumer_version/)
-          end
-        end
-
-        context "when consumer_version has a new line" do
-          let(:consumer_version) { "1\n" }
-
-          it "strips the new line" do
-            expect(pacts_client).to receive(:publish).with(pact_hash: pact_hash, consumer_version: "1")
-            subject.call
-          end
-        end
-
-        context "when pact_broker_base_url is blank" do
-          let(:pact_broker_base_url) { " " }
-          it "raises a validation errror" do
-            expect { subject.call }.to raise_error(/Please specify the pact_broker_base_url/)
-          end
-        end
-
-        context "when a tag is provided" do
-          let(:tags) { ["dev"] }
-
-          it "tags the consumer version" do
-            expect(pact_versions_client).to receive(:tag).with({pacticipant: "Consumer",
-              version: consumer_version, tag: "dev"})
-            subject.call
-          end
-
-          it "tags the version before publishing the pact so that there aren't timing issues retrieving pacts by tag" do
-            expect(pact_versions_client).to receive(:tag).ordered
-            expect(pacts_client).to receive(:publish).ordered
-            subject.call
-          end
-
-          context "when the tag has a new line on the end of it" do
-            let(:tags) { ["foo\n"] }
-
-            it "strips the newline" do
-              expect(pact_versions_client).to receive(:tag).with({pacticipant: "Consumer",
-                version: consumer_version, tag: "foo"})
-              subject.call
-            end
-          end
-
-          context "when an error occurs tagging the pact" do
-            before do
-              allow(pact_versions_client).to receive(:tag).and_raise("an error")
-              allow(Retry).to receive(:sleep)
-              allow($stderr).to receive(:puts)
-            end
-
-            it "retries multiple times" do
-              expect(pact_versions_client).to receive(:tag).exactly(3).times
-              subject.call
-            end
-
-            it "returns false" do
-              expect(subject.call.success).to eq false
-            end
-          end
-        end
-
-        context "when an error occurs every time while publishing a pact" do
-          before do
-            allow(Retry).to receive(:sleep)
-            allow(pacts_client).to receive(:publish).and_raise("an error")
-            allow($stderr).to receive(:puts)
-          end
-
-          it "retries multiple times" do
-            expect(pacts_client).to receive(:publish).exactly(3).times
-            subject.call
-          end
-
-          it "returns false" do
-            expect(subject.call.success).to eq false
-          end
-        end
-
-        context "when an error occurs less than the maximum number of retries" do
-          before do
-            allow(Retry).to receive(:sleep)
-            tries = 0
-            allow(pacts_client).to receive(:publish) do
-              if tries == 0
-                tries += 1
-                raise "an error"
-              else
-                latest_pact_url
-              end
-            end
-            allow($stderr).to receive(:puts)
-          end
-
-          it "retries multiple times" do
-            expect(pacts_client).to receive(:publish).exactly(2).times
-            subject.call
-          end
-
-          it "returns true" do
-            expect(subject.call.success).to eq true
-          end
-        end
-
-        context "when the broker does not support creation of a version with a branch but a branch is specified" do
-          let(:branch) { "main" }
-
-          it "logs a warning" do
-            expect($stdout).to receive(:puts).with(/WARN: This version/)
-            subject.call
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-require 'pact_broker/client/retry'
-
-module PactBroker
-  module Client
-    describe Retry do
-      describe ".until_truthy_or_max_times" do
-        before do
-          allow(service).to receive(:get_result).and_return(1, 2, 3)
-          allow(condition).to receive(:call).and_return(false, false, true)
-          allow(Retry).to receive(:sleep)
-        end
-
-        let(:service) { double('service') }
-        let(:condition) { double('condition') }
-        let(:times) { 4 }
-        let(:sleep_first) { nil }
-
-        subject do
-          Retry.until_truthy_or_max_times(condition: condition, times: times, sleep: 3, sleep_first: sleep_first) do
-            service.get_result
-          end
-        end
-
-        context "times is 0 (which it shouldn't be, but just to be sure...)" do
-          let(:times) { 0 }
-
-          it "only executes the block once" do
-            subject
-            expect(service).to have_received(:get_result).exactly(1).times
-          end
-
-          it "does not execute the condition" do
-            expect(condition).to_not receive(:call)
-            subject
-          end
-
-          it "returns the result" do
-            expect(subject).to eq 1
-          end
-        end
-
-        context "times is 1" do
-          let(:times) { 1 }
-
-          it "only executes the block once" do
-            subject
-            expect(service).to have_received(:get_result).exactly(1).times
-          end
-
-          it "does not execute the condition" do
-            expect(condition).to_not receive(:call)
-            subject
-          end
-
-          it "returns the result" do
-            expect(subject).to eq 1
-          end
-        end
-
-        context "when the condition becomes true before the max tries" do
-          it "stops retrying when the condition becomes true" do
-            subject
-            expect(condition).to have_received(:call).exactly(3).times
-            expect(service).to have_received(:get_result).exactly(3).times
-          end
-
-          it "returns the most recent result" do
-            expect(subject).to eq 3
-          end
-        end
-
-        context "when the max tries is reached before the condition becomes true" do
-          let(:times) { 2 }
-
-          it "stops retrying once the max tries is reached" do
-            subject
-            expect(condition).to have_received(:call).exactly(2).times
-            expect(service).to have_received(:get_result).exactly(2).times
-          end
-
-          it "returns the most recent result" do
-            expect(subject).to eq 2
-          end
-        end
-
-        context "when an error is raised each time" do
-          TestError = Class.new(StandardError)
-
-          before do
-            allow(service).to receive(:get_result).and_raise(TestError)
-            allow($stderr).to receive(:puts)
-          end
-
-          it "stops retrying once the max tries is reached" do
-            begin
-              subject
-            rescue TestError
-            end
-            expect(service).to have_received(:get_result).exactly(4).times
-          end
-
-          it "raises the error" do
-            expect { subject }.to raise_error TestError
-          end
-        end
-
-        context "when sleep_first is true" do
-          let(:sleep_first) { true }
-
-          it "sleeps before it executes the block" do
-            expect(Retry).to receive(:sleep).ordered
-            expect(service).to receive(:get_result).ordered
-            subject
-          end
-        end
-      end
-    end
-  end
-end