pact_broker-client 1.44.0 → 1.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a0a2b003221c85dee29fcab0f035344c961a676faaa63c9eb7a86837726471
-  data.tar.gz: 0356350e5894b59fde846079ed48dee78f494de755728f5c91a01a9f6df25594
+  metadata.gz: 99a06a67fbe9da6f970649c5159443669ed9ce419911e6178594944467255dd0
+  data.tar.gz: c45dcfa2fd158febe01b9094e2125b4a1637c716da3a6d11d3bd13a8ce19867c
 SHA512:
-  metadata.gz: 14ebf92314a784825a3788d5fb9e717e6b545cc2273c863095a3a43a679b24491df1e8cc8b810e4aa8a77d42cd004bcb79e76beff954d386a54f39fc00692ad7
-  data.tar.gz: 965f255b44bc7b9ca1a1bbc85c28a692167b1b08ac1e16c92d0751c8171b7d805a224cbcba7337ecaaa42f3cf85adcc1b53158318c711bf9f3af53828e9ca939
+  metadata.gz: 6da2ec04fc73a54ae53bebc62ddb5ddfe1fe1db17b1f94d22a3e195edfb756ad6330e9a99ebfeb1a6f5d20be71c92df4c16c0a808a409623b9600fb59e2e6385
+  data.tar.gz: c714b39a69e0f96ffccabe9b6bc3097c0401a6c1931a0de89e57eae7c1e0c04ef5133e1c3d124df49b2dd294bdd90fe2415baeba365e1bf44fc40b45b4602164

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+<a name="v1.45.0"></a>
+### v1.45.0 (2021-06-16)
+
+#### Features
+
+* **can-i-deploy**
+  * allow dry-run to be enabled by setting ACT_BROKER_CAN_I_DEPLOY_DRY_RUN=true	 ([0562436](/../../commit/0562436))
+  * add --dry-run option	 ([9d90c79](/../../commit/9d90c79))
+
+* add record-support-ended (feature toggled off)	 ([8f6b593](/../../commit/8f6b593))
+* update record-undeployment (feature toggled off)	 ([0c0dd15](/../../commit/0c0dd15))
+* update record-undeployment (feature toggled off)	 ([93046d5](/../../commit/93046d5))
+
 <a name="v1.44.0"></a>
 ### v1.44.0 (2021-06-09)
 

data/README.md

@@ -84,7 +84,8 @@ Options:
                 # The pacticipant version. Must be entered after the --pacticipant that it relates to.
       [--ignore=IGNORE]                    
                 # The pacticipant name to ignore. Use once for each pacticipant being ignored. 
-                A specific version can be ignored by also specifying a --version after the pacticipant name option.
+                A specific version can be ignored by also specifying a --version after the 
+                pacticipant name option.
   -l, [--latest=[TAG]]                     
                 # Use the latest pacticipant version. Optionally specify a TAG to use the 
                 latest version with the specified tag.
@@ -103,6 +104,9 @@ Options:
                 # The time between retries in seconds. Use in conjuction with --retry-while-unknown
                                            
                 # Default: 10
+      [--dry-run], [--no-dry-run]          
+                # When enabled, always exits process with a success code. Can also be enabled by setting
+                the environment variable PACT_BROKER_CAN_I_DEPLOY_DRY_RUN=true.
   -b, --broker-base-url=BROKER_BASE_URL    
                 # The base URL of the Pact Broker
   -u, [--broker-username=BROKER_USERNAME]  
@@ -113,14 +117,6 @@ Options:
                 # Pact Broker bearer token
   -v, [--verbose], [--no-verbose]          
                 # Verbose output. Default: false
-
-Description:
-  Returns exit code 0 or 1, indicating whether or not the specified application (pacticipant) versions are
-  compatible (ie. safe to deploy). Prints out the relevant pact/verification details, indicating any
-  missing or failed verification results.
-
-  The environment variables PACT_BROKER_BASE_URL, PACT_BROKER_USERNAME and PACT_BROKER_PASSWORD may be used
-  instead of their respective command line options.
 ```
 
 Returns exit code 0 or 1, indicating whether or not the specified application (pacticipant) versions are compatible (ie. safe to deploy). Prints out the relevant pact/verification details, indicating any missing or failed verification results.

data/lib/pact_broker/client/base_command.rb

@@ -65,6 +65,9 @@ module PactBroker
         { error: error_hash }.to_json
       end
 
+      def error_message_as_json(message)
+        { error: { message: message } }.to_json
+      end
 
       def text_error_message(e, include_backtrace)
         maybe_backtrace = (include_backtrace ? "\n" + e.backtrace.join("\n") : "")

data/lib/pact_broker/client/can_i_deploy.rb

@@ -33,9 +33,9 @@ module PactBroker
       def call
         create_result(fetch_matrix_with_retries)
       rescue PactBroker::Client::Error => e
-        Result.new(false, Term::ANSIColor.red(e.message))
+        Result.new(dry_run_or_false, for_dry_run(Term::ANSIColor.red(e.message)))
       rescue StandardError => e
-        Result.new(false, "Error retrieving matrix. #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}")
+        Result.new(dry_run_or_false, for_dry_run(Term::ANSIColor.red("Error retrieving matrix. #{e.class} - #{e.message}") + "\n#{e.backtrace.join("\n")}"))
       end
 
       private
@@ -46,14 +46,15 @@ module PactBroker
         if matrix.deployable?
           Result.new(true, success_message(matrix))
         else
-          Result.new(false, failure_message(matrix))
+          Result.new(dry_run_or_false, failure_message(matrix))
         end
       end
 
       def success_message(matrix)
         message = format_matrix(matrix)
         if format != 'json'
-          message = warning(matrix) + Term::ANSIColor.green('Computer says yes \o/ ') + message + "\n\n" + notice_or_reason(matrix, :green)
+          message = warning(matrix) + computer_says(true) + message + "\n\n" + notice_or_reason(matrix, :green)
+          message = for_dry_run(message)
         end
         message
       end
@@ -61,11 +62,28 @@ module PactBroker
       def failure_message(matrix)
         message = format_matrix(matrix)
         if format != 'json'
-          message = warning(matrix) + Term::ANSIColor.red('Computer says no ¯\_(ツ)_/¯ ') + message + "\n\n" + notice_or_reason(matrix, :red)
+          message = warning(matrix) + computer_says(false) + message + "\n\n" + notice_or_reason(matrix, :red)
+          message = for_dry_run(message)
         end
         message
       end
 
+      def computer_says(success)
+        if success
+          if dry_run?
+            "Computer says yes \\o/ (and maybe you don't need to enable dry run)"
+          else
+            Term::ANSIColor.green('Computer says yes \o/ ')
+          end
+        else
+          if dry_run?
+            "Computer says no ¯\\_(ツ)_/¯ (but you're ignoring this by enabling dry run)"
+          else
+            Term::ANSIColor.red("Computer says no ¯\_(ツ)_/¯")
+          end
+        end
+      end
+
       def notice_or_reason(matrix, reason_color)
         if matrix.notices
           PactBroker::Client::ColorizeNotices.call(matrix.notices).join("\n")
@@ -114,6 +132,23 @@ module PactBroker
         options[:retry_while_unknown] > 0
       end
 
+      def dry_run?
+        options[:dry_run]
+      end
+
+      def dry_run_or_false
+        dry_run? || false
+      end
+
+      def for_dry_run(lines)
+        if dry_run?
+          prefix = Term::ANSIColor.yellow("[dry-run] ")
+          lines.split("\n").collect { |line| prefix + Term::ANSIColor.uncolor(line) }.join("\n") + "\n" + prefix + "\n" + prefix + Term::ANSIColor.green("Dry run enabled - ignoring any failures")
+        else
+          lines
+        end
+      end
+
       def retry_options
         {
           condition: lambda { |matrix| !matrix.any_unknown?  },

data/lib/pact_broker/client/cli/broker.rb

@@ -37,6 +37,7 @@ module PactBroker
         method_option :retry_interval, banner: 'SECONDS', type: :numeric, default: 10, required: false, desc: "The time between retries in seconds. Use in conjuction with --retry-while-unknown"
         # Allow limit to be set manually until https://github.com/pact-foundation/pact_broker-client/issues/53 is fixed
         method_option :limit, hide: true
+        method_option :dry_run, type: :boolean, default: false, desc: "When dry-run is enabled, always exit process with a success code. Can also be enabled by setting the environment variable PACT_BROKER_CAN_I_DEPLOY_DRY_RUN=true."
         shared_authentication_options
 
         def can_i_deploy(*ignored_but_necessary)
@@ -51,7 +52,8 @@ module PactBroker
             []
           end
           validate_can_i_deploy_selectors(selectors)
-          can_i_deploy_options = { output: options.output, retry_while_unknown: options.retry_while_unknown, retry_interval: options.retry_interval }
+          dry_run = options.dry_run || ENV["PACT_BROKER_CAN_I_DEPLOY_DRY_RUN"] == "true"
+          can_i_deploy_options = { output: options.output, retry_while_unknown: options.retry_while_unknown, retry_interval: options.retry_interval, dry_run: dry_run }
           result = CanIDeploy.call(options.broker_base_url, selectors, { to_tag: options.to, to_environment: options.to_environment, limit: options.limit, ignore_selectors: ignore_selectors }, can_i_deploy_options, pact_broker_client_options)
           $stdout.puts result.message
           $stdout.flush

data/lib/pact_broker/client/cli/deployment_commands.rb

@@ -2,11 +2,15 @@ module PactBroker
   module Client
     module CLI
       module DeploymentCommands
-        HELP_URL = "https://docs.pact.io/pact_broker/recording_deployments_and_releases/"
+        RECORD_DEPLOYMENT_HELP_URL = "https://docs.pact.io/go/record-deployment"
+        RECORD_UNDEPLOYMENT_HELP_URL = "https://docs.pact.io/go/record-undeployment"
+        RECORD_RELEASE_HELP_URL = "https://docs.pact.io/go/record-release"
+        RECORD_SUPPORT_ENDED_HELP_URL = "https://docs.pact.io/go/record-support-ended"
+
 
         def self.included(thor)
           thor.class_eval do
-            desc "record-deployment", "Record deployment of a pacticipant version to an environment. See #{HELP_URL} for more information."
+            desc "record-deployment", "Record deployment of a pacticipant version to an environment. See #{RECORD_DEPLOYMENT_HELP_URL} for more information."
             method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant that was deployed."
             method_option :version, required: true, aliases: "-e", desc: "The pacticipant version number that was deployed."
             method_option :environment, required: true, desc: "The name of the environment that the pacticipant version was deployed to."
@@ -24,8 +28,8 @@ module PactBroker
               execute_deployment_command(params, "RecordDeployment")
             end
 
-            desc "record-undeployment", "Record undeployment of a pacticipant version from an environment."
-            long_desc "Note that use of this command is not required if you are deploying over a previous version, as record-deployment will handle that scenario for you. This command is only required if you are permanently removing an application instance from an environment."
+            desc "record-undeployment", "Record undeployment of a pacticipant from an environment."
+            long_desc "Note that use of this command is only required if you are permanently removing an application instance from an environment. It is not required if you are deploying over a previous version, as record-deployment will automatically mark the previously deployed version as undeployed for you. See #{RECORD_UNDEPLOYMENT_HELP_URL} for more information."
             method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant that was undeployed."
             method_option :environment, required: true, desc: "The name of the environment that the pacticipant version was undeployed from."
             method_option :target, default: nil, required: false, desc: "Optional. The target that the application is being undeployed from - a logical identifer required to differentiate deployments when there are multiple instances of the same application in an environment."
@@ -41,7 +45,7 @@ module PactBroker
               execute_deployment_command(params, "RecordUndeployment")
             end
 
-            desc "record-release", "Record release of a pacticipant version to an environment. See See #{HELP_URL} for more information."
+            desc "record-release", "Record release of a pacticipant version to an environment. See See #{RECORD_RELEASE_HELP_URL} for more information."
             method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant that was released."
             method_option :version, required: true, aliases: "-e", desc: "The pacticipant version number that was released."
             method_option :environment, required: true, desc: "The name of the environment that the pacticipant version was released to."
@@ -57,6 +61,22 @@ module PactBroker
               execute_deployment_command(params, "RecordRelease")
             end
 
+            desc "record-support-ended", "Record the end of support for a pacticipant version in an environment. See #{RECORD_SUPPORT_ENDED_HELP_URL} for more information."
+            method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant."
+            method_option :version, required: true, aliases: "-e", desc: "The pacticipant version number for which support is ended."
+            method_option :environment, required: true, desc: "The name of the environment in which the support is ended."
+            output_option_json_or_text
+            shared_authentication_options
+
+            def record_support_ended
+              params = {
+                pacticipant_name: options.pacticipant,
+                version_number: options.version,
+                environment_name: options.environment
+              }
+              execute_deployment_command(params, "RecordSupportEnded")
+            end
+
             no_commands do
               def execute_deployment_command(params, command_class_name)
                 require 'pact_broker/client/deployments'

data/lib/pact_broker/client/deployments.rb

@@ -1,4 +1,4 @@
-require 'pact_broker/client/deployments/record_deployment'
-require 'pact_broker/client/deployments/record_release'
-require 'pact_broker/client/deployments/record_undeployment'
-
+require "pact_broker/client/deployments/record_deployment"
+require "pact_broker/client/deployments/record_release"
+require "pact_broker/client/deployments/record_undeployment"
+require "pact_broker/client/deployments/record_support_ended"

data/lib/pact_broker/client/deployments/record_support_ended.rb

@@ -0,0 +1,103 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordSupportEnded < PactBroker::Client::BaseCommand
+        def initialize(params, options, pact_broker_client_options)
+          super
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @environment_name = params.fetch(:environment_name)
+          @version_number = params.fetch(:version_number)
+        end
+
+        private
+
+        def do_call
+          if unsupported_versions_resources.empty?
+            PactBroker::Client::CommandResult.new(false, error_result_message)
+          else
+            PactBroker::Client::CommandResult.new(unsupported_versions_resources.all?(&:success?), result_message)
+          end
+        end
+
+        attr_reader :pacticipant_name, :environment_name, :version_number
+
+        def currently_supported_versions_link
+          environment_resource._link("pb:currently-supported-versions") or raise PactBroker::Client::Error.new(not_supported_message)
+        end
+
+        def currently_supported_version_entities_for_pacticipant_version
+          @deployed_version_links ||= currently_supported_versions_link.get!(pacticipant: pacticipant_name, version: version_number).embedded_entities!("releasedVersions")
+        end
+
+        def unsupported_versions_resources
+          @unsupported_versions_resources ||= currently_supported_version_entities_for_pacticipant_version.collect do | entity |
+            entity._link!("self").patch(currentlySupported: false)
+          end
+        end
+
+        def action
+          "undeployment"
+        end
+
+        def environment_resource
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find!(environment_name, "No environment found with name '#{environment_name}'")
+            .get!
+        end
+
+        def result_message
+          if json_output?
+            unsupported_versions_resources.collect{ | resource | resource.response.body }.to_a.to_json
+          else
+            unsupported_versions_resources.collect do | undeployed_versions_resource |
+              if undeployed_versions_resource.success?
+                green("#{success_result_text_message(undeployed_versions_resource)} in #{pact_broker_name}.")
+              else
+                red(undeployed_versions_resource.error_message)
+              end
+            end.join("\n")
+          end
+        end
+
+        def success_result_text_message(undeployed_versions_resource)
+          "Recorded support ended for #{pacticipant_name} version #{version_number} in #{environment_name} environment"
+        end
+
+        def error_result_message
+          if json_output?
+            error_message_as_json(error_text)
+          else
+            red(error_text)
+          end
+        end
+
+        def error_text
+          if pacticipant_does_not_exist?
+            "No pacticipant with name '#{pacticipant_name}' found."
+          else
+            "#{pacticipant_name} version #{version_number} is not currently released in #{environment_name} environment. Cannot record support ended."
+          end
+        end
+
+        def not_supported_message
+          "This version of the Pact Broker does not support recording end of support. Please upgrade to version 2.80.0 or later."
+        end
+
+        def pacticipant_does_not_exist?
+          index_resource._link("pb:pacticipant") && index_resource._link("pb:pacticipant").expand(pacticipant: pacticipant_name).get.does_not_exist?
+        end
+
+        def check_if_command_supported
+          unless index_resource.can?("pb:environments")
+            raise PactBroker::Client::Error.new(not_supported_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/deployments/record_undeployment.rb

@@ -4,10 +4,7 @@ module PactBroker
   module Client
     module Deployments
       class RecordUndeployment < PactBroker::Client::BaseCommand
-
-
-
-        def initialize(params, pact_broker_base_url, pact_broker_client_options)
+        def initialize(params, options, pact_broker_client_options)
           super
           @pacticipant_name = params.fetch(:pacticipant_name)
           @environment_name = params.fetch(:environment_name)
@@ -18,26 +15,30 @@ module PactBroker
 
         def do_call
           if undeployed_versions_resources.empty?
-            check_pacticipant_exists!
-            PactBroker::Client::CommandResult.new(false, deployed_version_not_found_error_message)
+            PactBroker::Client::CommandResult.new(false, error_result_message)
           else
-            PactBroker::Client::CommandResult.new(undeployed_versions_resources.all?(:success?), result_message)
+            PactBroker::Client::CommandResult.new(undeployed_versions_resources.all?(&:success?), result_message)
           end
         end
 
-        attr_reader :pacticipant_name, :version_number, :environment_name, :target, :output
-        attr_reader :deployed_version_resource, :undeployment_entities
+        attr_reader :pacticipant_name, :environment_name, :target
 
         def currently_deployed_versions_link
           environment_resource._link("pb:currently-deployed-versions") or raise PactBroker::Client::Error.new(not_supported_message)
         end
 
-        def currently_deployed_versions_resource
-          @deployed_version_links ||= currently_deployed_versions_link.get!(pacticipant: pacticipant_name, target: target)
+        def currently_deployed_version_entities_for_pacticipant
+          @deployed_version_links ||= currently_deployed_versions_link.get!(pacticipant: pacticipant_name).embedded_entities!("deployedVersions")
+        end
+
+        def currently_deployed_version_entities_for_pacticipant_and_target
+          currently_deployed_version_entities_for_pacticipant.select do | entity |
+            entity.target == target
+          end
         end
 
         def undeployed_versions_resources
-          @undeployed_versions_resources ||= currently_deployed_versions_resource.embedded_entities("deployedVersions").collect do | entity |
+          @undeployed_versions_resources ||= currently_deployed_version_entities_for_pacticipant_and_target.collect do | entity |
             entity._link!("self").patch(currentlyDeployed: false)
           end
         end
@@ -55,12 +56,6 @@ module PactBroker
             .get!
         end
 
-        def check_pacticipant_exists!
-          if index_resource._link!("pb:pacticipant").expand(pacticipant: pacticipant_name).get.does_not_exist?
-            raise PactBroker::Client::Error.new("No pacticipant with name '#{pacticipant_name}' found")
-          end
-        end
-
         def result_message
           if json_output?
             undeployed_versions_resources.collect{ | resource | resource.response.body }.to_a.to_json
@@ -76,32 +71,40 @@ module PactBroker
         end
 
         def success_result_text_message(undeployed_versions_resource)
-          version_number = undeployed_versions_resource.embedded_entity{ | embedded_entity| embedded_entity['version'] }.number
-          message = "Recorded #{action} of #{pacticipant_name} version #{version_number} from #{environment_name} environment"
-          if target
-            message + " (target #{target})"
-          else
-            message
-          end
+          version = undeployed_versions_resource.embedded_entity{ | embedded_entity| embedded_entity && embedded_entity['version'] }
+          message = "Recorded #{action} of #{pacticipant_name}"
+          message = "#{message} version #{version.number}" if (version && version.number)
+          message = "#{message} from #{environment_name} environment"
+          message = "#{message} (target #{target})" if target
+          message
         end
 
-        def deployed_version_not_found_error_message
-          target_bit = target ? " with target '#{target}'" : ""
-          message = "#{pacticipant_name} is not currently deployed to #{environment_name}#{target_bit}. Cannot record undeployment."
-
+        def error_result_message
           if json_output?
-            { error: message }.to_json
+            error_message_as_json(error_text)
           else
-            red(message)
+            red(error_text)
           end
         end
 
+        def error_text
+          if pacticipant_does_not_exist?
+            "No pacticipant with name '#{pacticipant_name}' found."
+          else
+            if currently_deployed_version_entities_for_pacticipant.any?
+              target_does_not_match_message
+            else
+              "#{pacticipant_name} is not currently deployed to #{environment_name} environment. Cannot record undeployment."
+            end
+          end
+        end
 
-        def deployed_version_not_found_message
-          if (env_names = deployed_version_links.names).any?
-            "#{pacticipant_name} version #{version_number} is not currently deployed to #{environment_name}. It is currently deployed to: #{env_names.join(", ")}"
+        def target_does_not_match_message
+          potential_targets = currently_deployed_version_entities_for_pacticipant.collect(&:target).collect { |target| target || "<no target>"}
+          if target
+            "#{pacticipant_name} is not currently deployed to target '#{target}' in #{environment_name} environment. Please specify one of the following targets to record the undeployment from: #{potential_targets.join(", ")}"
           else
-            "#{pacticipant_name} version #{version_number} is not currently deployed to any environment."
+            "Please specify one of the following targets to record the undeployment from: #{potential_targets.join(", ")}"
           end
         end
 
@@ -109,6 +112,10 @@ module PactBroker
           "This version of the Pact Broker does not support recording undeployments. Please upgrade to version 2.80.0 or later."
         end
 
+        def pacticipant_does_not_exist?
+          index_resource._link("pb:pacticipant") && index_resource._link("pb:pacticipant").expand(pacticipant: pacticipant_name).get.does_not_exist?
+        end
+
         def check_if_command_supported
           unless index_resource.can?("pb:environments")
             raise PactBroker::Client::Error.new(not_supported_message)