pact_broker-client 1.38.3 → 1.43.0

data/lib/pact_broker/client/publish_pacts_the_old_way.rb

@@ -0,0 +1,194 @@
+require 'term/ansicolor'
+require 'pact_broker/client'
+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'
+require 'pact_broker/client/command_result'
+
+module PactBroker
+  module Client
+    class PublishPactsTheOldWay
+      using PactBroker::Client::HashRefinements
+      include HalClientMethods
+
+      def self.call(pact_broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options={})
+        new(pact_broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options).call
+      end
+
+      def initialize pact_broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options={}
+        @pact_broker_base_url = pact_broker_base_url
+        @pact_file_paths = pact_file_paths
+        @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 = create_consumer_versions && apply_tags && publish_pacts
+        $stdout.puts("")
+        if result
+          PactBroker::Client::CommandResult.new(true)
+        else
+          PactBroker::Client::CommandResult.new(false, "One or more pacts failed to be published")
+        end
+      end
+
+      private
+
+      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
+
+      def publish_pacts
+        pact_files.group_by(&:pact_name).collect do | pact_name, pact_files |
+          $stdout.puts "Merging #{pact_files.collect(&:path).join(", ")}" if pact_files.size > 1
+          publish_pact(PactHash[merge_contents(pact_files)])
+        end.all?
+      end
+
+      def merge_contents(pact_files)
+        MergePacts.call(pact_files.collect(&:pact_hash))
+      end
+
+      def pact_files
+        @pact_files ||= pact_file_paths.collect{ |pact_file_path| PactFile.new(pact_file_path) }
+      end
+
+      def consumer_names
+        pact_files.collect(&:consumer_name).uniq
+      end
+
+      def publish_pact pact
+        begin
+          $stdout.puts "Publishing #{pact.pact_name} to pact broker at #{pact_broker_base_url}"
+          publish_pact_contents pact
+        rescue => e
+          $stderr.puts "Failed to publish #{pact.pact_name} due to error: #{e.class} - #{e}"
+          false
+        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.empty?
+        tags.all? do | tag |
+          tag_consumer_version tag
+        end
+      end
+
+      def tag_consumer_version tag
+        versions = pact_broker_client.pacticipants.versions
+        Retry.while_error do
+          consumer_names.collect do | consumer_name |
+            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
+      rescue => e
+        $stderr.puts "Failed to tag version due to error: #{e.class} - #{e}"
+        false
+      end
+
+      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_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. For more information, see https://docs.pact.io/versioning)")
+            end
+          end
+
+          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_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
+    end
+  end
+end

data/lib/pact_broker/client/string_refinements.rb

@@ -0,0 +1,56 @@
+module PactBroker
+  module Client
+    module StringRefinements
+      refine NilClass do
+        def blank?
+          true
+        end
+      end
+
+      refine String do
+        def not_blank?
+          !blank?
+        end
+
+        def blank?
+          self.strip.size == 0
+        end
+
+        # ripped from rubyworks/facets, thank you
+        def snakecase
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+          .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+          .tr('-', '_')
+          .gsub(/\s/, '_')
+          .gsub(/__+/, '_')
+          .downcase
+        end
+
+        # ripped from rubyworks/facets, thank you
+        def camelcase(*separators)
+          case separators.first
+          when Symbol, TrueClass, FalseClass, NilClass
+            first_letter = separators.shift
+          end
+
+          separators = ['_', '\s'] if separators.empty?
+
+          str = self.dup
+
+          separators.each do |s|
+            str = str.gsub(/(?:#{s}+)([a-z])/){ $1.upcase }
+          end
+
+          case first_letter
+          when :upper, true
+            str = str.gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+          when :lower, false
+            str = str.gsub(/(\A|\s)([A-Z])/){ $1 + $2.downcase }
+          end
+
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -63,8 +63,9 @@ module PactBroker
             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
+            result = PactBroker::Client::PublishPacts.new(pact_broker_base_url, FileList[pattern], consumer_version_params, {}, pact_broker_client_options).call
+            $stdout.puts result.message
+            raise "One or more pacts failed to be published" unless result.success
           end
         end
       end
@@ -86,7 +87,6 @@ module PactBroker
           branch
         end
       end
-
     end
   end
 end

data/lib/pact_broker/client/version.rb

@@ -1,5 +1,5 @@
 module PactBroker
   module Client
-    VERSION = '1.38.3'
+    VERSION = '1.43.0'
   end
 end

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

@@ -1,42 +1,28 @@
-require 'pact_broker/client/hal_client_methods'
-require 'pact_broker/client/error'
-require 'pact_broker/client/command_result'
+require 'pact_broker/client/base_command'
 
 module PactBroker
   module Client
     class Versions
-      class RecordDeployment
-        include PactBroker::Client::HalClientMethods
+      class RecordDeployment < PactBroker::Client::BaseCommand
 
         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
+        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)
-          @replaced_previous_deployed_version = params.fetch(:replaced_previous_deployed_version)
-          @output = params.fetch(:output)
-          @pact_broker_client_options = pact_broker_client_options
+          @target = params.fetch(:target)
         end
 
-        def call
-          check_if_command_supported
-          record_deployment
+        private
 
+        def do_call
+          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 :pacticipant_name, :version_number, :environment_name, :target, :output
         attr_reader :deployed_version_resource
 
         def check_environment_exists
@@ -75,29 +61,19 @@ module PactBroker
         end
 
         def record_deployment_request_body
-          { replacedPreviousDeployedVersion: replaced_previous_deployed_version }
+          { target: target }
         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"
+          if json_output?
             deployed_version_resource.response.raw_body
           else
-            ""
+            message = "Recorded deployment of #{pacticipant_name} version #{version_number} to #{environment_name} environment"
+            message = "#{message} (target #{target})" if target
+            green("#{message} in #{pact_broker_name}.")
           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)

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

@@ -2,6 +2,10 @@ require 'pact_broker/client/hal_client_methods'
 require 'pact_broker/client/error'
 require 'pact_broker/client/command_result'
 
+# TODO
+# --limit 1
+# order by date so that the oldest one gets undeployed first
+
 module PactBroker
   module Client
     class Versions
@@ -24,10 +28,17 @@ module PactBroker
         end
 
         def call
-          check_environment_exists
-          # record_undeployment
+          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
+          else
+            check_environment_exists
+            raise_not_found_error
+          end
 
-          PactBroker::Client::CommandResult.new(true, result_message)
+          PactBroker::Client::CommandResult.new(true, "foo")
         rescue PactBroker::Client::Error => e
           PactBroker::Client::CommandResult.new(false, e.message)
         end
@@ -35,83 +46,49 @@ module PactBroker
         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
+        attr_reader :pacticipant_name, :version_number, :environment_name, :target, :output
+        attr_reader :deployed_version_resource, :undeployment_entities
 
-        def check_environment_exists
-          deployed_versions = currently_deployed_versions_for_pacticipant
-                                .get(version: version_number)
-                                .embedded_entities("deployedVersions")
-          deployed_versions
+        def version_resource
+          index_resource._link!("pb:pacticipant-version").expand(pacticipant: pacticipant_name, version: version_number).get!
         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)
+        def deployed_version_links
+          @deployed_version_links ||= version_resource._links!("pb:currently-deployed-versions")
         end
 
-        def currently_deployed_versions_for_pacticipant_version
-          @currently_deployed_versions ||= currently_deployed_versions_for_pacticipant
-            .get(version: version_number)
-            .embedded_entities("deployedVersions")
+        def deployed_version_links_for_environment
+          @deployed_version_links_for_environment ||= deployed_version_links.select(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 check_environment_exists
+          index_resource
+            ._link!("pb:environments")
+            .get!
+            ._links("pb:environments")
+            .find!(environment_name, "No environment found with name '#{environment_name}'")
+        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
+        def raise_not_found_error
+          raise PactBroker::Client::Error.new(deployed_version_not_found_message)
         end
 
-        def pact_broker_name
-          is_pactflow? ? "Pactflow" : "the Pact Broker"
+        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 is_pactflow?
-          deployed_version_resource.response.headers.keys.any?{ | header_name | header_name.downcase.include?("pactflow") }
+        def result_message
+          if output == "text"
+            message = "Recorded undeployment of #{pacticipant_name} version #{version_number} from #{environment_name} in #{pact_broker_name}."
+          elsif output == "json"
+            undeployment_entities.last.response.raw_body
+          else
+            ""
+          end
         end
 
         def check_if_command_supported