pact_broker-client 1.75.3 → 1.75.4

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

@@ -1,327 +0,0 @@
-require 'pact_broker/client/cli/broker'
-require 'pact_broker/client/publish_pacts'
-require 'pact_broker/client/git'
-require 'ostruct'
-
-module PactBroker::Client::CLI
-  describe Broker do
-    describe '.broker' do
-      before do
-        allow(PactBroker::Client::PublishPacts).to receive(:call).and_return(result)
-        allow(PactBroker::Client::Git).to receive(:branch).and_return('bar')
-        allow(PactBroker::Client::Git).to receive(:commit).and_return('6.6.6')
-        allow(PactBroker::Client::Git).to receive(:build_url).and_return('build_url')
-        subject.options = OpenStruct.new(minimum_valid_options)
-        allow($stdout).to receive(:puts)
-      end
-
-      let(:success) { true }
-      let(:result) { instance_double(PactBroker::Client::CommandResult, success: success, message: "message")}
-      let(:file_list) { ["spec/support/cli_test_pacts/foo.json"] }
-      let(:minimum_valid_options) do
-        {
-          pact_dir: 'spec/pacts',
-          consumer_app_version: '1.2.3',
-          broker_base_url: 'http://pact-broker'
-        }
-      end
-
-      let(:invoke_broker) { subject.publish(*file_list) }
-
-      context "with minimum valid options" do
-        it "invokes the PublishPacts command" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            "http://pact-broker",
-            ["spec/support/cli_test_pacts/foo.json"],
-            { number: "1.2.3", tags: [] },
-            {},
-            { pact_broker_base_url: 'http://pact-broker' }
-          )
-          invoke_broker
-        end
-      end
-
-      context "with a file pattern specified" do
-        let(:file_list) { ["spec/support/cli_test_pacts/*.json"] }
-
-        it "invokes the PublishPacts command with the expanded list of files" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            ["spec/support/cli_test_pacts/bar.json", "spec/support/cli_test_pacts/foo.json"],
-            anything,
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with a pact directory specified" do
-        let(:file_list) { ["spec/support/cli_test_pacts"] }
-
-        it "invokes the PublishPacts command with the list of files in the directory" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            ["spec/support/cli_test_pacts/bar.json", "spec/support/cli_test_pacts/foo.json"],
-            anything,
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with a windows directory specified" do
-        let(:file_list) { ['spec\\support\cli_test_pacts'] }
-
-        it "invokes the PublishPacts command with the list of files in the directory" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            ["spec/support/cli_test_pacts/bar.json", "spec/support/cli_test_pacts/foo.json"],
-            anything,
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with an invalid argument specified that gets interpreted as a path" do
-        let(:file_list) { ['--wrong'] }
-
-        it "raises a more helpful error" do
-          expect{ invoke_broker }.to raise_error(Thor::Error, 'ERROR: pact-broker publish was called with invalid arguments ["--wrong"]')
-        end
-      end
-
-      context "when a specified file does not exist" do
-        let(:file_list) { ['no-existy'] }
-
-        it "raises a more helpful error" do
-          expect{ invoke_broker }.to raise_error(Thor::Error, /Specified pact file 'no-existy' does not exist/)
-        end
-      end
-
-      context "with a tag" do
-        before do
-          subject.options = OpenStruct.new(minimum_valid_options.merge(tag: ['foo']))
-        end
-
-        it "passes in the tag" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(tags: ['foo']),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with tag-with-git-branch" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(tag_with_git_branch: true, tag: ['foo'])
-          )
-        end
-
-        it "determines the git branch name" do
-          expect(PactBroker::Client::Git).to receive(:branch)
-          invoke_broker
-        end
-
-        it "adds it to the list of tags when publishing" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(tags: ['foo', 'bar']),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with a branch specified" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(branch: "main")
-          )
-        end
-
-        it "passes in the branch option" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(branch: "main"),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with --auto-detect-version-properties specified" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(auto_detect_version_properties: true, consumer_app_version: nil)
-          )
-        end
-
-        it "determines the git branch name" do
-          expect(PactBroker::Client::Git).to receive(:branch).with(raise_error: true)
-          invoke_broker
-        end
-
-        it "passes in the auto detected branch option" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(branch: "bar"),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-
-        it 'determines the commit sha' do
-          expect(PactBroker::Client::Git).to receive(:commit).with(raise_error: true)
-          invoke_broker
-        end
-
-        it 'passes in the auto detected commit sha option' do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(number: '6.6.6'),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-
-        it 'determines the build URL' do
-          expect(PactBroker::Client::Git).to receive(:build_url)
-          invoke_broker
-        end
-
-        it 'passes in the auto detected build URL' do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(build_url: 'build_url'),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-
-        context "with the branch specified as well" do
-          before do
-            subject.options = OpenStruct.new(
-              minimum_valid_options.merge(branch: "specified-branch", auto_detect_version_properties: true)
-            )
-          end
-
-          it "uses the specified branch" do
-            expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-              anything,
-              anything,
-              hash_including(branch: "specified-branch"),
-              anything,
-              anything
-            )
-            invoke_broker
-          end
-        end
-      end
-
-      context "with the build_url specified" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(build_url: "http://ci")
-          )
-        end
-
-        it "passes in the branch option" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            hash_including(build_url: "http://ci"),
-            anything,
-            anything
-          )
-          invoke_broker
-        end
-      end
-
-      context "with no consumer_app_version" do
-        before do
-          subject.options.consumer_app_version = nil
-        end
-
-        it "raises an error" do
-          expect { invoke_broker }.to raise_error ::Thor::RequiredArgumentMissingError, /--consumer-app-version/
-        end
-      end
-
-      context "with basic auth options specified" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(broker_username: 'foo', broker_password: 'bar')
-          )
-        end
-
-        it "passes in the basic auth options" do
-          expect(PactBroker::Client::PublishPacts).to receive(:call).with(
-            anything,
-            anything,
-            anything,
-            anything,
-            hash_including(basic_auth: { username: 'foo', password: 'bar' })
-          )
-          invoke_broker
-        end
-      end
-
-      context "with basic auth and a token specified" do
-        before do
-          subject.options = OpenStruct.new(
-            minimum_valid_options.merge(broker_username: 'foo', broker_password: 'bar', broker_token: 'foo')
-          )
-        end
-
-        it "raises an error" do
-          expect { invoke_broker }.to raise_error AuthError, /both/
-        end
-      end
-
-      context "when no pact files are specified" do
-        let(:file_list) { [] }
-
-        it "raises an error" do
-          expect { invoke_broker }.to raise_error ::Thor::RequiredArgumentMissingError, "No value provided for required pact_files"
-        end
-      end
-
-      context "when an error is raised publishing" do
-        before do
-          allow(PactBroker::Client::PublishPacts).to receive(:call).and_raise(PactBroker::Client::Error.new('foo'))
-        end
-
-        it "raises a PactPublicationError" do
-          expect { invoke_broker }.to raise_error PactPublicationError, /foo/
-        end
-      end
-
-      context "when the publish command is not successful" do
-        let(:success) { false }
-
-        it "raises a SystemExit" do
-          expect { invoke_broker }.to raise_error SystemExit
-        end
-      end
-    end
-  end
-end

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

@@ -1,287 +0,0 @@
-require 'pact_broker/client/cli/broker'
-require 'pact_broker/client/webhooks/create'
-require 'ostruct'
-
-module PactBroker
-  module Client
-    module CLI
-      describe Broker do
-        describe "run_webhook_commands" do
-          before do
-            allow($stdout).to receive(:puts)
-            allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_return(command_result)
-            broker.options = OpenStruct.new(options_hash)
-          end
-
-          let(:broker) { Broker.new }
-          let(:data) { 'data' }
-          let(:user) { "username:password" }
-          let(:command_result) { double('command result', success: success, message: 'message') }
-          let(:success) { true }
-          let(:header) { ["Foo: bar", "Bar: foo"] }
-
-          let(:options_hash) do
-            {
-              uuid: '9999',
-              description: "some webhook",
-              request: "POST",
-              header: header,
-              data: data,
-              user: user,
-              consumer: "consumer",
-              provider: "provider",
-              broker_base_url: "http://broker",
-              broker_username: "username",
-              broker_password: "password",
-              contract_content_changed: true,
-              verbose: true,
-              team_uuid: "1234"
-            }
-          end
-
-          let(:expected_params) do
-            {
-              uuid: '9999',
-              description: "some webhook",
-              http_method: "POST",
-              url: "http://webhook",
-              headers: { "Foo" => "bar", "Bar" => "foo"},
-              username: "username",
-              password: "password",
-              body: "data",
-              consumer: "consumer",
-              consumer_label: nil,
-              provider: "provider",
-              provider_label: nil,
-              events: ["contract_content_changed"],
-              team_uuid: "1234"
-            }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
-          end
-
-          subject { broker.run_webhook_commands "http://webhook" }
-
-          it "calls PactBroker::Client::Webhooks::Create with the webhook params" do
-            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-              expect(params).to eq expected_params
-              command_result
-            end
-            subject
-          end
-
-          it "calls PactBroker::Client::Webhooks::Create with pact broker details" do
-            expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, broker_base_url, pact_broker_client_options |
-              expect(broker_base_url).to eq "http://broker"
-              expect(pact_broker_client_options).to eq(pact_broker_base_url: 'http://broker', basic_auth: { username: "username", password: "password"}, verbose: true)
-              command_result
-            end
-            subject
-          end
-
-          context "when neither event type is selected" do
-            before do
-              options_hash.delete(:contract_content_changed)
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "raises an error" do
-              expect { subject }.to raise_error WebhookCreationError, /You must specify at least one/
-            end
-          end
-
-          context "with no basic auth" do
-            before do
-              options_hash.delete(:broker_username)
-              options_hash.delete(:broker_password)
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "calls Webhooks::Create without basic auth" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, _, pact_broker_client_options |
-                expect(pact_broker_client_options).to eq(verbose: true, pact_broker_base_url: 'http://broker')
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "with a bearer token" do
-            before do
-              options_hash.delete(:broker_username)
-              options_hash.delete(:broker_password)
-              options_hash[:broker_token] = "token"
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "calls Webhooks::Create without basic auth" do
-
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | _, _, pact_broker_client_options |
-                expect(pact_broker_client_options).to eq(verbose: true, token: "token", pact_broker_base_url: 'http://broker')
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when there are no headers specified" do
-            let(:header) { nil }
-
-            it "calls Webhooks::Create with an empty hash of headers" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:headers]).to eq({})
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when data is nil" do
-            let(:data) { nil }
-
-            it "alls Webhooks::Create with a nil body" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:body]).to be nil
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when a uuid is provided" do
-            before do
-              options_hash.merge!(uuid: '9999')
-              expected_params.merge!(uuid: '9999')
-
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "calls PactBroker::Client::Webhooks::Create with uuid in params" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params).to eq expected_params
-                command_result
-              end
-              subject
-            end
-          end
-
-          context "when a file reference is passed for the data" do
-            before do
-              FileUtils.mkdir_p "tmp"
-              File.open("tmp/body.json", "w") { |file| file << "file" }
-            end
-
-            let(:data) { "@tmp/body.json" }
-
-            it "reads the file and passes it in to the Webhooks::Create call" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params[:body]).to eq "file"
-                command_result
-              end
-              subject
-            end
-
-            context "when the file is not found" do
-
-              let(:data) { "@doesnotexist.json" }
-
-              it "raises a WebhookCreationError" do
-                expect { subject }.to raise_error WebhookCreationError, /Couldn't read data from file/
-              end
-            end
-
-            context "when successful" do
-              it "prints the message to stdout" do
-                expect($stdout).to receive(:puts).with('message')
-                subject
-              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
-                  subject
-                rescue SystemExit
-                end
-              end
-
-              it "exits with code 1" do
-                exited_with_error = false
-                begin
-                  subject
-                rescue SystemExit
-                  exited_with_error = true
-                end
-                expect(exited_with_error).to be true
-              end
-            end
-
-            context "when a PactBroker::Client::Error is raised" do
-              before do
-                allow(PactBroker::Client::Webhooks::Create).to receive(:call).and_raise(PactBroker::Client::Error, "foo")
-              end
-
-              it "raises a WebhookCreationError which does not show an ugly stack trace" do
-                expect { subject }.to raise_error(WebhookCreationError, /foo/)
-              end
-            end
-
-          end
-
-          context "when both consumer name and label options are specified" do
-            before do
-              options_hash[:consumer_label] = "consumer_label"
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "raises a WebhookCreationError" do
-              expect { subject }.to raise_error(
-                WebhookCreationError,
-                "Consumer name (--consumer) and label (--consumer_label) options are mutually exclusive"
-              )
-            end
-          end
-
-          context "when both provider name and label options are specified" do
-            before do
-              options_hash[:provider_label] = "provider_label"
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "raises a WebhookCreationError" do
-              expect { subject }.to raise_error(
-                WebhookCreationError,
-                "Provider name (--provider) and label (--provider_label) options are mutually exclusive"
-              )
-            end
-          end
-
-          context "when participant labels are specified" do
-            before do
-              options_hash.delete(:consumer)
-              options_hash.delete(:provider)
-              options_hash.merge!(consumer_label: 'consumer_label', provider_label: 'provider_label')
-              expected_params.merge!(
-                consumer: nil,
-                consumer_label: 'consumer_label',
-                provider: nil,
-                provider_label: 'provider_label'
-              )
-
-              broker.options = OpenStruct.new(options_hash)
-            end
-
-            it "calls PactBroker::Client::Webhooks::Create with participant labels in params" do
-              expect(PactBroker::Client::Webhooks::Create).to receive(:call) do | params, _, _ |
-                expect(params).to eq expected_params
-                command_result
-              end
-              subject
-            end
-          end
-        end
-      end
-    end
-  end
-end