pact_broker-client 1.44.0 → 1.45.0

data/lib/pact_broker/client/hal/entity.rb

@@ -8,6 +8,7 @@ module PactBroker
   module Client
     module Hal
       class RelationNotFoundError < ::PactBroker::Client::Error; end
+      class EmbeddedEntityNotFoundError < ::PactBroker::Client::Error; end
       class ErrorResponseReturned < ::PactBroker::Client::Error
         attr_reader :entity
 
@@ -99,7 +100,17 @@ module PactBroker
 
         def embedded_entity
           embedded_ent = yield @data["_embedded"]
-          Entity.new(embedded_ent["_links"]["self"]["href"], embedded_ent, @client, response)
+          if embedded_ent
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
+          end
+        end
+
+        def embedded_entities!(key)
+          embedded_ents = (@data["_embedded"] && @data["_embedded"][key])
+          raise EmbeddedEntityNotFoundError.new("Could not find embedded entity with key '#{key}' in resource at #{@href}") unless embedded_ents
+          embedded_ents.collect do | embedded_ent |
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
+          end
         end
 
         def embedded_entities(key = nil)
@@ -109,7 +120,7 @@ module PactBroker
             yield @data["_embedded"]
           end
           embedded_ents.collect do | embedded_ent |
-            Entity.new(embedded_ent["_links"]["self"]["href"], embedded_ent, @client, response)
+            Entity.new(self_href(embedded_ent), embedded_ent, @client, response)
           end
         end
 
@@ -146,6 +157,10 @@ module PactBroker
         def assert_success!(_ignored = nil)
           self
         end
+
+        def self_href(entity_hash)
+          entity_hash["_links"] && entity_hash["_links"]["self"] && entity_hash["_links"]["self"]["href"]
+        end
       end
 
       class ErrorEntity < Entity

data/lib/pact_broker/client/pacticipants/create.rb

@@ -30,7 +30,7 @@ module PactBroker
           if json_output?
             response_entity.response.raw_body
           else
-            green(message = "Pacticipant \"#{params[:name]}\" #{action}")
+            green(message = "Pacticipant \"#{params[:name]}\" #{action} in #{pact_broker_name}")
           end
         end
 

data/lib/pact_broker/client/version.rb

@@ -1,5 +1,5 @@
 module PactBroker
   module Client
-    VERSION = '1.44.0'
+    VERSION = '1.45.0'
   end
 end

data/script/record-deployments-and-releases.sh

@@ -5,6 +5,14 @@ bundle exec bin/pact-broker create-version-tag --pacticipant Foo --version 2 --t
 bundle exec bin/pact-broker describe-version --pacticipant Foo --version 2
 bundle exec bin/pact-broker create-environment --name test
 bundle exec bin/pact-broker can-i-deploy --pacticipant Foo --version 2 --to-environment test
-bundle exec bin/pact-broker record-deployment --pacticipant Foo --version 2 --environment test --target foo
-bundle exec bin/pact-broker record-undeployment --pacticipant Foo --version 2 --environment test --target foo
-bundle exec bin/pact-broker record-release --pacticipant Foo --version 2 --environment test
+
+bundle exec bin/pact-broker record-deployment --pacticipant Foo --version 2 --environment test
+bundle exec bin/pact-broker record-deployment --pacticipant Foo --version 2 --environment test --target customer-1
+bundle exec bin/pact-broker record-deployment --pacticipant Foo --version 2 --environment test --target customer-1
+
+bundle exec bin/pact-broker record-undeployment --pacticipant Foo --environment test
+bundle exec bin/pact-broker record-undeployment --pacticipant Foo --environment test
+bundle exec bin/pact-broker record-undeployment --pacticipant Foo --environment test --target customer-1
+
+bundle exec bin/pact-broker record-release --pacticipant Foo --version 2 --environment test
+bundle exec bin/pact-broker record-support-ended --pacticipant Foo --version 2 --environment test

data/spec/fixtures/approvals/can_i_deploy_failure_dry_run.approved.txt

@@ -0,0 +1,7 @@
+[dry-run] Computer says no ¯\_(ツ)_/¯ (but you're ignoring this by enabling dry run)
+[dry-run] 
+[dry-run] text matrix
+[dry-run] 
+[dry-run] some reason
+[dry-run] 
+[dry-run] Dry run enabled - ignoring any failures

data/spec/fixtures/approvals/can_i_deploy_success_dry_run.approved.txt

@@ -0,0 +1,7 @@
+[dry-run] Computer says yes \o/ (and maybe you don't need to enable dry run)
+[dry-run] 
+[dry-run] text matrix
+[dry-run] 
+[dry-run] some reason
+[dry-run] 
+[dry-run] Dry run enabled - ignoring any failures

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

@@ -8,6 +8,7 @@ module PactBroker
       let(:version_selectors) { [{ pacticipant: "Foo", version: "1" }] }
       let(:matrix_options) { { } }
       let(:pact_broker_client_options) { { foo: 'bar' } }
+      let(:dry_run) { false }
       let(:matrix_client) { instance_double('PactBroker::Client::Matrix') }
       let(:matrix) do
         instance_double('Matrix::Resource',
@@ -23,7 +24,7 @@ module PactBroker
       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 } }
+      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 }
@@ -69,6 +70,14 @@ module PactBroker
             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
@@ -94,6 +103,18 @@ module PactBroker
             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
@@ -135,6 +156,19 @@ module PactBroker
           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
 
@@ -169,6 +203,19 @@ module PactBroker
         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
@@ -183,7 +230,20 @@ module PactBroker
         end
 
         it "returns a failure message and backtrace" do
-          expect(subject.message).to include "Error retrieving matrix. StandardError - error text\n"
+          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

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

@@ -25,7 +25,8 @@ module PactBroker
             verbose: 'verbose',
             retry_while_unknown: 1,
             retry_interval: 2,
-            limit: 1000
+            limit: 1000,
+            dry_run: false
           }
         end
 
@@ -37,7 +38,7 @@ module PactBroker
         end
 
         it "invokes the CanIDeploy service" do
-          expect(CanIDeploy).to receive(:call).with('http://pact-broker', version_selectors, { to_tag: nil, to_environment: nil, limit: 1000, ignore_selectors: []}, {output: 'table', retry_while_unknown: 1, retry_interval: 2}, { pact_broker_base_url: 'http://pact-broker', verbose: 'verbose' })
+          expect(CanIDeploy).to receive(:call).with('http://pact-broker', version_selectors, { to_tag: nil, to_environment: nil, limit: 1000, ignore_selectors: []}, {output: 'table', retry_while_unknown: 1, retry_interval: 2, dry_run: false}, { pact_broker_base_url: 'http://pact-broker', verbose: 'verbose' })
           invoke_can_i_deploy
         end
 
@@ -94,6 +95,18 @@ module PactBroker
           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, anything, hash_including(dry_run: true), 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)

data/spec/lib/pact_broker/client/deployments/record_support_ended_spec.rb

@@ -0,0 +1,208 @@
+require 'pact_broker/client/deployments/record_support_ended'
+
+module PactBroker
+  module Client
+    module Deployments
+      describe RecordSupportEnded do
+        let(:params) do
+          {
+            pacticipant_name: "Foo",
+            version_number: version_number,
+            environment_name: "test"
+          }
+        end
+        let(:version_number) { "2" }
+        let(:output) { "text" }
+        let(:options) { { output: output, verbose: true } }
+        let(:pact_broker_base_url) { "http://broker" }
+        let(:pact_broker_client_options) { { pact_broker_base_url: pact_broker_base_url } }
+
+        let(:index_body_hash) do
+          {
+            _links: {
+              :'pb:environments' => {
+                href: environments_url
+              },
+              :'pb:pacticipant' => {
+                href: pacticipant_url
+              }
+            }
+          }
+        end
+
+        let(:environments_hash) do
+          {
+            _links: {
+              :'pb:environments' => [
+                {
+                  name: "test",
+                  href: test_environment_url
+                }
+              ]
+            }
+          }
+        end
+
+        let(:environment_hash) do
+          {
+            _links: {
+              :'pb:currently-supported-versions' => {
+                href: currently_supported_versions_url
+              }
+            }
+          }
+        end
+
+        let(:supported_versions_hash) do
+          {
+            _embedded: {
+              releasedVersions: [
+                {
+                  number: "customer-1",
+                  _links: {
+                    self: {
+                      href: supported_version_url_1
+                    }
+                  }
+                },
+                {
+                  number: returned_target_2,
+                  _links: {
+                    self: {
+                      href: supported_version_url_2
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        end
+
+        let(:returned_target_2) { nil }
+        let(:supported_version_hash) do
+          {
+            _embedded: {
+              version: {
+                number: "2"
+              }
+            }
+          }
+        end
+
+        let(:environments_url) { "#{webmock_base_url}/environments" }
+        let(:test_environment_url) { "#{webmock_base_url}/environments/1234" }
+        let(:currently_supported_versions_url) { "#{webmock_base_url}/currently-deployed-versions" }
+        let(:supported_version_url_1) { "#{webmock_base_url}/deployed-version-1" }
+        let(:supported_version_url_2) { "#{webmock_base_url}/deployed-version-2" }
+        let(:pacticipant_url) { "#{webmock_base_url}/pacticipant" }
+
+        let(:webmock_base_url) { "http://broker" }
+
+        let!(:index_request) do
+          stub_request(:get, "http://broker").to_return(status: 200, body: index_body_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:environments_request) do
+          stub_request(:get, "http://broker/environments").to_return(status: 200, body: environments_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:environment_request) do
+          stub_request(:get, test_environment_url).to_return(status: 200, body: environment_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:supported_versions_request) do
+          stub_request(:get, currently_supported_versions_url + "?pacticipant=Foo&version=2").to_return(status: 200, body: supported_versions_hash.to_json, headers: { "Content-Type" => "application/hal+json" }  )
+        end
+
+        let!(:supported_version_patch_request_1) do
+          stub_request(:patch, supported_version_url_1).with(body: { currentlySupported: false}.to_json).to_return(status: 200, body: supported_version_hash.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let!(:supported_version_patch_request_2) do
+          stub_request(:patch, supported_version_url_2).with(body: { currentlySupported: false}.to_json).to_return(status: 200, body: supported_version_hash.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let!(:pacticipant_request) do
+          stub_request(:get, pacticipant_url).to_return(status: pacticipant_request_status, body: {}.to_json, headers: { "Content-Type" => "application/hal+json" })
+        end
+
+        let(:pacticipant_request_status) { 200 }
+
+        subject { RecordSupportEnded.call(params, options, pact_broker_client_options) }
+
+        its(:success) { is_expected.to eq true }
+        its(:message) { is_expected.to include "Recorded support ended for Foo version 2 in test environment in the Pact Broker" }
+
+        context "when there is no pb:environments relation in the index" do
+          let(:index_body_hash) do
+            {
+              _links: {}
+            }
+          end
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "support" }
+        end
+
+        context "when output is json" do
+          let(:output) { "json" }
+          its(:message) { is_expected.to eq [supported_version_hash, supported_version_hash].to_json }
+        end
+
+        context "when there is an error returned from one of the supported version updates (there should only ever be one supported version, but testing just for the sake of it)" do
+          let!(:supported_version_patch_request_2) do
+            stub_request(:patch, supported_version_url_2).to_return(status: 400, body: { errors: { foo: ["some error"]}}.to_json, headers: { "Content-Type" => "application/hal+json" })
+          end
+
+          let(:returned_target_2) { "customer-1" }
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "Recorded" }
+          its(:message) { is_expected.to include "some error" }
+        end
+
+        context "when there is no currently-deployed-versions relation in the environment resource" do
+          let(:environment_hash) do
+            {
+              _links: {}
+            }
+          end
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include "support" }
+        end
+
+        context "when there is no matching supported versions" do
+          let(:supported_versions_hash) do
+            {
+              _embedded: {
+                releasedVersions: []
+              }
+            }
+          end
+
+          let(:expected_message) { "Foo version 2 is not currently released in test environment. Cannot record support ended." }
+
+          its(:success) { is_expected.to be false }
+          its(:message) { is_expected.to include expected_message }
+
+          context "when there are no supported versions for the pacticipant" do
+            context "when the pacticipant does not exist" do
+              let(:pacticipant_request_status) { 404 }
+
+              its(:success) { is_expected.to be false }
+              its(:message) { is_expected.to include "No pacticipant with name 'Foo' found" }
+            end
+          end
+
+          context "when output is json" do
+            let(:output) { "json" }
+
+            its(:message) { is_expected.to eq({ error: { message: expected_message } }.to_json) }
+          end
+        end
+
+      end
+    end
+  end
+end