pact_broker-client 1.35.0 → 1.38.1

data/lib/pact_broker/client/publish_pacts.rb

@@ -4,39 +4,60 @@ require 'pact_broker/client/retry'
 require 'pact_broker/client/pact_file'
 require 'pact_broker/client/pact_hash'
 require 'pact_broker/client/merge_pacts'
+require 'pact_broker/client/hal_client_methods'
+require 'pact_broker/client/hash_refinements'
 
 module PactBroker
   module Client
     class PublishPacts
+      using PactBroker::Client::HashRefinements
+      include HalClientMethods
 
-      def self.call(pact_broker_base_url, pact_file_paths, consumer_version, tags, pact_broker_client_options={})
-        new(pact_broker_base_url, pact_file_paths, consumer_version, tags, pact_broker_client_options).call
+      def self.call(pact_broker_base_url, pact_file_paths, consumer_version_params, pact_broker_client_options={})
+        new(pact_broker_base_url, pact_file_paths, consumer_version_params, pact_broker_client_options).call
       end
 
-      def initialize pact_broker_base_url, pact_file_paths, consumer_version, tags, pact_broker_client_options={}
+      def initialize pact_broker_base_url, pact_file_paths, consumer_version_params, pact_broker_client_options={}
         @pact_broker_base_url = pact_broker_base_url
         @pact_file_paths = pact_file_paths
-        @consumer_version = consumer_version.respond_to?(:strip) ? consumer_version.strip : consumer_version
-        @tags = tags ? tags.collect{ |tag| tag.respond_to?(:strip) ? tag.strip : tag } : tags
+        @consumer_version_number = consumer_version_params[:number].respond_to?(:strip) ? consumer_version_params[:number].strip : consumer_version_params[:number]
+        @branch = consumer_version_params[:branch]
+        @build_url = consumer_version_params[:build_url]
+        @tags = consumer_version_params[:tags] ? consumer_version_params[:tags].collect{ |tag| tag.respond_to?(:strip) ? tag.strip : tag } : []
+        @version_required = consumer_version_params[:version_required]
         @pact_broker_client_options = pact_broker_client_options
       end
 
       def call
         validate
         $stdout.puts("")
-        result = apply_tags && publish_pacts
+        result = create_consumer_versions && apply_tags && publish_pacts
         $stdout.puts("")
         result
       end
 
       private
 
-      attr_reader :pact_broker_base_url, :pact_file_paths, :consumer_version, :tags, :pact_broker_client_options
+      attr_reader :pact_broker_base_url, :pact_file_paths, :consumer_version_number, :branch, :tags, :build_url, :pact_broker_client_options, :version_required
 
       def pact_broker_client
         @pact_broker_client ||= PactBroker::Client::PactBrokerClient.new(base_url: pact_broker_base_url, client_options: pact_broker_client_options)
       end
 
+      def index_entry_point
+        @index_entry_point ||= create_index_entry_point(pact_broker_base_url, pact_broker_client_options)
+      end
+
+      def index_resource
+        @index_resource ||= Retry.while_error do
+          index_entry_point.get!
+        end
+      end
+
+      def can_create_version_with_branch?
+        @can_create_version_with_branch ||= index_resource.can?('pb:pacticipant-version')
+      end
+
       def merge_on_server?
         pact_broker_client_options[:write] == :merge
       end
@@ -70,8 +91,58 @@ module PactBroker
         end
       end
 
+      def create_consumer_versions
+        if create_versions?
+          consumer_names.collect do | consumer_name |
+            create_version(index_resource, consumer_name)
+          end
+          true
+        else
+          true
+        end
+      end
+
+      def create_versions?
+        if version_required
+          if can_create_version_with_branch?
+            true
+          else
+            raise PactBroker::Client::Error.new("This version of the Pact Broker does not support versions with branches or build URLs. Please upgrade your broker to 2.76.2 or later.")
+          end
+        elsif (branch || build_url) && can_create_version_with_branch?
+          true
+        else
+          false
+        end
+      end
+
+      def create_version(index_resource, consumer_name)
+        Retry.while_error do
+          version_resource = index_resource._link('pb:pacticipant-version').expand(version: consumer_version_number, pacticipant: consumer_name).put(version_body).assert_success!
+          message = if version_resource.response.status == 200
+            "Replaced version #{consumer_version_number} of #{consumer_name}"
+          else
+            "Created version #{consumer_version_number} of #{consumer_name}"
+          end
+
+          message = message + " (branch #{branch})" if branch
+          $stdout.puts message
+          if version_resource.response.status == 200
+            $stdout.puts ::Term::ANSIColor.yellow("Replacing the version resource is not recommended under normal circumstances and may indicate that you have not configured your Pact pipeline correctly (unless you are just re-running a build for a particular commit). For more information see https://docs.pact.io/versioning")
+          end
+          true
+        end
+      end
+
+      def version_body
+        {
+          branch: branch,
+          buildUrl: build_url
+        }.compact
+      end
+
       def apply_tags
-        return true if tags.nil? || tags.empty?
+        return true if tags.empty?
         tags.all? do | tag |
           tag_consumer_version tag
         end
@@ -81,8 +152,8 @@ module PactBroker
         versions = pact_broker_client.pacticipants.versions
         Retry.while_error do
           consumer_names.collect do | consumer_name |
-            versions.tag(pacticipant: consumer_name, version: consumer_version, tag: tag)
-            $stdout.puts "Tagged version #{consumer_version} of #{consumer_name} as #{tag.inspect}"
+            versions.tag(pacticipant: consumer_name, version: consumer_version_number, tag: tag)
+            $stdout.puts "Tagged version #{consumer_version_number} of #{consumer_name} as #{tag.inspect}"
             true
           end
         end
@@ -94,22 +165,22 @@ module PactBroker
       def publish_pact_contents(pact)
         Retry.while_error do
           pacts = pact_broker_client.pacticipants.versions.pacts
-          if pacts.version_published?(consumer: pact.consumer_name, provider: pact.provider_name, consumer_version: consumer_version)
+          if pacts.version_published?(consumer: pact.consumer_name, provider: pact.provider_name, consumer_version: consumer_version_number)
             if merge_on_server?
               $stdout.puts "A pact for this consumer version is already published. Merging contents."
             else
-              $stdout.puts ::Term::ANSIColor.yellow("A pact for this consumer version is already published. Overwriting. (Note: Overwriting pacts is not recommended as it can lead to race conditions. Best practice is to provide a unique consumer version number for each publication.)")
+              $stdout.puts ::Term::ANSIColor.yellow("A pact for this consumer version is already published. Overwriting. (Note: Overwriting pacts is not recommended as it can lead to race conditions. Best practice is to provide a unique consumer version number for each publication. For more information, see https://docs.pact.io/versioning)")
             end
           end
 
-          latest_pact_url = pacts.publish(pact_hash: pact, consumer_version: consumer_version)
+          latest_pact_url = pacts.publish(pact_hash: pact, consumer_version: consumer_version_number)
           $stdout.puts "The latest version of this pact can be accessed at the following URL:\n#{latest_pact_url}"
           true
         end
       end
 
       def validate
-        raise PactBroker::Client::Error.new("Please specify the consumer_version") unless (consumer_version && consumer_version.to_s.strip.size > 0)
+        raise PactBroker::Client::Error.new("Please specify the consumer_version_number") unless (consumer_version_number && consumer_version_number.to_s.strip.size > 0)
         raise PactBroker::Client::Error.new("Please specify the pact_broker_base_url") unless (pact_broker_base_url && pact_broker_base_url.to_s.strip.size > 0)
         raise PactBroker::Client::Error.new("No pact files found") unless (pact_file_paths && pact_file_paths.any?)
       end

data/lib/pact_broker/client/tasks/publication_task.rb

@@ -1,5 +1,6 @@
 require 'rake/tasklib'
 require 'pact_broker/client/git'
+require 'pact_broker/client/hash_refinements'
 
 =begin
 require pact_broker/client/tasks
@@ -17,31 +18,52 @@ end
 module PactBroker
   module Client
     class PublicationTask < ::Rake::TaskLib
+      using PactBroker::Client::HashRefinements
 
       attr_accessor :pattern, :pact_broker_base_url, :consumer_version, :tag, :write_method, :tag_with_git_branch, :pact_broker_basic_auth, :pact_broker_token
+      attr_reader :auto_detect_version_properties, :branch, :build_url
       alias_method :tags=, :tag=
       alias_method :tags, :tag
 
       def initialize name = nil, &block
         @name = name
+        @auto_detect_version_properties = nil
+        @version_required = false
         @pattern = 'spec/pacts/*.json'
         @pact_broker_base_url = 'http://pact-broker'
         rake_task &block
       end
 
+      def auto_detect_version_properties= auto_detect_version_properties
+        @version_required = version_required || auto_detect_version_properties
+        @auto_detect_version_properties = auto_detect_version_properties
+      end
+
+      def branch= branch
+        @version_required = version_required || !!branch
+        @branch = branch
+      end
+
+      def build_url= build_url
+        @version_required = version_required || !!build_url
+        @build_url = build_url
+      end
+
       private
 
+      attr_reader :version_required
+
       def rake_task &block
         namespace :pact do
           desc "Publish pacts to pact broker"
           task task_name do
             block.call(self)
             require 'pact_broker/client/publish_pacts'
-            pact_broker_client_options =  {}
-              .merge( pact_broker_basic_auth ? { basic_auth: pact_broker_basic_auth } : {} )
-              .merge( write_method ? { write: write_method } : {} )
-              .merge( pact_broker_token ? { token: pact_broker_token } : {} )
-            success = PactBroker::Client::PublishPacts.new(pact_broker_base_url, FileList[pattern], consumer_version, all_tags, pact_broker_client_options).call
+            pact_broker_client_options = { write: write_method, token: pact_broker_token }
+            pact_broker_client_options[:basic_auth] = pact_broker_basic_auth if pact_broker_basic_auth && pact_broker_basic_auth.any?
+            pact_broker_client_options.compact!
+            consumer_version_params = { number: consumer_version, branch: the_branch, build_url: build_url, tags: all_tags, version_required: version_required }.compact
+            success = PactBroker::Client::PublishPacts.new(pact_broker_base_url, FileList[pattern], consumer_version_params, pact_broker_client_options).call
             raise "One or more pacts failed to be published" unless success
           end
         end
@@ -53,9 +75,18 @@ module PactBroker
 
       def all_tags
         t = [*tags]
-        t << PactBroker::Client::Git.branch if tag_with_git_branch
+        t << PactBroker::Client::Git.branch(raise_error: true) if tag_with_git_branch
         t.compact.uniq
       end
+
+      def the_branch
+        if branch.nil? && auto_detect_version_properties != false
+          PactBroker::Client::Git.branch(raise_error: auto_detect_version_properties == true)
+        else
+          branch
+        end
+      end
+
     end
   end
 end

data/lib/pact_broker/client/version.rb

@@ -1,5 +1,5 @@
 module PactBroker
   module Client
-    VERSION = '1.35.0'
+    VERSION = '1.38.1'
   end
 end

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

@@ -0,0 +1,109 @@
+require 'pact_broker/client/hal_client_methods'
+require 'pact_broker/client/error'
+require 'pact_broker/client/command_result'
+
+module PactBroker
+  module Client
+    class Versions
+      class RecordDeployment
+        include PactBroker::Client::HalClientMethods
+
+        NOT_SUPPORTED_MESSAGE = "This version of the Pact Broker does not support recording deployments. Please upgrade to version 2.80.0 or later."
+
+        def self.call(params, pact_broker_base_url, pact_broker_client_options)
+          new(params, pact_broker_base_url, pact_broker_client_options).call
+        end
+
+        def initialize(params, pact_broker_base_url, pact_broker_client_options)
+          @pact_broker_base_url = pact_broker_base_url
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @version_number = params.fetch(:version_number)
+          @environment_name = params.fetch(:environment_name)
+          @replaced_previous_deployed_version = params.fetch(:replaced_previous_deployed_version)
+          @output = params.fetch(:output)
+          @pact_broker_client_options = pact_broker_client_options
+        end
+
+        def call
+          check_if_command_supported
+          record_deployment
+
+          PactBroker::Client::CommandResult.new(true, result_message)
+        rescue PactBroker::Client::Error => e
+          PactBroker::Client::CommandResult.new(false, e.message)
+        end
+
+        private
+
+        attr_reader :pact_broker_base_url, :pact_broker_client_options
+        attr_reader :pacticipant_name, :version_number, :environment_name, :replaced_previous_deployed_version, :output
+        attr_reader :deployed_version_resource
+
+        def check_environment_exists
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find!(environment_name, "No environment found with name '#{environment_name}'")
+        end
+
+        def record_deployment
+          @deployed_version_resource =
+            get_record_deployment_relation
+            .post(record_deployment_request_body)
+            .assert_success!
+        end
+
+        def get_record_deployment_relation
+          record_deployment_links = get_pacticipant_version._links!("pb:record-deployment")
+          link_for_environment = record_deployment_links.find(environment_name)
+          if link_for_environment
+            link_for_environment
+          else
+            check_environment_exists
+            # Force the exception to be raised
+            record_deployment_links.find!(environment_name, "Environment '#{environment_name}' is not an available option for recording a deployment of #{pacticipant_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_deployment_request_body
+          { replacedPreviousDeployedVersion: replaced_previous_deployed_version }
+        end
+
+        def result_message
+          if output == "text"
+            message = "Recorded deployment of #{pacticipant_name} version #{version_number} to #{environment_name} in #{pact_broker_name}."
+            suffix = replaced_previous_deployed_version ? " Marked previous deployed version as undeployed." : ""
+            message + suffix
+          elsif output == "json"
+            deployed_version_resource.response.raw_body
+          else
+            ""
+          end
+        end
+
+        def pact_broker_name
+          is_pactflow? ? "Pactflow" : "the Pact Broker"
+        end
+
+        def is_pactflow?
+          deployed_version_resource.response.headers.keys.any?{ | header_name | header_name.downcase.include?("pactflow") }
+        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/versions/record_undeployment.rb

@@ -0,0 +1,125 @@
+require 'pact_broker/client/hal_client_methods'
+require 'pact_broker/client/error'
+require 'pact_broker/client/command_result'
+
+module PactBroker
+  module Client
+    class Versions
+      class RecordUndeployment
+        include PactBroker::Client::HalClientMethods
+
+        NOT_SUPPORTED_MESSAGE = "This version of the Pact Broker does not support recording undeployments. Please upgrade to version 2.80.0 or later."
+
+        def self.call(params, pact_broker_base_url, pact_broker_client_options)
+          new(params, pact_broker_base_url, pact_broker_client_options).call
+        end
+
+        def initialize(params, pact_broker_base_url, pact_broker_client_options)
+          @pact_broker_base_url = pact_broker_base_url
+          @pacticipant_name = params.fetch(:pacticipant_name)
+          @version_number = params.fetch(:version_number)
+          @environment_name = params.fetch(:environment_name)
+          @output = params.fetch(:output)
+          @pact_broker_client_options = pact_broker_client_options
+        end
+
+        def call
+          check_environment_exists
+          # record_undeployment
+
+          PactBroker::Client::CommandResult.new(true, result_message)
+        rescue PactBroker::Client::Error => e
+          PactBroker::Client::CommandResult.new(false, e.message)
+        end
+
+        private
+
+        attr_reader :pact_broker_base_url, :pact_broker_client_options
+        attr_reader :pacticipant_name, :version_number, :environment_name, :replaced_previous_deployed_version, :output
+        attr_reader :deployed_version_resource
+
+        def check_environment_exists
+          deployed_versions = currently_deployed_versions_for_pacticipant
+                                .get(version: version_number)
+                                .embedded_entities("deployedVersions")
+          deployed_versions
+        end
+
+        def currently_deployed_versions_for_pacticipant
+          @currently_deployed_versions_for_pacticipant ||= index_resource
+            ._link!("pb:environments")
+            .get!(name: environment_name)
+            .embedded_entities("environments")
+            .tap { |it| raise "Environment not found '#{environment_name}'" if it.empty? }
+            .first
+            ._link!("pb:currently-deployed-versions-for-pacticipant")
+            .expand(pacticipant: pacticipant_name)
+        end
+
+        def currently_deployed_versions_for_pacticipant_version
+          @currently_deployed_versions ||= currently_deployed_versions_for_pacticipant
+            .get(version: version_number)
+            .embedded_entities("deployedVersions")
+        end
+
+        # def record_deployment
+        #   @deployed_version_resource =
+        #     get_record_deployment_relation
+        #     .post(record_deployment_request_body)
+        #     .assert_success!
+        # end
+
+        # def get_record_deployment_relation
+        #   record_deployment_links = get_pacticipant_version._links!("pb:record-deployment")
+        #   link_for_environment = record_deployment_links.find(environment_name)
+        #   if link_for_environment
+        #     link_for_environment
+        #   else
+        #     check_environment_exists
+        #     # Force the exception to be raised
+        #     record_deployment_links.find!(environment_name, "Environment '#{environment_name}' is not an available option for recording a deployment of #{pacticipant_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_deployment_request_body
+        #   { replacedPreviousDeployedVersion: replaced_previous_deployed_version }
+        # end
+
+        def result_message
+          ""
+          # if output == "text"
+          #   message = "Recorded deployment of #{pacticipant_name} version #{version_number} to #{environment_name} in #{pact_broker_name}."
+          #   suffix = replaced_previous_deployed_version ? " Marked previous deployed version as undeployed." : ""
+          #   message + suffix
+          # elsif output == "json"
+          #   deployed_version_resource.response.raw_body
+          # else
+          #   ""
+          # end
+        end
+
+        def pact_broker_name
+          is_pactflow? ? "Pactflow" : "the Pact Broker"
+        end
+
+        def is_pactflow?
+          deployed_version_resource.response.headers.keys.any?{ | header_name | header_name.downcase.include?("pactflow") }
+        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