feat: add record-undeployment (feature toggled off)

lib/pact_broker/client/cli/deployment_commands.rb

@@ -27,7 +27,6 @@ def record_deployment
             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."
             method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant that was undeployed."
-            method_option :version, required: true, aliases: "-e", desc: "The pacticipant version number 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
@@ -36,7 +35,6 @@ def record_deployment
             def record_undeployment
               params = {
                 pacticipant_name: options.pacticipant,
-                version_number: options.version,
                 environment_name: options.environment,
                 target: options.target
               }

lib/pact_broker/client/deployments/record_undeployment.rb

@@ -5,59 +5,98 @@ module Client
     module Deployments
       class RecordUndeployment < PactBroker::Client::BaseCommand
 
-        NOT_SUPPORTED_MESSAGE = "This version of the Pact Broker does not support recording undeployments. Please upgrade to version 2.80.0 or later."
+
 
         def initialize(params, pact_broker_base_url, pact_broker_client_options)
           super
           @pacticipant_name = params.fetch(:pacticipant_name)
-          @version_number = params.fetch(:version_number)
           @environment_name = params.fetch(:environment_name)
           @target = params.fetch(:target)
         end
 
         private
 
         def do_call
-          check_if_command_supported
-          if deployed_version_links_for_environment.any?
-            @undeployment_entities = deployed_version_links_for_environment.collect do | deployed_version_link |
-              deployed_version_link.get!._link!("pb:record-undeployment").post!
-            end
+          if undeployed_versions_resources.empty?
+            check_pacticipant_exists!
+            PactBroker::Client::CommandResult.new(false, deployed_version_not_found_error_message)
           else
-            check_environment_exists
-            raise_not_found_error
+            PactBroker::Client::CommandResult.new(undeployed_versions_resources.all?(:success?), result_message)
           end
-
-          PactBroker::Client::CommandResult.new(true, "foo")
         end
 
         attr_reader :pacticipant_name, :version_number, :environment_name, :target, :output
         attr_reader :deployed_version_resource, :undeployment_entities
 
-        def version_resource
-          index_resource._link!("pb:pacticipant-version").expand(pacticipant: pacticipant_name, version: version_number).get!
+        def currently_deployed_versions_link
+          environment_resource._link("pb:currently-deployed-versions") or raise PactBroker::Client::Error.new(not_supported_message)
         end
 
-        def deployed_version_links
-          @deployed_version_links ||= version_resource._links!("pb:currently-deployed-versions")
+        def currently_deployed_versions_resource
+          @deployed_version_links ||= currently_deployed_versions_link.get!(pacticipant: pacticipant_name, target: target)
         end
 
-        def deployed_version_links_for_environment
-          @deployed_version_links_for_environment ||= deployed_version_links.select(environment_name)
+        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 check_environment_exists
+        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 raise_not_found_error
-          raise PactBroker::Client::Error.new(deployed_version_not_found_message)
+        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(", ")}"
@@ -66,17 +105,13 @@ def deployed_version_not_found_message
           end
         end
 
-        def result_message
-          if output_json?
-            undeployment_entities.last.response.raw_body
-          else
-            green("Recorded undeployment of #{pacticipant_name} version #{version_number} from #{environment_name} in #{pact_broker_name}.")
-          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)
+            raise PactBroker::Client::Error.new(not_supported_message)
           end
         end
       end

lib/pact_broker/client/hal/entity.rb

@@ -165,14 +165,17 @@ def success?
           false
         end
 
-        def assert_success!(messages = {})
+        def error_message(messages = {})
           default_message = "Error making request to #{@href} status=#{response ? response.status: nil} #{response ? response.raw_body : ''}".strip
           message = if response && messages[response.status]
             (messages[response.status] || "") + " (#{default_message})"
           else
             default_message
           end
-          raise ErrorResponseReturned.new(message, self)
+        end
+
+        def assert_success!(messages = {})
+          raise ErrorResponseReturned.new(error_message(messages), self)
         end
       end
     end

lib/pact_broker/client/hal/http_client.rb

@@ -46,7 +46,8 @@ def delete href, body = nil, headers = {}
 
         def create_request uri, http_method, body = nil, headers = {}
           request = Net::HTTP.const_get(http_method).new(uri.request_uri)
-          request['Content-Type'] = "application/json" if ['Post', 'Put', 'Patch'].include?(http_method)
+          request['Content-Type'] ||= "application/json" if ['Post', 'Put'].include?(http_method)
+          request['Content-Type'] ||= "application/merge-patch+json" if ['Patch'].include?(http_method)
           request['Accept'] = "application/hal+json"
           headers.each do | key, value |
             request[key] = value

lib/pact_broker/client/pacticipants/create.rb

@@ -17,7 +17,7 @@ def do_call
             index_resource._link!('pb:pacticipants').post!(pacticipant_resource_params)
           elsif pacticipant_entity.success?
             @action = "updated"
-            pacticipant_entity._link!('self').patch!(pacticipant_resource_params)
+            pacticipant_entity._link!('self').patch!(pacticipant_resource_params, { "Content-Type" => "application/json" })
           else
             pacticipant_entity.assert_success!
           end