pact_broker-client 1.75.3 → 1.75.4

data/spec/lib/pact_broker/client/branches/delete_branch_spec.rb

@@ -1,103 +0,0 @@
-require "pact_broker/client/branches/delete_branch"
-
-module PactBroker
-  module Client
-    module Branches
-      describe DeleteBranch do
-        before do
-          allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:sleep)
-          allow_any_instance_of(PactBroker::Client::Hal::HttpClient).to receive(:default_max_tries).and_return(1)
-        end
-
-        let(:params) do
-          {
-            pacticipant: "Foo",
-            branch: "main",
-            error_when_not_found: error_when_not_found
-          }
-        end
-        let(:options) do
-          {
-            verbose: verbose
-          }
-        end
-        let(:error_when_not_found) { true }
-        let(:pact_broker_base_url) { "http://example.org" }
-        let(:pact_broker_client_options) { { pact_broker_base_url: pact_broker_base_url } }
-        let(:response_headers) { { "Content-Type" => "application/hal+json"} }
-        let(:verbose) { false }
-
-        before do
-          stub_request(:get, "http://example.org/").to_return(status: 200, body: index_response_body, headers: response_headers)
-          stub_request(:delete, "http://example.org/pacticipants/Foo/branches/main").to_return(status: delete_response_status, body: delete_response_body, headers: response_headers)
-        end
-        let(:delete_response_status) { 200 }
-
-        let(:index_response_body) do
-          {
-            "_links" => {
-              "pb:pacticipant-branch" => {
-                "href" => "http://example.org/pacticipants/{pacticipant}/branches/{branch}"
-              }
-            }
-          }.to_json
-        end
-
-        let(:delete_response_body) do
-          { "some" => "error message" }.to_json
-        end
-
-        subject { DeleteBranch.call(params, options, pact_broker_client_options) }
-
-        context "when the branch is deleted" do
-          it "returns a success result" do
-            expect(subject.success).to be true
-            expect(subject.message).to include "Successfully deleted branch main of pacticipant Foo"
-          end
-        end
-
-        context "when there is a non-404 error" do
-          let(:delete_response_status) { 403 }
-
-          it "returns an error result with the response body" do
-            expect(subject.success).to be false
-            expect(subject.message).to include "error message"
-          end
-        end
-
-        context "when the branch is not found" do
-          let(:delete_response_status) { 404 }
-
-          context "when error_when_not_found is true" do
-            it "returns an error" do
-              expect(subject.success).to be false
-              expect(subject.message).to include "Could not delete branch main of pacticipant Foo as it was not found"
-            end
-          end
-
-          context "when error_when_not_found is false" do
-            let(:error_when_not_found) { false }
-
-            it "return a success" do
-              expect(subject.success).to be true
-              expect(subject.message).to include "Branch main of pacticipant Foo not found"
-            end
-          end
-        end
-
-        context "when deleting branches is not supported" do
-          let(:index_response_body) do
-            {
-              _links: {}
-            }.to_json
-          end
-
-          it "returns an error" do
-            expect(subject.success).to be false
-            expect(subject.message).to include "not support"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,250 +0,0 @@
-require 'pact_broker/client/can_i_deploy'
-require 'pact_broker/client/matrix/resource'
-
-module PactBroker
-  module Client
-    describe CanIDeploy do
-      let(:pact_broker_base_url) { 'http://example.org' }
-      let(:version_selectors) { [{ pacticipant: "Foo", version: "1" }] }
-      let(:matrix_options) { { } }
-      let(:pact_broker_client_options) { { pact_broker_base_url: pact_broker_base_url, foo: 'bar' } }
-      let(:dry_run) { false }
-      let(:matrix_client) { instance_double('PactBroker::Client::Matrix') }
-      let(:matrix) do
-        instance_double('Matrix::Resource',
-          deployable?: deployable,
-          reason: 'some reason',
-          any_unknown?: any_unknown,
-          supports_unknown_count?: supports_unknown_count,
-          supports_ignore?: supports_ignore,
-          unknown_count: unknown_count,
-          notices: notices)
-      end
-      let(:unknown_count) { 0 }
-      let(:any_unknown) { unknown_count > 0 }
-      let(:supports_unknown_count) { true }
-      let(:retry_while_unknown) { 0 }
-      let(:options) { { output: 'text', retry_while_unknown: retry_while_unknown, retry_interval: 5, dry_run: dry_run } }
-      let(:notices) { nil }
-      let(:supports_ignore) { true }
-      let(:deployable) { true }
-
-
-      before do
-        allow(PactBroker::Client::Matrix::Query).to receive(:call).and_return(matrix)
-        allow(Matrix::Formatter).to receive(:call).and_return('text matrix')
-      end
-
-      subject { CanIDeploy.call(version_selectors, matrix_options, options, pact_broker_client_options) }
-
-      it "retrieves the matrix from the pact broker" do
-        expect(PactBroker::Client::Matrix::Query).to receive(:call).with({ selectors: version_selectors, matrix_options: matrix_options }, options, pact_broker_client_options)
-        subject
-      end
-
-      it "creates a text table out of the matrix" do
-        expect(Matrix::Formatter).to receive(:call).with(matrix, 'text')
-        subject
-      end
-
-      context "when the versions are deployable" do
-        it "returns a success response" do
-          expect(subject.success).to be true
-        end
-
-        it "returns a success message with the text table" do
-          expect(subject.message).to include "Computer says yes"
-          expect(subject.message).to include "\n\ntext matrix"
-        end
-
-        it "returns a success reason" do
-          expect(subject.message).to include "some reason"
-        end
-
-        context "when there are notices" do
-          let(:notices) { [Notice.new(text: "some notice", type: "info")] }
-
-          it "returns the notices instead of the reason" do
-            expect(subject.message).to_not include "some reason"
-            expect(subject.message).to include "some notice"
-          end
-        end
-
-        context "when dry_run is enabled" do
-          let(:dry_run) { true }
-
-          it "prefixes each line with [dry-run]" do
-            Approvals.verify(subject.message, :name => "can_i_deploy_success_dry_run", format: :txt)
-          end
-        end
-      end
-
-      context "when the versions are not deployable" do
-        let(:matrix) { instance_double('Matrix::Resource', deployable?: false, reason: 'some reason', any_unknown?: false, notices: notices) }
-
-        it "returns a failure response" do
-          expect(subject.success).to be false
-        end
-
-        it "returns a failure message" do
-          expect(subject.message).to include "Computer says no"
-        end
-
-        it "returns a failure reason" do
-          expect(subject.message).to include "some reason"
-        end
-
-        context "when there are notices" do
-          let(:notices) { [Notice.new(text: "some notice", type: "info")] }
-
-          it "returns the notices instead of the reason" do
-            expect(subject.message).to_not include "some reason"
-            expect(subject.message).to include "some notice"
-          end
-        end
-
-        context "when dry_run is enabled" do
-          let(:dry_run) { true }
-
-          it "returns a success response" do
-            expect(subject.success).to be true
-          end
-
-          it "prefixes each line with [dry-run]" do
-            Approvals.verify(subject.message, :name => "can_i_deploy_failure_dry_run", format: :txt)
-          end
-        end
-      end
-
-      context "when retry_while_unknown is greater than 0" do
-        let(:retry_while_unknown) { 1 }
-
-        context "when any_unknown? is false" do
-          it "does not retry the request" do
-            expect(Retry).to_not receive(:until_truthy_or_max_times)
-            subject
-          end
-        end
-
-        context "when any_unknown? is true" do
-          before do
-            allow($stderr).to receive(:puts)
-            allow(Retry).to receive(:until_truthy_or_max_times)
-          end
-
-          let(:unknown_count) { 1 }
-
-          it "puts a message to stderr" do
-            expect($stderr).to receive(:puts).with("Waiting for 1 verification result to be published (maximum of 5 seconds)")
-            subject
-          end
-
-          it "retries the request" do
-            expect(Retry).to receive(:until_truthy_or_max_times).with(hash_including(times: 1, sleep: 5, sleep_first: true))
-            subject
-          end
-        end
-
-        context "when the matrix does not support the unknown count" do
-          let(:supports_unknown_count) { false }
-
-          it "returns a failure response" do
-            expect(subject.success).to be false
-          end
-
-          it "returns a failure message" do
-            expect(subject.message).to match /does not provide a count/
-          end
-
-          context "when dry_run is enabled" do
-            let(:dry_run) { true }
-
-            it "returns a success response" do
-              expect(subject.success).to be true
-            end
-
-            it "returns a failure message" do
-              expect(subject.message).to include "[dry-run]"
-              expect(subject.message).to match /does not provide a count/
-            end
-          end
-        end
-      end
-
-      context "when there are ignore selectors but the matrix does not support ignoring" do
-        let(:matrix_options) { { ignore_selectors: [{ pacticipant_name: "Foo" }]} }
-        let(:supports_ignore) { false }
-
-        context "when deployable" do
-          it "returns a warning" do
-            expect(subject.message).to include "does not support"
-          end
-        end
-
-        context "when not deployable" do
-          let(:deployable) { false }
-
-          it "returns a warning" do
-            expect(subject.message).to include "does not support"
-          end
-        end
-      end
-
-      context "when a PactBroker::Client::Error is raised" do
-        before do
-          allow(PactBroker::Client::Matrix::Query).to receive(:call).and_raise(PactBroker::Client::Error.new('error text'))
-        end
-
-        it "returns a failure response" do
-          expect(subject.success).to be false
-        end
-
-        it "returns a failure message" do
-          expect(subject.message).to include "error text"
-        end
-
-        context "when dry_run is enabled" do
-          let(:dry_run) { true }
-
-          it "returns a success response" do
-            expect(subject.success).to be true
-          end
-
-          it "returns a failure message" do
-            expect(subject.message).to include "[dry-run]"
-            expect(subject.message).to match /error text/
-          end
-        end
-      end
-
-      context "when a StandardError is raised" do
-        before do
-          allow(Retry).to receive(:while_error) { |&block| block.call }
-          allow($stderr).to receive(:puts)
-          allow(PactBroker::Client::Matrix::Query).to receive(:call).and_raise(StandardError.new('error text'))
-        end
-
-        it "returns a failure response" do
-          expect(subject.success).to be false
-        end
-
-        it "returns a failure message and backtrace" do
-          expect(subject.message).to include "Error retrieving matrix. StandardError - error text"
-        end
-
-        context "when dry_run is enabled" do
-          let(:dry_run) { true }
-
-          it "returns a success response" do
-            expect(subject.success).to be true
-          end
-
-          it "returns a failure message" do
-            expect(subject.message).to include "[dry-run]"
-            expect(subject.message).to match /error text/
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/cli/broker_can_i_deploy_spec.rb

@@ -1,196 +0,0 @@
-require 'pact_broker/client/cli/broker'
-require 'pact_broker/client/cli/version_selector_options_parser'
-require 'pact_broker/client/can_i_deploy'
-require 'ostruct'
-
-module PactBroker
-  module Client
-    module CLI
-      describe Broker do
-        before do
-          subject.options = OpenStruct.new(minimum_valid_options)
-          allow(VersionSelectorOptionsParser).to receive(:call).and_return(version_selectors)
-          allow(CanIDeploy).to receive(:call).and_return(result)
-          allow($stdout).to receive(:puts)
-          allow($stderr).to receive(:puts)
-        end
-
-        let(:result) { instance_double('PactBroker::Client::CanIDeploy::Result', success: success, message: message) }
-        let(:success) { true }
-        let(:message) { 'message' }
-        let(:version_selectors) { [{pacticipant: "Foo", version: "1"}] }
-        let(:minimum_valid_options) do
-          {
-            broker_base_url: 'http://pact-broker',
-            output: 'table',
-            verbose: 'verbose',
-            retry_while_unknown: 1,
-            retry_interval: 2,
-            limit: 1000,
-            dry_run: false
-          }
-        end
-
-        let(:invoke_can_i_deploy) { subject.can_i_deploy }
-
-        it "parses the pacticipant names and versions" do
-          expect(VersionSelectorOptionsParser).to receive(:call).with(ARGV)
-          invoke_can_i_deploy
-        end
-
-        it "invokes the CanIDeploy service" do
-          expect(CanIDeploy).to receive(:call).with(version_selectors, { to_tag: nil, to_environment: nil, limit: 1000, ignore_selectors: []}, {output: 'table', retry_while_unknown: 1, retry_interval: 2, dry_run: false, verbose: "verbose"}, { pact_broker_base_url: 'http://pact-broker', verbose: 'verbose' })
-          invoke_can_i_deploy
-        end
-
-        context "with a missing --version and --latest" do
-          let(:version_selectors) { [{pacticipant: "Foo", version: nil}] }
-
-          it "raises an error" do
-            expect { invoke_can_i_deploy }.to raise_error Thor::RequiredArgumentMissingError, /The version must be specified/
-          end
-        end
-
-        context "with --to" do
-          before do
-            subject.options.to = 'prod'
-          end
-
-          it "passes the value as the matrix options" do
-            expect(CanIDeploy).to receive(:call).with(anything, {to_tag: 'prod', to_environment: nil, limit: 1000, ignore_selectors: []}, anything, anything)
-            invoke_can_i_deploy
-          end
-        end
-
-        context "with --to-environment" do
-          before do
-            subject.options.to_environment = 'prod'
-          end
-
-          it "passes the value as the matrix options" do
-            expect(CanIDeploy).to receive(:call).with(anything, {to_tag: nil, to_environment: 'prod', limit: 1000, ignore_selectors: []}, anything, anything)
-            invoke_can_i_deploy
-          end
-
-          context "when the environment is an empty string" do
-            before do
-              subject.options.to_environment = ' '
-            end
-
-            it "raises an error" do
-              expect { invoke_can_i_deploy }.to raise_error ::Thor::RequiredArgumentMissingError
-            end
-          end
-        end
-
-        context "with basic auth" do
-          before do
-            subject.options.broker_username = 'foo'
-            subject.options.broker_password = 'bar'
-          end
-
-          it "invokes the CanIDeploy service with the basic auth credentials" do
-            expect(CanIDeploy).to receive(:call).with(anything, anything, anything, { pact_broker_base_url: 'http://pact-broker', basic_auth: {username: "foo", password: "bar"}, verbose: 'verbose'})
-            invoke_can_i_deploy
-          end
-        end
-
-        context "with a bearer token" do
-          before do
-            subject.options.broker_token = "some token"
-          end
-
-          it "invokes the CanIDeploy service with the basic auth credentials" do
-            expect(CanIDeploy).to receive(:call).with(anything, anything, anything, {pact_broker_base_url: 'http://pact-broker', token: "some token", verbose: 'verbose'})
-            invoke_can_i_deploy
-          end
-        end
-
-        context "when PACT_BROKER_CAN_I_DEPLOY_DRY_RUN=true" do
-          before do
-            allow(ENV).to receive(:[]).and_call_original
-            allow(ENV).to receive(:[]).with("PACT_BROKER_CAN_I_DEPLOY_DRY_RUN").and_return("true")
-          end
-
-          it "invokes the CanIDeploy service with dry_run set to true" do
-            expect(CanIDeploy).to receive(:call).with(anything, anything, hash_including(dry_run: true), anything)
-            invoke_can_i_deploy
-          end
-        end
-
-        context "when PACT_BROKER_CAN_I_DEPLOY_IGNORE=Some Service" do
-          before do
-            allow(ENV).to receive(:fetch).and_call_original
-            allow(ENV).to receive(:fetch).with("PACT_BROKER_CAN_I_DEPLOY_IGNORE", "").and_return("Some Service, Some Other Service")
-          end
-
-          it "invokes the CanIDeploy service with ignore selectors" do
-            expect(CanIDeploy).to receive(:call).with(anything, hash_including(ignore_selectors: [ { pacticipant: "Some Service" }, { pacticipant: "Some Other Service" } ]), anything, anything)
-            invoke_can_i_deploy
-          end
-        end
-
-        context "when successful" do
-          it "prints the message to stdout" do
-            expect($stdout).to receive(:puts).with(message)
-            invoke_can_i_deploy
-          end
-        end
-
-        context "when not successful" do
-          let(:success) { false }
-
-          it "prints the message to stderr" do
-            expect($stdout).to receive(:puts).with(message)
-            begin
-              invoke_can_i_deploy
-            rescue SystemExit
-            end
-          end
-
-          it "exits with code 1" do
-            exited_explicitly = false
-            exited_explicitlyerror = nil
-            begin
-              invoke_can_i_deploy
-            rescue SystemExit => e
-              exited_explicitly = true
-              error = e
-            end
-            expect(exited_explicitly).to be true
-            expect(error.status).to be 1
-          end
-
-          context "when an exit status is specified" do
-            before do
-              allow(ENV).to receive(:fetch).and_call_original
-              allow(ENV).to receive(:fetch).with('PACT_BROKER_CAN_I_DEPLOY_EXIT_CODE_BETA', '').and_return("0")
-            end
-
-            it "exits with the specified code" do
-              exited_explicitly = false
-              error = nil
-              begin
-                invoke_can_i_deploy
-              rescue SystemExit => e
-                exited_explicitly = true
-                error = e
-              end
-              expect(exited_explicitly).to be true
-              expect(error.status).to be 0
-            end
-
-            it "prints the configured exit code" do
-              expect($stderr).to receive(:puts).with("Exiting can-i-deploy with configured exit code 0")
-              expect($stdout).to receive(:puts).with(message)
-              begin
-                invoke_can_i_deploy
-              rescue SystemExit
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/cli/broker_create_or_update_webhook_spec.rb

@@ -1,23 +0,0 @@
-require 'pact_broker/client/cli/broker'
-require 'pact_broker/client/webhooks/create'
-
-module PactBroker
-  module Client
-    module CLI
-      describe Broker do
-        describe "create_or_update_webhook" do
-
-          let(:broker) { Broker.new }
-
-          subject { broker.create_or_update_webhook "http://webhook" }
-
-          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
-            expect(broker).to receive(:run_webhook_commands).with("http://webhook")
-
-            subject
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/cli/broker_create_webhook_spec.rb

@@ -1,23 +0,0 @@
-require 'pact_broker/client/cli/broker'
-require 'pact_broker/client/webhooks/create'
-
-module PactBroker
-  module Client
-    module CLI
-      describe Broker do
-        describe "create_webhook" do
-
-          let(:broker) { Broker.new }
-
-          subject { broker.create_webhook "http://webhook" }
-
-          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
-            expect(broker).to receive(:run_webhook_commands).with("http://webhook")
-
-            subject
-          end
-        end
-      end
-    end
-  end
-end