pact_broker-client 1.44.0 → 1.47.1

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

@@ -0,0 +1,93 @@
+module PactBroker
+  module Client
+    module CLI
+      module MatrixCommands
+
+        def self.included(thor)
+          thor.class_eval do
+            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
+            method_option :output, aliases: "-o", desc: "json or table", default: "table"
+            method_option :retry_while_unknown, banner: "TIMES", type: :numeric, default: 0, required: false, desc: "The number of times to retry while there is an unknown verification result (ie. the provider verification is likely still running)"
+            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)
+              require "pact_broker/client/cli/version_selector_options_parser"
+              require "pact_broker/client/can_i_deploy"
+
+              validate_credentials
+              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)
+              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, verbose: options.verbose }
+              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
+            end
+
+            if ENV.fetch("PACT_BROKER_FEATURES", "").include?("verification_required")
+
+              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 :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 :in_environment, required: false, banner: "ENVIRONMENT", desc: "The environment into which the pacticipant(s) are to be deployed", default: nil, hide: true
+              method_option :output, aliases: "-o", desc: "json or table", default: "table"
+
+              shared_authentication_options
+              desc "verification-required", "Checks if there is a verification required between the given pacticipant versions"
+              def verification_required(*ignored_but_necessary)
+                require "pact_broker/client/cli/version_selector_options_parser"
+                require "pact_broker/client/verification_required"
+
+                validate_credentials
+                selectors = VersionSelectorOptionsParser.call(ARGV)
+                validate_can_i_deploy_selectors(selectors)
+                verification_required_options = { output: options.output, verbose: options.verbose, retry_while_unknown: 0 }
+                result = VerificationRequired.call(options.broker_base_url, selectors, { to_tag: options.to, to_environment: options.in_environment, ignore_selectors: [] }, verification_required_options, pact_broker_client_options)
+                $stdout.puts result.message
+                $stdout.flush
+                exit(1) unless result.success
+              end
+
+            end
+
+            no_commands do
+              def can_i_deploy_exit_status
+                exit_code_string = ENV.fetch("PACT_BROKER_CAN_I_DEPLOY_EXIT_CODE_BETA", "")
+                if exit_code_string =~ /^\d+$/
+                  $stderr.puts "Exiting can-i-deploy with configured exit code #{exit_code_string}"
+                  exit_code_string.to_i
+                else
+                  1
+                end
+              end
+
+              def validate_can_i_deploy_selectors selectors
+                pacticipants_without_versions = selectors.select{ |s| s[:version].nil? && s[:latest].nil? && s[:tag].nil? }.collect{ |s| s[:pacticipant] }
+                raise ::Thor::RequiredArgumentMissingError, "The version must be specified using `--version VERSION`, `--latest`, `--latest TAG`, or `--all TAG` for pacticipant #{pacticipants_without_versions.join(", ")}" if pacticipants_without_versions.any?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module PactBroker
+  module Client
+    module CLI
+      # Thor::Error will have its backtrace hidden
+      class WebhookCreationError < ::Thor::Error; end
+
+      module WebhookCommands
+        def self.included(thor)
+          thor.class_eval do
+
+            no_commands do
+              def self.shared_options_for_webhook_commands
+                method_option :request, banner: "METHOD", aliases: "-X", desc: "Webhook HTTP method", required: true
+                method_option :header, aliases: "-H", type: :array, desc: "Webhook Header"
+                method_option :data, aliases: "-d", desc: "Webhook payload (file or string)"
+                method_option :user, aliases: "-u", desc: "Webhook basic auth username and password eg. username:password"
+                method_option :consumer, desc: "Consumer name"
+                method_option :provider, desc: "Provider name"
+                method_option :description, desc: "Webhook description"
+                method_option :contract_content_changed, type: :boolean, desc: "Trigger this webhook when the pact content changes"
+                method_option :contract_published, type: :boolean, desc: "Trigger this webhook when a pact is published"
+                method_option :provider_verification_published, type: :boolean, desc: "Trigger this webhook when a provider verification result is published"
+                method_option :provider_verification_failed, type: :boolean, desc: "Trigger this webhook when a failed provider verification result is published"
+                method_option :provider_verification_succeeded, type: :boolean, desc: "Trigger this webhook when a successful provider verification result is published"
+                method_option :team_uuid, banner: "UUID", desc: "UUID of the Pactflow team to which the webhook should be assigned (Pactflow only)"
+                shared_authentication_options
+              end
+            end
+
+            shared_options_for_webhook_commands
+
+            desc 'create-webhook URL', 'Creates a webhook using the same switches as a curl request.'
+            long_desc File.read(File.join(File.dirname(__FILE__), 'create_webhook_long_desc.txt'))
+            def create_webhook webhook_url
+              run_webhook_commands webhook_url
+            end
+
+            shared_options_for_webhook_commands
+            method_option :uuid, type: :string, required: true, desc: "Specify the uuid for the webhook"
+
+            desc 'create-or-update-webhook URL', 'Creates or updates a webhook with a provided uuid and using the same switches as a curl request.'
+            long_desc File.read(File.join(File.dirname(__FILE__), 'create_or_update_webhook_long_desc.txt'))
+            def create_or_update_webhook webhook_url
+              run_webhook_commands webhook_url
+            end
+
+            desc 'test-webhook', 'Test the execution of a webhook'
+            method_option :uuid, type: :string, required: true, desc: "Specify the uuid for the webhook"
+            shared_authentication_options
+            def test_webhook
+              require 'pact_broker/client/webhooks/test'
+              result = PactBroker::Client::Webhooks::Test.call(options, pact_broker_client_options)
+              $stdout.puts result.message
+            end
+
+            no_commands do
+
+              def parse_webhook_events
+                events = []
+                events << 'contract_content_changed' if options.contract_content_changed
+                events << 'contract_published' if options.contract_published
+                events << 'provider_verification_published' if options.provider_verification_published
+                events << 'provider_verification_succeeded' if options.provider_verification_succeeded
+                events << 'provider_verification_failed' if options.provider_verification_failed
+                events
+              end
+
+              def parse_webhook_options(webhook_url)
+                events = parse_webhook_events
+
+                if events.size == 0
+                  raise WebhookCreationError.new("You must specify at least one of --contract-content-changed, --contract-published, --provider-verification-published, --provider-verification-succeeded or --provider-verification-failed")
+                end
+
+                username = options.user ? options.user.split(":", 2).first : nil
+                password = options.user ? options.user.split(":", 2).last : nil
+
+                headers = (options.header || []).each_with_object({}) { | header, headers | headers[header.split(":", 2).first.strip] = header.split(":", 2).last.strip }
+
+                body = options.data
+                if body && body.start_with?("@")
+                  filepath = body[1..-1]
+                  begin
+                    body = File.read(filepath)
+                  rescue StandardError => e
+                    raise WebhookCreationError.new("Couldn't read data from file \"#{filepath}\" due to #{e.class} #{e.message}")
+                  end
+                end
+
+                {
+                  uuid: options.uuid,
+                  description: options.description,
+                  http_method: options.request,
+                  url: webhook_url,
+                  headers: headers,
+                  username: username,
+                  password: password,
+                  body: body,
+                  consumer: options.consumer,
+                  provider: options.provider,
+                  events: events,
+                  team_uuid: options.team_uuid
+                }
+              end
+
+              def run_webhook_commands webhook_url
+                require 'pact_broker/client/webhooks/create'
+
+                validate_credentials
+                result = PactBroker::Client::Webhooks::Create.call(parse_webhook_options(webhook_url), options.broker_base_url, pact_broker_client_options)
+                $stdout.puts result.message
+                exit(1) unless result.success
+              rescue PactBroker::Client::Error => e
+                raise WebhookCreationError, "#{e.class} - #{e.message}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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-released-versions", "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)
+          environment_resource._link("pb:currently-deployed-deployed-versions", "pb:currently-deployed-versions") or raise PactBroker::Client::Error.new(not_supported_message)
+        end
+
+        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_versions_resource
-          @deployed_version_links ||= currently_deployed_versions_link.get!(pacticipant: pacticipant_name, target: target)
+        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)