pact_broker-client 1.32.0 → 1.37.0

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

@@ -1,29 +1,54 @@
+require 'pact_broker/client/matrix/resource'
 require 'pact_broker/client/matrix/text_formatter'
 
 module PactBroker
   module Client
     describe Matrix::TextFormatter do
-      let(:matrix_lines) { JSON.parse(File.read('spec/support/matrix.json'), symbolize_names: true)[:matrix] }
+      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
-      subject { Matrix::TextFormatter.call(matrix: matrix_lines).split("\n").collect(&:strip).join("\n") }
+      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 eq expected_matrix_lines
+          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_lines) { [{}] }
+        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
+          line_2[:verificationResult] = nil
+          line_3[:verificationResult][:success] = false
+          [line_1, line_2, line_3]
+        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/publish_pacts_spec.rb

@@ -23,6 +23,7 @@ module PactBroker
         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(PublishPacts).to receive(:create_index_entry_point).and_return(index_entry_point)
       end
 
       after do
@@ -34,11 +35,23 @@ module PactBroker
       let(:pact_file_paths) { ['spec/pacts/consumer-provider.json']}
       let(:consumer_version) { "1.2.3" }
       let(:tags) { nil }
-      let(:pact_hash) { {consumer: {name: 'Consumer'}, provider: {name: 'Provider'}, interactions: [] } }
-      let(:pact_hash_2) { {consumer: {name: 'Foo'}, provider: {name: 'Bar'}, interactions: [] } }
+      let(:branch) { nil }
+      let(:build_url) { nil }
+      let(:version_required) { false }
+      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,
+          version_required: version_required
+        }
+      end
       let(:pact_broker_client_options) do
         {
           basic_auth: {
@@ -47,8 +60,11 @@ module PactBroker
           }
         }
       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 }
 
-      subject { PublishPacts.new(pact_broker_base_url, pact_file_paths, consumer_version, tags, pact_broker_client_options) }
+      subject { PublishPacts.new(pact_broker_base_url, pact_file_paths, consumer_version_params, pact_broker_client_options) }
 
       describe "call" do
         it "creates a PactBroker Client" do
@@ -62,12 +78,12 @@ module PactBroker
         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).to be true
           end
@@ -142,6 +158,15 @@ module PactBroker
           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
@@ -164,8 +189,17 @@ module PactBroker
             subject.call
           end
 
-          context "when an error occurs tagging the pact" do
+          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)
@@ -184,7 +218,6 @@ module PactBroker
         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")
@@ -202,7 +235,6 @@ module PactBroker
         end
 
         context "when an error occurs less than the maximum number of retries" do
-
           before do
             allow(Retry).to receive(:sleep)
             tries = 0
@@ -226,6 +258,86 @@ module PactBroker
             expect(subject.call).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" }
+
+          context "when version_required is true" do
+            let(:version_required) { true }
+
+            it "raises an error" do
+              expect { subject.call }.to raise_error PactBroker::Client::Error
+            end
+          end
+        end
+
+        context "when the broker supports creation of a version with a branch" do
+          before do
+            allow(version_link).to receive(:expand).and_return(version_link)
+            allow(version_resource).to receive(:assert_success!).and_return(version_resource)
+            allow(version_resource).to receive_message_chain(:response, :status).and_return(version_creation_response_status)
+          end
+          let(:can_create_version) { true }
+          let(:version_link) { instance_double("PactBroker::Client::Hal::Link", put: version_resource) }
+          let(:version_resource) { instance_double("PactBroker::Client::Hal::Entity") }
+          let(:version_creation_response_status) { 201 }
+
+          before do
+            allow(index_resource).to receive(:_link).and_return(version_link)
+          end
+
+          context "when there is a branch, build_url or tags specified" do
+            let(:tags) { ["dev"] }
+            let(:branch) { ["main"] }
+            let(:build_url) { "build_url" }
+
+            it "creates a version with the branch, build_url and tags" do
+              expect(index_resource).to receive(:_link)
+              expect(version_link).to receive(:expand).with(pacticipant: "Consumer", version: "1.2.3")
+              expect(version_link).to receive(:put).with(branch: branch, buildUrl: build_url)
+              subject.call
+            end
+
+            context "when there is a branch but no tags" do
+              let(:tags) { [] }
+
+              it "does not set the tags, as this would overwrite the existing ones - not sure about this implementation" do
+                expect(version_link).to receive(:put).with(branch: branch, buildUrl: build_url)
+                subject.call
+              end
+            end
+
+            context "when the version response status is 201" do
+              it "puts a message indicating the version was created" do
+                expect($stdout).to receive(:puts).with(/Created/)
+                subject.call
+              end
+            end
+
+            context "when the version response status is 200" do
+              let(:version_creation_response_status) { 200 }
+
+              it "puts a message indicating the version was replaced" do
+                expect($stdout).to receive(:puts).with(/Replaced/)
+                subject.call
+              end
+            end
+          end
+
+          context "when there is no branch, tags or build_url specified" do
+            before do
+              allow(Retry).to receive(:while_error) { |&block| block.call }
+            end
+            let(:tags) { [] }
+            let(:branch) { nil }
+            let(:build_url) { nil }
+
+            it "does not create a version resource" do
+              expect(index_resource).to_not receive(:_link)
+              subject.call
+            end
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,6 @@ require 'pact_broker/client/tasks/publication_task'
 require 'pact_broker/client/publish_pacts'
 
 module PactBroker::Client
-
   describe PublicationTask do
 
     before do
@@ -22,7 +21,6 @@ module PactBroker::Client
     let(:pattern) { "spec/pacts/*.json" }
 
     describe "default task" do
-
       before :all do
         PactBroker::Client::PublicationTask.new do | task |
           task.consumer_version = '1.2.3'
@@ -31,7 +29,7 @@ module PactBroker::Client
 
       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, '1.2.3', [], {}).and_return(publish_pacts)
+          expect(PactBroker::Client::PublishPacts).to receive(:new).with('http://pact-broker', pact_file_list, { number: '1.2.3', branch: "foo", tags: [], version_required: false}, {}).and_return(publish_pacts)
           expect(publish_pacts).to receive(:call).and_return(true)
           Rake::Task['pact:publish'].execute
         end
@@ -54,7 +52,7 @@ module PactBroker::Client
       end
 
       it "invokes PublishPacts with the write method set" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with('http://pact-broker', pact_file_list, '1.2.3', [], {write: :merge}).and_return(publish_pacts)
+        expect(PactBroker::Client::PublishPacts).to receive(:new).with('http://pact-broker', pact_file_list, { number: "1.2.3", branch: "foo", tags: [], version_required: false }, {write: :merge}).and_return(publish_pacts)
         expect(publish_pacts).to receive(:call).and_return(true)
         Rake::Task['pact:publish:merge'].execute
       end
@@ -65,17 +63,98 @@ module PactBroker::Client
         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 "invokes PublishPacts with the git branch name as a tag" do
-        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, anything, ['bar', 'foo'], anything).and_return(publish_pacts)
+      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).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.consumer_version = '1.2.3'
+          task.auto_detect_version_properties = true
+        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_auto_detect_true'].execute
+      end
+
+      it "invokes PublishPacts with the branch name" do
+        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(branch: "foo"), 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 branch is specified" do
+      before :all do
+        PactBroker::Client::PublicationTask.new(:git_branch_auto_detect_true_with_branch) do | task |
+          task.consumer_version = '1.2.3'
+          task.auto_detect_version_properties = true
+          task.branch = "main"
+        end
+      end
+
+      it "does not get the branch name" do
+        expect(PactBroker::Client::Git).to_not receive(:branch)
+        Rake::Task['pact:publish:git_branch_auto_detect_true_with_branch'].execute
+      end
+
+      it "invokes PublishPacts with the specified branch name" do
+        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(branch: "main"), anything).and_return(publish_pacts)
+        Rake::Task['pact:publish:git_branch_auto_detect_true_with_branch'].execute
+      end
+    end
+
+    context "when auto_detect_version_properties is explicitly set to false" do
+      before :all do
+        PactBroker::Client::PublicationTask.new(:git_branch_auto_detect_false) do | task |
+          task.consumer_version = '1.2.3'
+          task.auto_detect_version_properties = false
+        end
+      end
+
+      it "does not get the git branch name" do
+        expect(PactBroker::Client::Git).to_not receive(:branch)
+        Rake::Task['pact:publish:git_branch_auto_detect_false'].execute
+      end
+
+      it "invokes PublishPacts without the branch name" do
+        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_not_including(branch: "foo"), anything).and_return(publish_pacts)
+        Rake::Task['pact:publish:git_branch_auto_detect_false'].execute
+      end
+    end
+
+    context "when auto_detect_version_properties is left as its default" do
+      before :all do
+        PactBroker::Client::PublicationTask.new(:git_branch_auto_detect_default) do | task |
+          task.consumer_version = '1.2.3'
+        end
+      end
+
+      it "gets the git branch name" do
+        expect(PactBroker::Client::Git).to receive(:branch).with(raise_error: false)
+        Rake::Task['pact:publish:git_branch_auto_detect_default'].execute
+      end
+
+      it "invokes PublishPacts with the branch name" do
+        expect(PactBroker::Client::PublishPacts).to receive(:new).with(anything, anything, hash_including(branch: "foo"), anything).and_return(publish_pacts)
+        Rake::Task['pact:publish:git_branch_auto_detect_default'].execute
+      end
+    end
+
     describe "custom task" do
 
       before :all do
@@ -98,10 +177,9 @@ module PactBroker::Client
 
       it "invokes PublishPacts with the customised values" do
         expect(PactBroker::Client::PublishPacts).to receive(:new).with(
-          @pact_broker_base_url, 
-          pact_file_list, 
-          '1.2.3', 
-          [@tag], 
+          @pact_broker_base_url,
+          pact_file_list,
+          { number: "1.2.3", tags: [@tag], branch: "foo", version_required: false},
           { basic_auth: @pact_broker_basic_auth, token: @pact_broker_token }
         )
         expect(publish_pacts).to receive(:call).and_return(true)

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

@@ -5,7 +5,6 @@ module PactBroker
     class Versions
       describe Describe do
         describe ".call" do
-
           let(:versions_client) do
             instance_double('PactBroker::Client::Versions', latest: version_hash)
           end

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

@@ -0,0 +1,82 @@
+require 'pact_broker/client/versions/record_deployment'
+
+module PactBroker
+  module Client
+    class Versions
+      describe RecordDeployment do
+        describe ".call" do
+          let(:broker_base_url) { "http://broker" }
+          let(:index_body_hash) do
+            {
+              _links: {}
+            }
+          end
+          let!(:index_request) do
+            stub_request(:get, broker_base_url).to_return(status: 200, body: index_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+          end
+
+          let(:replaced_previous_deployed_version) { true }
+
+          let(:params) do
+            {
+              pacticipant_name: "Foo",
+              version_number: "1",
+              environment_name: "test",
+              replaced_previous_deployed_version: replaced_previous_deployed_version,
+              output: "text"
+            }
+          end
+
+          let(:pact_broker_client_options) { {} }
+
+          subject { RecordDeployment.call(params, broker_base_url, pact_broker_client_options) }
+
+          context "when the pb:environments relation does not exist" do
+            it "returns an error response" do
+              expect(subject.success).to be false
+              expect(subject.message).to include "does not support"
+            end
+          end
+
+          context "when the response headers contain Pactflow" do
+            before do
+              allow_any_instance_of(RecordDeployment).to receive(:check_if_command_supported)
+              allow_any_instance_of(RecordDeployment).to receive(:check_environment_exists)
+              allow_any_instance_of(RecordDeployment).to receive(:record_deployment)
+              allow_any_instance_of(RecordDeployment).to receive(:deployed_version_resource).and_return(deployed_version_resource)
+            end
+
+            let(:response_headers) { { "X-Pactflow-Sha" => "abc" } }
+
+            let(:deployed_version_resource) do
+              double('PactBroker::Client::Hal::Entity', response: double('response', headers: response_headers) )
+            end
+
+            it "indicates the API was Pactflow" do
+              expect(subject.message).to include "Recorded deployment of Foo version 1 to test in Pactflow"
+            end
+          end
+
+          context "when replaced_previous_deployed_version is false" do
+            before do
+              allow_any_instance_of(RecordDeployment).to receive(:check_if_command_supported)
+              allow_any_instance_of(RecordDeployment).to receive(:check_environment_exists)
+              allow_any_instance_of(RecordDeployment).to receive(:record_deployment)
+              allow_any_instance_of(RecordDeployment).to receive(:pact_broker_name).and_return("")
+            end
+
+            let(:replaced_previous_deployed_version) { false }
+
+            let(:deployed_version_resource) do
+              double('PactBroker::Client::Hal::Entity', response: double('response', headers: response_headers) )
+            end
+
+            it "does not include the message about marking the previous version as undeployed" do
+              expect(subject.message).to_not include "undeployed"
+            end
+          end
+        end
+      end
+    end
+  end
+end