pact_broker-client 1.40.0 → 1.45.0

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

@@ -0,0 +1,70 @@
+module PactBroker
+  module Client
+    module CLI
+      module EnvironmentCommands
+        ENVIRONMENT_PARAM_NAMES = [:name, :display_name, :production, :contact_name, :contact_email_address]
+
+        def self.included(thor)
+          thor.class_eval do
+            def self.shared_environment_options(name_required: false)
+              method_option :name, required: name_required, desc: "The uniquely identifying name of the environment as used in deployment code"
+              method_option :display_name, desc: "The display name of the environment"
+              method_option :production, type: :boolean, default: false, desc: "Whether or not this environment is a production environment. Default: false"
+              method_option :contact_name, required: false, desc: "The name of the team/person responsible for this environment"
+              method_option :contact_email_address, required: false, desc: "The email address of the team/person responsible for this environment"
+              output_option_json_or_text
+            end
+
+            desc "create-environment", "Create an environment resource in the Pact Broker to represent a real world deployment or release environment."
+            shared_environment_options(name_required: true)
+            shared_authentication_options
+            def create_environment
+              execute_environment_command(params_from_options(ENVIRONMENT_PARAM_NAMES), "CreateEnvironment")
+            end
+
+            desc "update-environment", "Update an environment resource in the Pact Broker."
+            method_option :uuid, required: true, desc: "The UUID of the environment to update"
+            shared_environment_options(name_required: false)
+            shared_authentication_options
+            def update_environment
+              execute_environment_command(params_from_options(ENVIRONMENT_PARAM_NAMES + [:uuid]), "UpdateEnvironment")
+            end
+
+            desc "describe-environment", "Describe an environment"
+            method_option :uuid, required: true, desc: "The UUID of the environment to describe"
+            method_option :output, aliases: "-o", desc: "json or text", default: 'text'
+            shared_authentication_options
+            def describe_environment
+              execute_environment_command(params_from_options([:uuid]), "DescribeEnvironment")
+            end
+
+            desc "list-environments", "List environment"
+            method_option :output, aliases: "-o", desc: "json or text", default: 'text'
+            shared_authentication_options
+            def list_environments
+              execute_environment_command({}, "ListEnvironments")
+            end
+
+            desc "delete-environment", "Delete an environment"
+            method_option :uuid, required: true, desc: "The UUID of the environment to delete"
+            method_option :output, aliases: "-o", desc: "json or text", default: 'text'
+            shared_authentication_options
+            def delete_environment
+              execute_environment_command(params_from_options([:uuid]), "DeleteEnvironment")
+            end
+
+            no_commands do
+              def execute_environment_command(params, command_class_name)
+                require 'pact_broker/client/environments'
+                command_options = { verbose: options.verbose, output: options.output }
+                result = PactBroker::Client::Environments.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

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

@@ -0,0 +1,53 @@
+module PactBroker
+  module Client
+    module CLI
+      module PacticipantCommands
+        PACTICIPANT_PARAM_NAMES = [:name, :display_name, :repository_url]
+
+        def self.included(thor)
+          thor.class_eval do
+            desc 'create-or-update-pacticipant', 'Create or update pacticipant by name'
+            method_option :name, type: :string, required: true, desc: "Pacticipant name"
+            method_option :display_name, type: :string, desc: "Display name"
+            method_option :repository_url, type: :string, required: false, desc: "The repository URL of the pacticipant"
+            output_option_json_or_text
+            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
+              execute_pacticipant_command(params_from_options(PACTICIPANT_PARAM_NAMES), 'Create')
+            end
+
+            desc 'list-pacticipants', 'List pacticipants'
+            output_option_json_or_text
+            shared_authentication_options
+            verbose_option
+            def list_pacticipants
+              execute_pacticipant_command(params_from_options(PACTICIPANT_PARAM_NAMES), 'List')
+            end
+
+            desc 'describe-pacticipant', "Describe a pacticipant"
+            method_option :name, type: :string, required: true, desc: "Pacticipant name"
+            output_option_json_or_text
+            shared_authentication_options
+            verbose_option
+            def describe_pacticipant
+              execute_pacticipant_command({ name: options.name }, 'Describe')
+            end
+
+            no_commands do
+              def execute_pacticipant_command(params, command_class_name)
+                require 'pact_broker/client/pacticipants'
+                command_options = { verbose: options.verbose, output: options.output }
+                result = PactBroker::Client::Pacticipants2.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

data/lib/pact_broker/client/cli/record_deployment_long_desc.txt

@@ -1,55 +0,0 @@
-The record-deployment command is used to allow the Pact Broker to keep track of which version(s) of an application are currently deployed in each environment. It is used to keep track of applications that are deployed to known instances. If you are releasing a client library or mobile application to a repository or application store, please use record-release instead.
-
-## Examples
-
-
-record-deployment --pacticipant Foo --version 6897aa95e --environment production
-record-deployment --pacticipant Foo --version 6897aa95e --environment production --target blue
-record-deployment --pacticipant Foo --version 6897aa95e --environment production --target green
-
-## Target
-
-The "target" field is used to distinguish between deployed versions of an application within the same environment, and most importantly, to identify which previously deployed version has been replaced by the current deployment. The Pact Broker only allows one unique combination of pacticipant/environment/target to be considered the "currently deployed" one, and any call to record a deployment will cause the previously deployed version with the same pacticipant/environment/target to be automatically marked as undeployed (mimicking the real world process of "deploying over" a previous version).
-
-### Use cases
-
-#### There is a single instance of an application deployed within an environment and deployments of integrated applications are NOT likely to happen during the deployment window of this application
-
-eg.
-
-* the window of time when there are multiple versions in prod is small
-* or there aren't many other integrations
-* or deployments happen rarely
-* or the same team controls all the deployments and generally only runs one deployment at a time
-
-In this case, there is no need to specify a target. The call to record deployment should be done at the end of the deployment and it will automatically mark the version of Foo that was previously the currently deployed version as undeployed. Only one version of the pacticipant is ever considered to be currently deployed at a time.
-
-eg.
-
-# actual call to deploy here...
-record-deployment --pacticipant Foo --version 6897aa95e --environment production
-
-#### There is a single instance of an application deployed within an environment and but deployments of integrated applications ARE likely to happen during the deployment window of this application
-
-eg.
-* the window of time when there are multiple versions in prod is large
-* or there are many integrations
-* or deployments happen often
-* or there are many different teams deploying and deployments aren't coordinated
-
-To allow multiple versions to be considered currently deployed at the same time, use two different targets, and call the first record-deployment at the start of the deployment process and a second one at the end.
-
-eg.
-
-This will use the targets "blue" and "green" to model stages of the deployment.
-
-record-deployment --pacticipant Foo --version 6897aa95e --environment production --target blue
-# actual call to deploy here...
-record-deployment --pacticipant Foo --version 6897aa95e --environment production --target green
-
-After the first call to record-deployment, there will be two versions considered currently deployed - the "blue" one that was just recorded, and the one from the previous "green" deployment. After the second call to record-deployment, there is only one version considered currently deployed - both "blue" and "green" targets will be have version 6897aa95e deployed to them.
-
-
-#### There are multiple permanent application versions deployed to the same environment
-
-TBC

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

@@ -12,6 +12,8 @@ module PactBroker
             case word
             when "--pacticipant", "-a"
               selectors << {}
+            when "--ignore"
+              selectors << { ignore: true }
             when "--latest", "-l"
               selectors << { pacticipant: nil } if selectors.empty?
               selectors.last[:latest] = true
@@ -21,6 +23,8 @@ module PactBroker
               case previous_option
               when "--pacticipant", "-a"
                 selectors.last[:pacticipant] = word
+              when "--ignore"
+                selectors.last[:pacticipant] = word
               when "--version", "-e"
                 selectors << { pacticipant: nil } if selectors.empty?
                 selectors.last[:version] = word

data/lib/pact_broker/client/colorize_notices.rb

@@ -0,0 +1,31 @@
+require 'term/ansicolor'
+
+module PactBroker
+  module Client
+    class ColorizeNotices
+      def self.call(notices)
+        notices.collect do | notice |
+          colorized_message(notice)
+        end
+      end
+
+      def self.colorized_message(notice)
+        color = color_for_type(notice.type)
+        if color
+          ::Term::ANSIColor.color(color, notice.text || '')
+        else
+          notice.text
+        end
+      end
+
+      def self.color_for_type(type)
+        case type
+        when "warning", "prompt" then "yellow"
+        when "error", "danger" then :red
+        when "success" then :green
+        else nil
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/deployments.rb

@@ -0,0 +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_support_ended"

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

@@ -0,0 +1,38 @@
+require 'pact_broker/client/deployments/record_release'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordDeployment < PactBroker::Client::Deployments::RecordRelease
+        def initialize(params, options, pact_broker_client_options)
+          super
+          @target = params.fetch(:target)
+        end
+
+        private
+
+        attr_reader :target
+
+        def action
+          "deployment"
+        end
+
+        def action_relation_name
+          "pb:record-deployment"
+        end
+
+        def record_action_request_body
+          { target: target }.compact
+        end
+
+        def result_text_message
+          if target
+            "#{super} (target #{target})"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordRelease < PactBroker::Client::BaseCommand
+        def initialize(params, options, pact_broker_client_options)
+          super
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @version_number = params.fetch(:version_number)
+          @environment_name = params.fetch(:environment_name)
+        end
+
+        private
+
+        attr_reader :pacticipant_name, :version_number, :environment_name
+        attr_reader :deployed_version_resource
+
+        def do_call
+          record_action
+          PactBroker::Client::CommandResult.new(true, result_message)
+        end
+
+        def action
+          "release"
+        end
+
+        def action_relation_name
+          "pb:record-release"
+        end
+
+        def not_supported_message
+          "This version of the Pact Broker does not support recording #{action}s. Please upgrade to version 2.80.0 or later."
+        end
+
+        def environment_exists?
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find(environment_name)
+        end
+
+        def record_action
+          @deployed_version_resource =
+            get_record_action_relation
+            .post(record_action_request_body)
+            .assert_success!
+        end
+
+        def record_action_links
+          get_pacticipant_version._links(action_relation_name) or raise PactBroker::Client::Error.new(not_supported_message)
+        end
+
+        def get_record_action_relation
+          record_action_links.find(environment_name) or record_action_links.find!(environment_name, environment_relation_not_found_error_message)
+        end
+
+        def environment_relation_not_found_error_message
+          if environment_exists?
+            "Environment '#{environment_name}' is not an available option for recording a deployment of #{pacticipant_name}."
+          else
+            "No environment found with name '#{environment_name}'."
+          end
+        end
+
+        def get_pacticipant_version
+          index_resource
+            ._link!("pb:pacticipant-version")
+            .expand(pacticipant: pacticipant_name, version: version_number)
+            .get
+            .assert_success!(404 => "#{pacticipant_name} version #{version_number} not found")
+        end
+
+        def record_action_request_body
+          {}
+        end
+
+        def result_message
+          if json_output?
+            deployed_version_resource.response.raw_body
+          else
+            green("#{result_text_message} in #{pact_broker_name}.")
+          end
+        end
+
+        def result_text_message
+          "Recorded #{action} of #{pacticipant_name} version #{version_number} to #{environment_name} environment"
+        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_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