pact_broker-client 1.39.0 → 1.44.0

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'
+

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_undeployment.rb

@@ -0,0 +1,120 @@
+require 'pact_broker/client/base_command'
+
+module PactBroker
+  module Client
+    module Deployments
+      class RecordUndeployment < PactBroker::Client::BaseCommand
+
+
+
+        def initialize(params, pact_broker_base_url, pact_broker_client_options)
+          super
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @environment_name = params.fetch(:environment_name)
+          @target = params.fetch(:target)
+        end
+
+        private
+
+        def do_call
+          if undeployed_versions_resources.empty?
+            check_pacticipant_exists!
+            PactBroker::Client::CommandResult.new(false, deployed_version_not_found_error_message)
+          else
+            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
+
+        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)
+        end
+
+        def undeployed_versions_resources
+          @undeployed_versions_resources ||= currently_deployed_versions_resource.embedded_entities("deployedVersions").collect do | entity |
+            entity._link!("self").patch(currentlyDeployed: 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 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
+          else
+            undeployed_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)
+          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
+        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."
+
+          if json_output?
+            { error: message }.to_json
+          else
+            red(message)
+          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(", ")}"
+          else
+            "#{pacticipant_name} version #{version_number} is not currently deployed to any environment."
+          end
+        end
+
+        def not_supported_message
+          "This version of the Pact Broker does not support recording undeployments. Please upgrade to version 2.80.0 or later."
+        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/describe_text_formatter.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+require 'pact_broker/client/generate_display_name'
+
+module PactBroker
+  module Client
+    class DescribeTextFormatter
+      extend GenerateDisplayName
+
+      def self.call(properties)
+        YAML.dump(displayify_keys(properties)).gsub("---\n", "")
+      end
+
+      def self.displayify_keys(thing)
+        case thing
+        when Hash then thing.each_with_object({}) { | (key, value), new_hash | new_hash[generate_display_name(key)] = displayify_keys(value) }
+        when Array then thing.collect{ | value | displayify_keys(value) }
+        else
+          thing
+        end
+      end
+    end
+  end
+end