pact_broker-client 1.40.0 → 1.45.0

data/lib/pact_broker/client/backports.rb

@@ -10,4 +10,13 @@ class Hash
   def compact!
     reject! {|_key, value| value == nil}
   end unless method_defined? :compact!
+
+  def except(*keys)
+    if keys.size > 4 && size > 4 # index if O(m*n) is big
+      h = {}
+      keys.each { |key| h[key] = true }
+      keys = h
+    end
+    reject { |key, _value| keys.include? key}
+  end unless method_defined? :except
 end

data/lib/pact_broker/client/base_command.rb

@@ -0,0 +1,98 @@
+require 'pact_broker/client/hal_client_methods'
+require 'pact_broker/client/error'
+require 'pact_broker/client/command_result'
+require 'term/ansicolor'
+require 'pact_broker/client/backports'
+
+module PactBroker
+  module Client
+    class BaseCommand
+      include PactBroker::Client::HalClientMethods
+
+      def self.call(params, options, pact_broker_client_options)
+        new(params, options, pact_broker_client_options).call
+      end
+
+      def initialize(params, options, pact_broker_client_options)
+        @params = params
+        @options = options
+        @pact_broker_base_url = pact_broker_client_options.fetch(:pact_broker_base_url)
+        @pact_broker_client_options = pact_broker_client_options
+      end
+
+      def call
+        check_if_command_supported
+        do_call
+      rescue PactBroker::Client::Hal::ErrorResponseReturned => e
+        handle_http_error(e)
+      rescue PactBroker::Client::Error => e
+        handle_ruby_error(e)
+      rescue StandardError => e
+        handle_ruby_error(e, verbose?)
+      end
+
+      private
+
+      attr_reader :params, :options
+      attr_reader :pact_broker_base_url, :pact_broker_client_options
+
+      def handle_http_error(e)
+        message = if json_output?
+          body = e.entity.response.raw_body
+          (body.nil? || body == "") ? "{}" : body
+        else
+          red(e.message)
+        end
+        PactBroker::Client::CommandResult.new(false, message)
+      end
+
+      def handle_ruby_error(e, include_backtrace = false)
+        PactBroker::Client::CommandResult.new(false,  error_message(e, include_backtrace))
+      end
+
+      def error_message(e, include_backtrace)
+        if json_output?
+          json_error_message(e, include_backtrace)
+        else
+          text_error_message(e, include_backtrace)
+        end
+      end
+
+      def json_error_message(e, include_backtrace)
+        error_hash = { message: e.message }
+        error_hash[:class] = e.class.name unless e.is_a?(PactBroker::Client::Error)
+        error_hash[:backtrace] = e.backtrace if include_backtrace
+        { 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") : "")
+        exception_message = e.is_a?(PactBroker::Client::Error) ? e.message : "#{e.class} - #{e.message}"
+        red(exception_message) + maybe_backtrace
+      end
+
+      def check_if_command_supported
+      end
+
+      def json_output?
+        options[:output] == "json"
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      def green(text)
+        ::Term::ANSIColor.green(text)
+      end
+
+      def red(text)
+        ::Term::ANSIColor.red(text)
+      end
+    end
+  end
+end

data/lib/pact_broker/client/can_i_deploy.rb

@@ -3,6 +3,7 @@ require 'pact_broker/client/pact_broker_client'
 require 'pact_broker/client/retry'
 require 'pact_broker/client/matrix/formatter'
 require 'term/ansicolor'
+require 'pact_broker/client/colorize_notices'
 
 module PactBroker
   module Client
@@ -32,9 +33,9 @@ module PactBroker
       def call
         create_result(fetch_matrix_with_retries)
       rescue PactBroker::Client::Error => e
-        Result.new(false, 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
@@ -45,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 = 'Computer says yes \o/ ' + message + "\n\n" + Term::ANSIColor.green(matrix.reason)
+          message = warning(matrix) + computer_says(true) + message + "\n\n" + notice_or_reason(matrix, :green)
+          message = for_dry_run(message)
         end
         message
       end
@@ -60,11 +62,36 @@ module PactBroker
       def failure_message(matrix)
         message = format_matrix(matrix)
         if format != 'json'
-          message = 'Computer says no ¯\_(ツ)_/¯ ' + message + "\n\n" + Term::ANSIColor.red(matrix.reason)
+          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")
+        else
+          Term::ANSIColor.send(reason_color, matrix.reason)
+        end
+      end
+
       def format_matrix(matrix)
         formatted_matrix = Matrix::Formatter.call(matrix, format)
         if format != 'json' && formatted_matrix.size > 0
@@ -105,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?  },
@@ -131,6 +175,14 @@ module PactBroker
           raise PactBroker::Client::Error.new("This version of the Pact Broker does not provide a count of the unknown verification results. Please upgrade your Broker to >= v2.23.4")
         end
       end
+
+      def warning(matrix)
+        if matrix_options[:ignore_selectors] && matrix_options[:ignore_selectors].any? && !matrix.supports_ignore?
+          Term::ANSIColor.yellow("WARN: This version of the Pact Broker does not support ignoring pacticipants. Please upgrade your Broker to >= 2.80.0") + "\n\n"
+        else
+          ""
+        end
+      end
     end
   end
 end

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

@@ -1,6 +1,9 @@
 require 'pact_broker/client/cli/custom_thor'
 require 'pact_broker/client/hash_refinements'
 require 'thor/error'
+require 'pact_broker/client/cli/environment_commands'
+require 'pact_broker/client/cli/deployment_commands'
+require 'pact_broker/client/cli/pacticipant_commands'
 
 module PactBroker
   module Client
@@ -13,12 +16,19 @@ module PactBroker
 
       class Broker < CustomThor
         using PactBroker::Client::HashRefinements
+        if ENV.fetch("PACT_BROKER_FEATURES", "").include?("deployments")
+          include PactBroker::Client::CLI::EnvironmentCommands
+          include PactBroker::Client::CLI::DeploymentCommands
+        end
+        include PactBroker::Client::CLI::PacticipantCommands
+
 
         desc 'can-i-deploy', ''
         long_desc File.read(File.join(__dir__, 'can_i_deploy_long_desc.txt'))
 
         method_option :pacticipant, required: true, aliases: "-a", desc: "The pacticipant name. Use once for each pacticipant being checked."
         method_option :version, required: false, aliases: "-e", desc: "The pacticipant version. Must be entered after the --pacticipant that it relates to."
+        method_option :ignore, required: false, desc: "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."
         method_option :latest, required: false, aliases: "-l", banner: '[TAG]', desc: "Use the latest pacticipant version. Optionally specify a TAG to use the latest version with the specified tag."
         method_option :to, required: false, banner: 'TAG', desc: "This is too hard to explain in a short sentence. Look at the examples.", default: nil
         method_option :to_environment, required: false, banner: 'ENVIRONMENT', desc: "The environment into which the pacticipant(s) are to be deployed", default: nil, hide: true
@@ -27,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)
@@ -34,10 +45,16 @@ module PactBroker
           require 'pact_broker/client/can_i_deploy'
 
           validate_credentials
-          selectors = VersionSelectorOptionsParser.call(ARGV)
+          selectors = VersionSelectorOptionsParser.call(ARGV).select { |s| !s[:ignore] }
+          ignore_selectors = if ENV.fetch("PACT_BROKER_FEATURES", "").include?("ignore")
+            VersionSelectorOptionsParser.call(ARGV).select { |s| s[:ignore] }
+          else
+            []
+          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 }
-          result = CanIDeploy.call(options.broker_base_url, selectors, { to_tag: options.to, to_environment: options.to_environment, limit: options.limit }, can_i_deploy_options, pact_broker_client_options)
+          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
           exit(can_i_deploy_exit_status) unless result.success
@@ -51,7 +68,7 @@ module PactBroker
         method_option :tag_with_git_branch, aliases: "-g", type: :boolean, default: false, required: false, desc: "Tag consumer version with the name of the current git branch. Default: false"
         method_option :build_url, desc: "The build URL that created the pact"
         method_option :merge, type: :boolean, default: false, require: false, desc: "If a pact already exists for this consumer version and provider, merge the contents. Useful when running Pact tests concurrently on different build nodes."
-        method_option :output, aliases: "-o", desc: "json or text", default: 'text'
+        output_option_json_or_text
         shared_authentication_options
 
         def publish(*pact_files)
@@ -148,22 +165,9 @@ module PactBroker
           puts SecureRandom.uuid
         end
 
-        desc 'create-or-update-pacticipant', 'Create or update pacticipant by name'
-        method_option :name, type: :string, required: true, desc: "Pacticipant name"
-        method_option :repository_url, type: :string, required: false, desc: "The repository URL of the pacticipant"
-        shared_authentication_options
-        verbose_option
-        def create_or_update_pacticipant(*required_but_ignored)
-          raise ::Thor::RequiredArgumentMissingError, "Pacticipant name cannot be blank" if options.name.strip.size == 0
-          require 'pact_broker/client/pacticipants/create'
-          result = PactBroker::Client::Pacticipants2::Create.call({ name: options.name, repository_url: options.repository_url }, options.broker_base_url, pact_broker_client_options)
-          $stdout.puts result.message
-          exit(1) unless result.success
-        end
-
         desc 'list-latest-pact-versions', 'List the latest pact for each integration'
         shared_authentication_options
-        method_option :output, aliases: "-o", desc: "json or table", default: 'table'
+        output_option_json_or_table
         def list_latest_pact_versions(*required_but_ignored)
           require 'pact_broker/client/pacts/list_latest_versions'
           result = PactBroker::Client::Pacts::ListLatestVersions.call(options.broker_base_url, options.output, pact_broker_client_options)
@@ -171,63 +175,6 @@ module PactBroker
           exit(1) unless result.success
         end
 
-        if ENV.fetch("PACT_BROKER_FEATURES", "").include?("deployments")
-
-          ignored_and_hidden_potential_options_from_environment_variables
-          desc "record-deployment", "Record deployment of a pacticipant version to an environment"
-          long_desc File.read(File.join(__dir__, 'record_deployment_long_desc.txt'))
-          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."
-          method_option :target, default: nil, required: false, desc: "The target of the deployment - a logical identifer that represents where the application version was deployed to. See the usage docs for information on when to use this."
-          method_option :output, aliases: "-o", desc: "json or text", default: 'text'
-          shared_authentication_options
-
-          def record_deployment
-            require 'pact_broker/client/versions/record_deployment'
-            params = {
-              pacticipant_name: options.pacticipant,
-              version_number: options.version,
-              environment_name: options.environment,
-              target: options.target,
-              output: options.output
-            }
-            result = PactBroker::Client::Versions::RecordDeployment.call(
-              params,
-              options.broker_base_url,
-              pact_broker_client_options
-            )
-            $stdout.puts result.message
-            exit(1) unless result.success
-          end
-
-          ignored_and_hidden_potential_options_from_environment_variables
-          desc "record-undeployment", "Record undeployment of (or the end of support for) a pacticipant version from an environment"
-          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."
-          method_option :output, aliases: "-o", desc: "json or text", default: 'text'
-          shared_authentication_options
-
-          def record_undeployment
-            require 'pact_broker/client/versions/record_undeployment'
-            params = {
-              pacticipant_name: options.pacticipant,
-              version_number: options.version,
-              environment_name: options.environment,
-              output: options.output
-            }
-            result = PactBroker::Client::Versions::RecordUndeployment.call(
-              params,
-              options.broker_base_url,
-              pact_broker_client_options
-            )
-            $stdout.puts result.message
-            exit(1) unless result.success
-          end
-
-        end
-
         ignored_and_hidden_potential_options_from_environment_variables
         desc 'version', "Show the pact_broker-client gem version"
         def version
@@ -339,7 +286,7 @@ module PactBroker
           end
 
           def pact_broker_client_options
-            client_options = { verbose: options.verbose }
+            client_options = { verbose: options.verbose, pact_broker_base_url: options.broker_base_url }
             client_options[:token] = options.broker_token || ENV['PACT_BROKER_TOKEN']
             if options.broker_username || ENV['PACT_BROKER_USERNAME']
               client_options[:basic_auth] = {

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

@@ -110,6 +110,18 @@ module PactBroker
           def self.verbose_option
             method_option :verbose, aliases: "-v", type: :boolean, default: false, required: false, desc: "Verbose output. Default: false"
           end
+
+          def self.output_option_json_or_text
+            method_option :output, aliases: "-o", desc: "json or text", default: 'text'
+          end
+
+          def self.output_option_json_or_table
+            method_option :output, aliases: "-o", desc: "json or table", default: 'table'
+          end
+
+          def params_from_options(keys)
+            keys.each_with_object({}) { | key, p | p[key] = options[key] }
+          end
         end
       end
     end

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

@@ -0,0 +1,94 @@
+module PactBroker
+  module Client
+    module CLI
+      module DeploymentCommands
+        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 #{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."
+            method_option :target, default: nil, required: false, desc: "Optional. The target of the deployment - a logical identifer required to differentiate deployments when there are multiple instances of the same application in an environment."
+            output_option_json_or_text
+            shared_authentication_options
+
+            def record_deployment
+              params = {
+                pacticipant_name: options.pacticipant,
+                version_number: options.version,
+                environment_name: options.environment,
+                target: options.target
+              }
+              execute_deployment_command(params, "RecordDeployment")
+            end
+
+            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."
+            output_option_json_or_text
+            shared_authentication_options
+
+            def record_undeployment
+              params = {
+                pacticipant_name: options.pacticipant,
+                environment_name: options.environment,
+                target: options.target
+              }
+              execute_deployment_command(params, "RecordUndeployment")
+            end
+
+            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."
+            output_option_json_or_text
+            shared_authentication_options
+
+            def record_release
+              params = {
+                pacticipant_name: options.pacticipant,
+                version_number: options.version,
+                environment_name: options.environment
+              }
+              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'
+                command_options = { verbose: options.verbose, output: options.output }
+                result = PactBroker::Client::Deployments.const_get(command_class_name).call(params, command_options, pact_broker_client_options)
+                $stdout.puts result.message
+                exit(1) unless result.success
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end