pact_broker-client 1.38.1 → 1.41.0

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

@@ -15,10 +15,14 @@ module PactBroker
         using PactBroker::Client::HashRefinements
 
         desc 'can-i-deploy', ''
-        long_desc File.read(File.join(File.dirname(__FILE__), 'can_i_deploy_long_desc.txt'))
+        long_desc File.read(File.join(__dir__, 'can_i_deploy_long_desc.txt'))
 
         method_option :pacticipant, required: true, aliases: "-a", desc: "The pacticipant name. Use once for each pacticipant being checked."
         method_option :version, required: false, aliases: "-e", desc: "The pacticipant version. Must be entered after the --pacticipant that it relates to."
+
+        if ENV.fetch("PACT_BROKER_FEATURES", "").include?("ignore")
+          method_option :ignore, required: false, desc: "The pacticipant name to ignore. Use once for each pacticipant being ignored. A specific version can be ignored by also specifying a --version."
+        end
         method_option :latest, required: false, aliases: "-l", banner: '[TAG]', desc: "Use the latest pacticipant version. Optionally specify a TAG to use the latest version with the specified tag."
         method_option :to, required: false, banner: 'TAG', desc: "This is too hard to explain in a short sentence. Look at the examples.", default: nil
         method_option :to_environment, required: false, banner: 'ENVIRONMENT', desc: "The environment into which the pacticipant(s) are to be deployed", default: nil, hide: true
@@ -34,11 +38,17 @@ module PactBroker
           require 'pact_broker/client/can_i_deploy'
 
           validate_credentials
-          selectors = VersionSelectorOptionsParser.call(ARGV)
+          selectors = VersionSelectorOptionsParser.call(ARGV).select { |s| !s[:ignore] }
+          ignore_selectors = if ENV.fetch("PACT_BROKER_FEATURES", "").include?("ignore")
+            VersionSelectorOptionsParser.call(ARGV).select { |s| s[:ignore] }
+          else
+            []
+          end
           validate_can_i_deploy_selectors(selectors)
           can_i_deploy_options = { output: options.output, retry_while_unknown: options.retry_while_unknown, retry_interval: options.retry_interval }
-          result = CanIDeploy.call(options.broker_base_url, selectors, { to_tag: options.to, to_environment: options.to_environment, limit: options.limit }, can_i_deploy_options, pact_broker_client_options)
+          result = CanIDeploy.call(options.broker_base_url, selectors, { to_tag: options.to, to_environment: options.to_environment, limit: options.limit, ignore_selectors: ignore_selectors }, can_i_deploy_options, pact_broker_client_options)
           $stdout.puts result.message
+          $stdout.flush
           exit(can_i_deploy_exit_status) unless result.success
         end
 
@@ -50,14 +60,16 @@ module PactBroker
         method_option :tag_with_git_branch, aliases: "-g", type: :boolean, default: false, required: false, desc: "Tag consumer version with the name of the current git branch. Default: false"
         method_option :build_url, desc: "The build URL that created the pact"
         method_option :merge, type: :boolean, default: false, require: false, desc: "If a pact already exists for this consumer version and provider, merge the contents. Useful when running Pact tests concurrently on different build nodes."
+        method_option :output, aliases: "-o", desc: "json or text", default: 'text'
         shared_authentication_options
 
         def publish(*pact_files)
           require 'pact_broker/client/error'
           validate_credentials
           validate_pact_files(pact_files)
-          success = publish_pacts(pact_files)
-          raise PactPublicationError, "One or more pacts failed to be published" unless success
+          result = publish_pacts(pact_files)
+          $stdout.puts result.message
+          exit(1) unless result.success
         rescue PactBroker::Client::Error => e
           raise PactPublicationError, "#{e.class} - #{e.message}"
         end
@@ -171,11 +183,11 @@ module PactBroker
         if ENV.fetch("PACT_BROKER_FEATURES", "").include?("deployments")
 
           ignored_and_hidden_potential_options_from_environment_variables
-          desc "record-deployment", "Record deployment of a pacticipant version to an environment"
+          desc "record-deployment", "Record deployment of a pacticipant version to an environment. See https://docs.pact.io/go/record_deployment for more information."
           method_option :pacticipant, required: true, aliases: "-a", desc: "The name of the pacticipant that was deployed."
           method_option :version, required: true, aliases: "-e", desc: "The pacticipant version number that was deployed."
           method_option :environment, required: true, desc: "The name of the environment that the pacticipant version was deployed to."
-          method_option :replaced_previous_deployed_version, type: :boolean, default: true, required: false, desc: "Whether or not this deployment replaced the previous deployed version. If it did, the previous deployed version of this pacticipant will be marked as undeployed in the Pact Broker."
+          method_option :target, default: nil, required: false, desc: "Optional. The target of the deployment - a logical identifer required to differentiate deployments when there are multiple instances of the same application in an environment."
           method_option :output, aliases: "-o", desc: "json or text", default: 'text'
           shared_authentication_options
 
@@ -185,7 +197,7 @@ module PactBroker
               pacticipant_name: options.pacticipant,
               version_number: options.version,
               environment_name: options.environment,
-              replaced_previous_deployed_version: options.replaced_previous_deployed_version,
+              target: options.target,
               output: options.output
             }
             result = PactBroker::Client::Versions::RecordDeployment.call(
@@ -281,6 +293,7 @@ module PactBroker
               options.broker_base_url,
               file_list(pact_files),
               consumer_version_params,
+              { merge: options[:merge], output: options.output }.compact,
               pact_broker_client_options.merge(write_options)
             )
           end
@@ -289,13 +302,26 @@ module PactBroker
             require 'rake/file_list'
 
             correctly_separated_pact_files = pact_files.collect{ |path| path.gsub(/\\+/, '/') }
-            Rake::FileList[correctly_separated_pact_files].collect do | path |
+            paths = Rake::FileList[correctly_separated_pact_files].collect do | path |
               if File.directory?(path)
                 Rake::FileList[File.join(path, "*.json")]
               else
                 path
               end
             end.flatten
+            validate_pact_path_list(paths)
+          end
+
+          def validate_pact_path_list(paths)
+            paths.collect do | path |
+              if File.exist?(path)
+                path
+              elsif path.start_with?("-")
+                raise Thor::Error.new("ERROR: pact-broker publish was called with invalid arguments #{[path]}")
+              else
+                raise Thor::Error.new("Specified pact file '#{path}' does not exist. This sometimes indicates one of the arguments has been specified with the wrong name and has been incorrectly identified as a file path.")
+              end
+            end
           end
 
           def tags
@@ -378,7 +404,6 @@ module PactBroker
               provider: options.provider,
               events: events
             }
-
           end
 
           def run_webhook_commands webhook_url

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/hal/entity.rb

@@ -23,18 +23,34 @@ module PactBroker
           _link(key).get(*args)
         end
 
+        def get!(key, *args)
+          get(key, *args).assert_success!
+        end
+
         def post(key, *args)
           _link(key).post(*args)
         end
 
+        def post!(key, *args)
+          post(key, *args).assert_success!
+        end
+
         def put(key, *args)
           _link(key).put(*args)
         end
 
+        def put!(key, *args)
+          put(key, *args).assert_success!
+        end
+
         def patch(key, *args)
           _link(key).patch(*args)
         end
 
+        def patch!(key, *args)
+          patch(key, *args).assert_success!
+        end
+
         def can?(key)
           @links.key? key.to_s
         end

data/lib/pact_broker/client/hal/http_client.rb

@@ -7,6 +7,7 @@ module PactBroker
   module Client
     module Hal
       class HttpClient
+        RETRYABLE_ERRORS = [Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EHOSTUNREACH, Net::ReadTimeout]
         attr_accessor :username, :password, :verbose, :token
 
         def initialize options
@@ -53,7 +54,7 @@ module PactBroker
         end
 
         def perform_request request, uri
-          response = Retry.until_truthy_or_max_times do
+          response = until_truthy_or_max_times(condition: ->(resp) { resp.code.to_i < 500 }) do
             http = Net::HTTP.new(uri.host, uri.port, :ENV)
             http.set_debug_output(output_stream) if verbose
             http.use_ssl = (uri.scheme == 'https')
@@ -69,6 +70,41 @@ module PactBroker
           Response.new(response)
         end
 
+        def until_truthy_or_max_times options = {}
+          max_tries = options.fetch(:times, default_max_tries)
+          tries = 0
+          sleep_interval = options.fetch(:sleep, 5)
+          sleep(sleep_interval) if options[:sleep_first]
+          while true
+            begin
+              result = yield
+              return result if max_tries < 2
+              if options[:condition]
+                condition_result = options[:condition].call(result)
+                return result if condition_result
+              else
+                return result if result
+              end
+              tries += 1
+              return result if max_tries == tries
+              sleep sleep_interval
+            rescue *RETRYABLE_ERRORS => e
+              tries += 1
+              $stderr.puts "ERROR: Error making request - #{e.class} #{e.message} #{e.backtrace.find{|l| l.include?('pact_broker-client')}}, attempt #{tries} of #{max_tries}"
+              raise e if max_tries == tries
+              sleep sleep_interval
+            end
+          end
+        end
+
+        def default_max_tries
+          5
+        end
+
+        def sleep seconds
+          Kernel.sleep seconds
+        end
+
         def output_stream
           AuthorizationHeaderRedactor.new($stdout)
         end

data/lib/pact_broker/client/hal/link.rb

@@ -49,14 +49,26 @@ module PactBroker
           wrap_response(href, @http_client.put(href, payload ? JSON.dump(payload) : nil, headers))
         end
 
+        def put!(*args)
+          put(*args).assert_success!
+        end
+
         def post(payload = nil, headers = {})
           wrap_response(href, @http_client.post(href, payload ? JSON.dump(payload) : nil, headers))
         end
 
+        def post!(*args)
+          post(*args).assert_success!
+        end
+
         def patch(payload = nil, headers = {})
           wrap_response(href, @http_client.patch(href, payload ? JSON.dump(payload) : nil, headers))
         end
 
+        def patch!(*args)
+          patch(*args).assert_success!
+        end
+
         def expand(params)
           expanded_url = expand_url(params, href)
           new_attrs = @attrs.merge('href' => expanded_url)

data/lib/pact_broker/client/hal/links.rb

@@ -30,6 +30,21 @@ module PactBroker
           links.find{ | link | link.name == name }
         end
 
+        def select!(name, not_found_message = nil)
+          selected_links = select(name)
+          if selected_links.any?
+            selected_links
+          else
+            message = not_found_message || "Could not find relation '#{key}' with name '#{name}' in resource at #{href}."
+            available_options = names.any? ? names.join(", ") : "<none found>"
+            raise RelationNotFoundError.new(message.chomp(".") + ". Available options: #{available_options}")
+          end
+        end
+
+        def select(name)
+          links.select{ | link | link.name == name }
+        end
+
         private
 
         attr_reader :links, :key, :href

data/lib/pact_broker/client/hal_client_methods.rb

@@ -21,6 +21,14 @@ module PactBroker
           index_entry_point.get!
         end
       end
+
+      def is_pactflow?
+        index_resource.response.headers.keys.any?{ | header_name | header_name.downcase.include?("pactflow") }
+      end
+
+      def pact_broker_name
+        is_pactflow? ? "Pactflow" : "the Pact Broker"
+      end
     end
   end
 end

data/lib/pact_broker/client/matrix.rb

@@ -60,6 +60,9 @@ module PactBroker
         elsif selectors.size == 1 && !options[:to_environment]
           opts[:latest] = 'true'
         end
+        if options[:ignore_selectors] && options[:ignore_selectors].any?
+          opts[:ignore] = convert_selector_hashes_to_params(options[:ignore_selectors])
+        end
         opts
       end
 
@@ -69,6 +72,7 @@ module PactBroker
             hash[:version] = selector[:version] if selector[:version]
             hash[:latest] = 'true' if selector[:latest]
             hash[:tag] = selector[:tag] if selector[:tag]
+            hash[:branch] = selector[:branch] if selector[:branch]
           end
         end
       end

data/lib/pact_broker/client/matrix/abbreviate_version_number.rb

@@ -0,0 +1,15 @@
+module PactBroker
+  module Client
+    class Matrix
+      class AbbreviateVersionNumber
+        def self.call version_number
+          if version_number
+            version_number.gsub(/[A-Za-z0-9]{40}/) do | val |
+              val[0...7] + "..."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/matrix/resource.rb

@@ -2,9 +2,22 @@ require 'pact_broker/client/base_client'
 
 module PactBroker
   module Client
+    class Notice < Hash
+      def initialize(hash)
+        self.merge!(hash)
+      end
+
+      def text
+        self[:text]
+      end
+
+      def type
+        self[:type]
+      end
+    end
     class Matrix < BaseClient
-      class Resource < Hash
 
+      class Resource < Hash
         def initialize hash
           self.merge!(hash)
         end
@@ -21,6 +34,10 @@ module PactBroker
           !!(self[:summary] && Integer === self[:summary][:unknown] )
         end
 
+        def supports_ignore?
+          !!(self[:summary] && Integer === self[:summary][:ignored] )
+        end
+
         def unknown_count
           supports_unknown_count? ? self[:summary][:unknown] : nil
         end
@@ -32,6 +49,14 @@ module PactBroker
         def deployable?
           self[:summary][:deployable]
         end
+
+        def notices
+          if self[:notices].is_a?(Array)
+            self[:notices].collect { | notice_hash | Notice.new(notice_hash) }
+          else
+            nil
+          end
+        end
       end
     end
   end

data/lib/pact_broker/client/matrix/text_formatter.rb

@@ -1,6 +1,7 @@
 require 'table_print'
 require 'dig_rb'
 require 'pact_broker/client/hash_refinements'
+require 'pact_broker/client/matrix/abbreviate_version_number'
 
 module PactBroker
   module Client
@@ -8,18 +9,19 @@ module PactBroker
       class TextFormatter
         using PactBroker::Client::HashRefinements
 
-        Line = Struct.new(:consumer, :consumer_version, :provider, :provider_version, :success, :ref)
+        Line = Struct.new(:consumer, :consumer_version, :provider, :provider_version, :success, :ref, :ignored)
 
-        OPTIONS = [
+        TP_OPTIONS = [
           { consumer: {} },
           { consumer_version: {display_name: 'C.VERSION'} },
           { provider: {} },
           { provider_version: {display_name: 'P.VERSION'} },
           { success: {display_name: 'SUCCESS?'} },
-          { ref: { display_name: 'RESULT#' }}
+          { ref: { display_name: 'RESULT#' } }
         ]
 
         def self.call(matrix)
+          tp_options = TP_OPTIONS.dup
           matrix_rows = matrix[:matrix]
           return "" if matrix_rows.size == 0
           verification_result_number = 0
@@ -30,15 +32,16 @@ module PactBroker
             end
             Line.new(
               lookup(line, "???", :consumer, :name),
-              lookup(line, "???", :consumer, :version, :number),
+              AbbreviateVersionNumber.call(lookup(line, "???", :consumer, :version, :number)),
               lookup(line, "???", :provider, :name) ,
-              lookup(line, "???", :provider, :version, :number),
-              (lookup(line, "???", :verificationResult, :success)).to_s,
-              has_verification_result_url ? verification_result_number : ""
+              AbbreviateVersionNumber.call(lookup(line, "???", :provider, :version, :number)),
+              (lookup(line, "???", :verificationResult, :success)).to_s + ( line[:ignored] ? " [ignored]" : ""),
+              has_verification_result_url ? verification_result_number : "",
+              lookup(line, nil, :ignored)
             )
           end
 
-          printer = TablePrint::Printer.new(data, OPTIONS)
+          printer = TablePrint::Printer.new(data, tp_options)
           printer.table_print + verification_result_urls_text(matrix)
         end