pact_broker-client 1.75.3 → 1.75.4

data/spec/lib/pact_broker/client/tasks/publication_task_spec.rb

@@ -1,231 +0,0 @@
-require 'spec_helper'
-require 'pact_broker/client/tasks/publication_task'
-require 'pact_broker/client/publish_pacts'
-require 'pact_broker/client/command_result'
-
-module PactBroker::Client
-  describe PublicationTask do
-    before do
-      @consumer_version = "1.2.3"
-    end
-
-    let(:publish_pacts) { instance_double("PactBroker::ClientSupport::PublishPacts", call: result)}
-    let(:pact_file_list) { ['spec/pact/consumer-provider.json'] }
-    let(:success) { true }
-    let(:result) { instance_double(PactBroker::Client::CommandResult, success: success, message: "message")}
-
-    before do
-      allow(PactBroker::Client::PublishPacts).to receive(:new).and_return(publish_pacts)
-      allow(FileList).to receive(:[]).with(pattern).and_return(pact_file_list)
-      allow(PactBroker::Client::Git).to receive(:branch).and_return('foo')
-      allow(PactBroker::Client::Git).to receive(:commit).and_return('6.6.6')
-      allow(PactBroker::Client::Git).to receive(:build_url).and_return("build_url")
-      allow($stdout).to receive(:puts)
-    end
-
-    let(:pattern) { "spec/pacts/*.json" }
-
-    describe "default task" do
-      before :all do
-        PactBroker::Client::PublicationTask.new do | task |
-          task.consumer_version = '1.2.3'
-        end
-      end
-
-      context "when pacts are succesfully published" do
-        it "invokes PublishPacts with the default values" do
-          expect(PactBroker::Client::PublishPacts).to receive(:new).with('http://pact-broker', pact_file_list, { number: '1.2.3', branch: "foo", tags: [] }, {}, {}).and_return(publish_pacts)
-          expect(publish_pacts).to receive(:call).and_return(result)
-          Rake::Task['pact:publish'].execute
-        end
-      end
-
-      context "when a pact fails to be published" do
-        let(:success) { false }
-
-        it "raises an error" do
-          expect { Rake::Task['pact:publish'].execute }.to raise_error("One or more pacts failed to be published")
-        end
-      end
-    end
-
-    describe "merge method configuration" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:merge) do | task |
-          task.consumer_version = '1.2.3'
-          task.write_method = :merge
-        end
-      end
-
-      it "invokes PublishPacts with the write method set" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with('http://pact-broker', pact_file_list, { number: "1.2.3", branch: "foo", tags: [] }, {}, {write: :merge}).and_return(publish_pacts)
-        expect(publish_pacts).to receive(:call).and_return(result)
-        Rake::Task['pact:publish:merge'].execute
-      end
-    end
-
-    context "when tag_with_git_branch is true" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:git_branch) do | task |
-          task.consumer_version = '1.2.3'
-          task.tag_with_git_branch = true
-          task.auto_detect_version_properties = false
-          task.tags = ['bar']
-        end
-      end
-
-      it "gets the git branch name" do
-        expect(PactBroker::Client::Git).to receive(:branch).with(raise_error: true)
-        Rake::Task['pact:publish:git_branch'].execute
-      end
-
-      it "invokes PublishPacts with the git branch name as a tag" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(tags: ['bar', 'foo']), anything, anything).and_return(publish_pacts)
-        Rake::Task['pact:publish:git_branch'].execute
-      end
-    end
-
-    context "when auto_detect_version_properties is explicitly set to true" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:git_branch_auto_detect_true) do | task |
-          task.auto_detect_version_properties = true
-        end
-      end
-
-      # Don't usually put 3 expects into the one it block, but if I separate them,
-      # only the first it block passes for some reason that I can't work out.
-      it "gets the commit, build_url and branch" do
-        expect(PactBroker::Client::Git).to receive(:commit).with(raise_error: true)
-        expect(PactBroker::Client::Git).to receive(:build_url)
-        expect(PactBroker::Client::Git).to receive(:branch).with(raise_error: true)
-        Rake::Task['pact:publish:git_branch_auto_detect_true'].execute
-      end
-
-      it "invokes PublishPacts with the branch name and build URL" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(number: "6.6.6", branch: "foo", build_url: "build_url"), anything, anything).and_return(publish_pacts)
-        Rake::Task['pact:publish:git_branch_auto_detect_true'].execute
-      end
-    end
-
-    context "when auto_detect_version_properties is explicitly set to true and the auto detectable attributes are specified" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:auto_detect_true_with_attributes_specified) do | task |
-          task.auto_detect_version_properties = true
-          task.consumer_version = '1.2.3'
-          task.branch = "feat/foo"
-          task.consumer_version = "3"
-          task.build_url = "some_build"
-        end
-      end
-
-      it "does not get the commit, branch or build URL from Git" do
-        expect(PactBroker::Client::Git).to_not receive(:commit)
-        expect(PactBroker::Client::Git).to_not receive(:build_url)
-        expect(PactBroker::Client::Git).to_not receive(:branch)
-        Rake::Task['pact:publish:auto_detect_true_with_attributes_specified'].execute
-      end
-
-      it "invokes PublishPacts with the specified attributes" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(number: "3", branch: "feat/foo", build_url: "some_build"), anything, anything).and_return(publish_pacts)
-        Rake::Task['pact:publish:auto_detect_true_with_attributes_specified'].execute
-      end
-    end
-
-    context "when auto_detect_version_properties is explicitly set to false" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:auto_detect_false) do | task |
-          task.auto_detect_version_properties = false
-          task.consumer_version = '1.2.3'
-          task.branch = "feat/foo"
-          task.consumer_version = "3"
-          task.build_url = "some_build"
-        end
-      end
-
-      it "does not get the commit, branch or build URL from Git" do
-        expect(PactBroker::Client::Git).to_not receive(:commit)
-        expect(PactBroker::Client::Git).to_not receive(:build_url)
-        expect(PactBroker::Client::Git).to_not receive(:branch)
-        Rake::Task['pact:publish:auto_detect_false'].execute
-      end
-
-      it "invokes PublishPacts with the specified attributes" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(number: "3", branch: "feat/foo", build_url: "some_build"), anything, anything).and_return(publish_pacts)
-        Rake::Task['pact:publish:auto_detect_false'].execute
-      end
-    end
-
-    context "when auto_detect_version_properties is left as its default and the branch is not specified" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:auto_detect_default) do | task |
-          task.consumer_version = '1.2.3'
-        end
-      end
-
-      it "gets the git branch name but won't raise an error if it can't be determined" do
-        expect(PactBroker::Client::Git).to receive(:branch).with(raise_error: false)
-        Rake::Task['pact:publish:auto_detect_default'].execute
-      end
-
-      it "invokes PublishPacts with the branch name if found" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(branch: "foo"),anything, anything).and_return(publish_pacts)
-        Rake::Task['pact:publish:auto_detect_default'].execute
-      end
-    end
-
-    describe "custom task" do
-      before :all do
-        @pact_broker_base_url = "http://some-host"
-        @pattern = "pact/*.json"
-        @pact_broker_basic_auth = { username: 'user', password: 'pass' }
-        @pact_broker_token = 'token'
-        @tag = "dev"
-        PactBroker::Client::PublicationTask.new(:custom) do | task |
-          task.consumer_version = '1.2.3'
-          task.tag = @tag
-          task.pact_broker_base_url = @pact_broker_base_url
-          task.pattern = @pattern
-          task.pact_broker_basic_auth = @pact_broker_basic_auth
-          task.pact_broker_token = @pact_broker_token
-        end
-      end
-
-      let(:pattern) { @pattern }
-
-      it "invokes PublishPacts with the customised values" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(
-          @pact_broker_base_url,
-          pact_file_list,
-          { number: "1.2.3", tags: [@tag], branch: "foo" },
-          {},
-          { basic_auth: @pact_broker_basic_auth, token: @pact_broker_token }
-        )
-        expect(publish_pacts).to receive(:call).and_return(result)
-        Rake::Task['pact:publish:custom'].execute
-      end
-    end
-
-    describe "with no consumer version" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:no_consumer_version) do
-        end
-      end
-
-      it "raises an error" do
-        expect { Rake::Task['pact:publish:no_consumer_version'].execute }.to raise_error PactBroker::Client::Error, /consumer version/
-      end
-    end
-
-    describe "timing of block execution" do
-      before :all do
-        PactBroker::Client::PublicationTask.new(:exception) do | task |
-          raise 'A contrived exception'
-        end
-      end
-
-      it "does not execute the block passed to the publication task until the task is called" do
-        expect{ Rake::Task['pact:publish:exception'].execute }.to raise_error 'A contrived exception'
-      end
-    end
-  end
-end

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

@@ -1,174 +0,0 @@
-require "pact_broker/client/versions/create"
-
-module PactBroker
-  module Client
-    describe Versions::Create do
-      describe "#call" do
-        let(:index_body) do
-          {
-            "_links" => {
-              "pb:pacticipant-branch-version" => {
-                "href" => "http://broker/pacticipants/{pacticipant}/branches/{branch}/versions/{version}"
-              },
-              "pb:pacticipant-version-tag" => {
-                "href" => "http://broker/pacticipants/{pacticipant}/versions/{version}/tags/{tag}"
-              },
-              "pb:pacticipant-version" => {
-                "href" => "http://broker/pacticipants/{pacticipant}/versions/{version}"
-              }
-            }
-          }
-        end
-
-        let!(:index_request) do
-          stub_request(:get, "http://broker").to_return(status: 200, body: index_body.to_json, headers: { "Content-Type" => "application/hal+json" }  )
-        end
-
-        let!(:branch_request) do
-          stub_request(:put, "http://broker/pacticipants/Foo/branches/main/versions/1").to_return(status: 200, body: "{}", headers: { "Content-Type" => "application/hal+json" }  )
-        end
-
-        let!(:tag_request) do
-          stub_request(:put, "http://broker/pacticipants/Foo/versions/1/tags/dev").to_return(status: 200, body: "{}", headers: { "Content-Type" => "application/hal+json" }  )
-        end
-
-        let!(:create_version_request) do
-          stub_request(:put, "http://broker/pacticipants/Foo/versions/1").to_return(status: 200, body: { version: "created" }.to_json, headers: { "Content-Type" => "application/hal+json" }  )
-        end
-
-        let!(:get_version_request) do
-          stub_request(:get, "http://broker/pacticipants/Foo/versions/1").to_return(status: 200, body: { version: "got" }.to_json, headers: { "Content-Type" => "application/hal+json" }  )
-        end
-
-        let(:params) do
-          {
-            pacticipant_name: "Foo",
-            version_number: "1",
-            branch_name: branch_name,
-            tags: tags
-          }
-        end
-
-        let(:branch_name) { "main" }
-        let(:tags) { ["dev"] }
-
-        let(:options) do
-          {
-            verbose: "verbose",
-            output: output
-          }
-        end
-
-        let(:output) { "text" }
-
-        let(:pact_broker_client_options) do
-          {
-            token: "token",
-            pact_broker_base_url: "http://broker"
-          }
-        end
-
-        subject { PactBroker::Client::Versions::Create.call(params, options, pact_broker_client_options)}
-
-        context "with a branch and tags" do
-          it "creates a branch version" do
-            subject
-            expect(branch_request).to have_been_made
-          end
-
-          it "creates the tag" do
-            subject
-            expect(tag_request).to have_been_made
-          end
-
-          it "returns a message" do
-            expect(subject.message).to include "Created/updated pacticipant version 1 with branch main and tag(s) dev in the Pact Broker"
-            expect(subject.success).to be true
-          end
-
-          context "without output json" do
-            let(:output) { "json" }
-
-            it "returns a json message" do
-              expect(subject.message).to eq({ version: "got" }.to_json)
-            end
-          end
-        end
-
-        context "with only tags" do
-          let(:branch_name) { nil }
-
-          it "returns a message" do
-            expect(subject.message).to include "Created/updated pacticipant version 1 with tag(s) dev in the Pact Broker"
-            expect(subject.success).to be true
-          end
-
-          context "without output json" do
-            let(:output) { "json" }
-
-            it "returns a json message" do
-              expect(subject.message).to eq({ version: "got" }.to_json)
-            end
-          end
-        end
-
-        context "with only a branch" do
-          let(:tags) { nil }
-
-          it "returns a message" do
-            expect(subject.message).to include "Created/updated pacticipant version 1 with branch main in the Pact Broker"
-            expect(subject.success).to be true
-          end
-
-          context "without output json" do
-            let(:output) { "json" }
-
-            it "returns a json message" do
-              expect(subject.message).to eq({ version: "got" }.to_json)
-            end
-          end
-        end
-
-        context "with no branch or tags" do
-          let(:tags) { nil }
-          let(:branch_name) { nil }
-
-          it "creates a version" do
-            subject
-            expect(create_version_request).to have_been_made
-          end
-
-          it "returns a message" do
-            expect(subject.message).to include "Created/updated pacticipant version 1 in the Pact Broker"
-            expect(subject.success).to be true
-          end
-
-          context "without output json" do
-            let(:output) { "json" }
-
-            it "returns a json message" do
-              expect(subject.message).to eq({ version: "created" }.to_json)
-            end
-          end
-        end
-
-        context "when the Pact Broker does not support branch versions" do
-          before do
-            index_body["_links"].delete("pb:pacticipant-branch-version")
-          end
-
-          let(:index_body) do
-            {
-              "_links" => {}
-            }
-          end
-
-          it "returns an error" do
-            expect(subject.message).to include "does not support branch versions"
-            expect(subject.success).to be false
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/client/versions/describe_spec.rb

@@ -1,64 +0,0 @@
-require 'pact_broker/client/versions/describe'
-
-module PactBroker
-  module Client
-    class Versions
-      describe Describe do
-        describe ".call" do
-          let(:versions_client) do
-            instance_double('PactBroker::Client::Versions', latest: version_hash)
-          end
-
-          let(:pact_broker_base_url) { 'http://broker' }
-          let(:pact_broker_client_options) { {} }
-          let(:pact_broker_client) { instance_double('PactBroker::Client::PactBrokerClient')}
-          let(:version_hash) do
-            {
-              foo: 'bar'
-            }
-          end
-
-          let(:params) do
-            {
-              pacticipant: 'foo',
-              latest: true,
-              tag: 'bar'
-            }
-          end
-
-          let(:options) do
-            {
-              output: 'someformat'
-            }
-          end
-
-          before do
-            allow(PactBroker::Client::PactBrokerClient).to receive(:new).and_return(pact_broker_client)
-            allow(pact_broker_client).to receive_message_chain(:pacticipants, :versions).and_return(versions_client)
-            allow(Formatter).to receive(:call).and_return('formatted_output')
-          end
-
-          subject { Describe.call(params, options, pact_broker_base_url, pact_broker_client_options) }
-
-          it "invokes the versions client" do
-            expect(versions_client).to receive(:latest).with(params)
-            subject
-          end
-
-          it "formats the output" do
-            expect(Formatter).to receive(:call).with(version_hash, 'someformat')
-            subject
-          end
-
-          it "returns a successful result" do
-            expect(subject.success).to be true
-          end
-
-          it "returns a result with the formatted output as the message" do
-            expect(subject.message).to eq 'formatted_output'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'pact_broker/client/versions'
-module PactBroker
-  module Client
-    describe Versions do
-      let(:client_options) do
-        { some_option: 'option value'}
-      end
-      let(:base_url) { 'http://blah' }
-      let(:pacticipant_name) { 'Foo' }
-      let(:version_number) { '1.2.3' }
-
-      subject { Versions.new(base_url: base_url, client_options: client_options) }
-
-      describe 'pacts' do
-        it 'initializes versions with base url and client options' do
-          expect(PactBroker::Client::Pacts).to receive(:new).with(base_url: base_url, client_options: client_options)
-          subject.pacts
-        end
-      end
-
-      describe 'tag' do
-        context "when the tag has a / in it" do
-          let(:tag) { 'feat/foo' }
-          let!(:request) { stub_request(:put, "http://blah/pacticipants/Foo/versions/1.2.3/tags/feat%2Ffoo").to_return(status: 200) }
-
-          it "URL encodes the /" do
-            subject.tag(pacticipant: pacticipant_name, version: version_number, tag: tag)
-            expect(request).to have_been_made
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'pact_broker/client/webhooks/create'
-
-module PactBroker
-  module Client
-    module Webhooks
-      describe Create do
-        describe ".call" do
-          let(:index_body) do
-            {
-              "_links" => {
-                "pb:webhooks" => {
-                  "href" => "http://broker/webhooks"
-                }
-              }
-            }.to_json
-          end
-          let!(:index_request) do
-            stub_request(:get, "http://broker").with(headers: { "Authorization" => /.*/}).to_return(status: 200, body: index_body, headers: { "Content-Type" => "application/hal+json" }  )
-          end
-
-          let(:params) do
-            {
-              http_method: "POST",
-              url: "https://webhook",
-              headers: { "Foo" => "bar", "Bar" => "foo"},
-              username: "username",
-              password: "password",
-              body: "body",
-              events: ["contract_content_changed"]
-            }.tap { |it| Pact::Fixture.add_fixture(:create_webhook_params, it) }
-          end
-
-          let(:pact_broker_client_options) do
-            {
-              token: 'token',
-              verbose: 'verbose'
-            }
-          end
-
-          subject { Create.call(params, "http://broker", pact_broker_client_options) }
-
-          context "when a 405 is returned from the webhook creation request" do
-            let!(:webhook_request) do
-              stub_request(:post, "http://broker/webhooks").to_return(status: 405)
-            end
-
-            it "returns a result with success=false and a message" do
-              expect(subject.success).to be false
-              expect(subject.message).to eq Create::WEBHOOKS_WITH_OPTIONAL_PACTICICPANTS_NOT_SUPPORTED
-            end
-          end
-
-          context "when a UUID is specified and index does not contain a pb:webhook relation" do
-            subject { Create.call(params.merge(uuid: 'some-uuid'), "http://broker", pact_broker_client_options) }
-
-            it "returns a result with success=false and a message" do
-              expect(subject.success).to be false
-              expect(subject.message).to eq Create::CREATING_WEBHOOK_WITH_UUID_NOT_SUPPORTED
-            end
-          end
-
-          context "when a 400 is returned from the webhook creation request" do
-            let!(:webhook_request) do
-              stub_request(:post, "http://broker/webhooks").to_return(status: 400, body: '{"some":"error"}', headers: { "Content-Type" => "application/hal+json" })
-            end
-
-            it "returns a result with success=false" do
-              expect(subject.success).to be false
-              expect(subject.message).to match /400/
-              expect(subject.message).to match /"some":"error"/
-            end
-          end
-
-          context "when there is an empty description returned" do
-            let!(:webhook_request) do
-              stub_request(:post, "http://broker/webhooks").to_return(status: 200, body: response_body.to_json, headers: { "Content-Type" => "application/hal+json" })
-            end
-
-            let(:response_body) do
-              {
-                description: "",
-                _links: {
-                  self: {
-                    href: "href",
-                    title: "the title"
-                  }
-                }
-              }
-            end
-
-            it "uses the self title in the message instead" do
-              expect(subject.message).to include "the title"
-            end
-          end
-        end
-      end
-    end
-  end
-end