pact_broker-client 1.38.2 → 1.42.0

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,38 +9,44 @@ module PactBroker
       class TextFormatter
         using PactBroker::Client::HashRefinements
 
-        Line = Struct.new(:consumer, :consumer_version, :provider, :provider_version, :success, :ref)
-
-        OPTIONS = [
-          { consumer: {} },
-          { consumer_version: {display_name: 'C.VERSION'} },
-          { provider: {} },
-          { provider_version: {display_name: 'P.VERSION'} },
-          { success: {display_name: 'SUCCESS?'} },
-          { ref: { display_name: 'RESULT#' }}
-        ]
+        Line = Struct.new(:consumer, :consumer_version, :provider, :provider_version, :success, :ref, :ignored)
 
         def self.call(matrix)
           matrix_rows = matrix[:matrix]
           return "" if matrix_rows.size == 0
+          data = prepare_data(matrix_rows)
+          printer = TablePrint::Printer.new(data, tp_options(data))
+          printer.table_print + verification_result_urls_text(matrix)
+        end
+
+        def self.prepare_data(matrix_rows)
           verification_result_number = 0
-          data = matrix_rows.each_with_index.collect do | line |
+          matrix_rows.each_with_index.collect do | line |
             has_verification_result_url = lookup(line, nil, :verificationResult, :_links, :self, :href)
             if has_verification_result_url
               verification_result_number += 1
             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
+        end
 
-          printer = TablePrint::Printer.new(data, OPTIONS)
-          printer.table_print + verification_result_urls_text(matrix)
+        def self.tp_options(data)
+          [
+            { consumer: { width: max_width(data, :consumer, 'CONSUMER') } },
+            { consumer_version: { display_name: 'C.VERSION', width: max_width(data, :consumer_version, 'C.VERSION') } },
+            { provider: { width: max_width(data, :provider, 'PROVIDER') } },
+            { provider_version: { display_name: 'P.VERSION', width: max_width(data, :provider_version, 'P.VERSION') } },
+            { success: { display_name: 'SUCCESS?' } },
+            { ref: { display_name: 'RESULT#' } }
+          ]
         end
 
         def self.lookup line, default, *keys
@@ -72,6 +79,10 @@ module PactBroker
             text
           end
         end
+
+        def self.max_width(data, column, title)
+          (data.collect{ |row| row.send(column) } + [title]).compact.collect(&:size).max
+        end
       end
     end
   end

data/lib/pact_broker/client/pacticipants.rb

@@ -1,3 +1,9 @@
+# New code
+Dir.glob(File.join(__FILE__.gsub(".rb", "/**/*.rb"))).sort.each do | path |
+  require path
+end
+
+# Old code
 require 'pact_broker/client/base_client'
 
 module PactBroker

data/lib/pact_broker/client/pacticipants/create.rb

@@ -1,55 +1,45 @@
-require 'pact_broker/client/hal'
-require 'json'
-require 'pact_broker/client/command_result'
-require 'pact_broker/client/hal_client_methods'
+require 'pact_broker/client/base_command'
 
 module PactBroker
   module Client
     module Pacticipants2
-      class Create
+      class Create < PactBroker::Client::BaseCommand
 
-        include HalClientMethods
+        private
 
-        def self.call(params, pact_broker_base_url, pact_broker_client_options)
-          new(params, pact_broker_base_url, pact_broker_client_options).call
-        end
+        attr_reader :action, :response_entity
 
-        def initialize(params, pact_broker_base_url, pact_broker_client_options)
-          @params = params
-          @index_entry_point = create_index_entry_point(pact_broker_base_url, pact_broker_client_options)
-          @verbose = pact_broker_client_options[:verbose]
-        end
+        def do_call
+          pacticipant_entity = index_resource._link('pb:pacticipant').expand('pacticipant' => params[:name]).get
 
-        def call
-          pacticipant_entity = index_entity._link('pb:pacticipant').expand('pacticipant' => params[:name]).get
-          message = nil
           response_entity = if pacticipant_entity.does_not_exist?
-            message = "Pacticipant \"#{params[:name]}\" created"
-            index_entity._link!('pb:pacticipants').post(pacticipant_resource_params)
+            @action = "created"
+            index_resource._link!('pb:pacticipants').post!(pacticipant_resource_params)
+          elsif pacticipant_entity.success?
+            @action = "updated"
+            pacticipant_entity._link!('self').patch!(pacticipant_resource_params)
           else
-            message = "Pacticipant \"#{params[:name]}\" updated"
-            pacticipant_entity._link!('self').patch(pacticipant_resource_params)
+            pacticipant_entity.assert_success!
           end
 
           response_entity.assert_success!
-          PactBroker::Client::CommandResult.new(true, message)
-        rescue StandardError => e
-          $stderr.puts("#{e.class} - #{e}\n#{e.backtrace.join("\n")}") if verbose
-          PactBroker::Client::CommandResult.new(false, "#{e.class} - #{e}")
+          PactBroker::Client::CommandResult.new(true, result_message)
         end
 
-        private
-
-        attr_reader :index_entry_point, :params, :verbose
-
-        def index_entity
-          @index_entity ||= index_entry_point.get!
+        def result_message
+          if json_output?
+            response_entity.response.raw_body
+          else
+            green(message = "Pacticipant \"#{params[:name]}\" #{action}")
+          end
         end
 
         def pacticipant_resource_params
-          p = { name: params[:name] }
-          p[:repositoryUrl] = params[:repository_url] if params[:repository_url]
-          p
+          {
+            name: params[:name],
+            repositoryUrl: params[:repository_url],
+            displayName: params[:display_name]
+          }.compact
         end
       end
     end

data/lib/pact_broker/client/pacticipants/list.rb

@@ -0,0 +1,34 @@
+require 'pact_broker/client/base_command'
+require 'pact_broker/client/pacticipants/text_formatter'
+
+module PactBroker
+  module Client
+    module Pacticipants2
+      class List < PactBroker::Client::BaseCommand
+        private
+
+        attr_reader :environments_resource
+
+        def do_call
+          PactBroker::Client::CommandResult.new(true, result_message)
+        end
+
+        def environments_resource
+          @environments_resource = environments_link.get!
+        end
+
+        def environments_link
+          index_resource._link!('pb:pacticipants')
+        end
+
+        def result_message
+          if json_output?
+            environments_resource.response.raw_body
+          else
+            TextFormatter.call(environments_resource._embedded["pacticipants"])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'table_print'
+require 'ostruct'
+
+module PactBroker
+  module Client
+    module Pacticipants2
+      class TextFormatter
+        def self.call(pacticipants)
+          return "" if pacticipants.size == 0
+
+          data = pacticipants.collect do | pacticipant |
+            # Might add a UUID in at some stage. Backwards compatible supporting code.
+            OpenStruct.new({ uuid: "" }.merge(pacticipant).merge(url: pacticipant["_links"]["self"]["href"]))
+          end.sort_by{ | pacticipant | pacticipant.name.downcase }
+
+          TablePrint::Printer.new(data, tp_options(data)).table_print
+        end
+
+        def self.tp_options(data)
+          uuid_width = max_width(data, :uuid, "")
+          name_width = max_width(data, :name, "NAME")
+          display_name_width = max_width(data, :displayName, "DISPLAY NAME")
+
+          tp_options = [
+            { name: { width: name_width} },
+            { displayName: { display_name: "Display name", width: display_name_width } },
+          ]
+
+          if uuid_width > 0
+            tp_options.unshift({ uuid: { width: uuid_width } })
+          end
+          tp_options
+        end
+
+        def self.max_width(data, column, title)
+          (data.collect{ |row| row.send(column) } + [title]).compact.collect(&:size).max
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/client/pacts.rb

@@ -4,7 +4,6 @@ require 'pact_broker/client/pact_hash'
 module PactBroker
   module Client
     class Pacts  < BaseClient
-
       def publish options
         consumer_version = options[:consumer_version]
         pact_hash = options[:pact_hash]

data/lib/pact_broker/client/publish_pacts.rb

@@ -1,11 +1,8 @@
 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 'base64'
+require 'pact_broker/client/publish_pacts_the_old_way'
+require 'pact_broker/client/colorize_notices'
 
 module PactBroker
   module Client
@@ -13,170 +10,135 @@ module PactBroker
       using PactBroker::Client::HashRefinements
       include HalClientMethods
 
-      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
+      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, pact_broker_client_options={}
+      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]
+        @consumer_version_params = consumer_version_params
+        @consumer_version_number = strip(consumer_version_params[:number])
+        @branch = strip(consumer_version_params[:branch])
+        @build_url = strip(consumer_version_params[:build_url])
+        @tags = consumer_version_params[:tags] ? consumer_version_params[:tags].collect{ |tag| strip(tag) } : []
+        @options = options
         @pact_broker_client_options = pact_broker_client_options
       end
 
       def call
         validate
-        $stdout.puts("")
-        result = create_consumer_versions && apply_tags && publish_pacts
-        $stdout.puts("")
-        result
+        if ENV.fetch("PACT_BROKER_FEATURES", "").include?("publish_contracts") && index_resource.can?("pb:publish-contracts")
+          publish_pacts
+          PactBroker::Client::CommandResult.new(success?, message)
+        else
+          PublishPactsTheOldWay.call(pact_broker_base_url, pact_file_paths, consumer_version_params, options, pact_broker_client_options)
+        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
+      attr_reader :pact_broker_base_url, :pact_file_paths, :consumer_version_params, :consumer_version_number, :branch, :tags, :build_url, :options, :pact_broker_client_options, :response_entities
 
-      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
+      def request_body_for(consumer_name)
+        {
+          pacticipantName: consumer_name,
+          pacticipantVersionNumber: consumer_version_number,
+          tags: tags,
+          branch: branch,
+          buildUrl: build_url,
+          contracts: contracts_for(consumer_name)
+        }.compact
       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
+        @response_entities = consumer_names.collect do | consumer_name |
+          index_resource._link("pb:publish-contracts").post(request_body_for(consumer_name))
+        end
       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
+      def success?
+        response_entities.all?(&:success?)
       end
 
-      def create_consumer_versions
-        if create_versions?
-          consumer_names.collect do | consumer_name |
-            create_version(index_resource, consumer_name)
-          end
-          true
+      def message
+        if options[:output] == "json"
+          response_entities.collect(&:response).collect(&:body).to_a.to_json
         else
-          true
+          text_message
         end
       end
 
-      def create_versions?
-        if version_required
-          if can_create_version_with_branch?
-            true
+      def text_message
+        response_entities.flat_map do | response_entity |
+          if response_entity.success?
+            if response_entity.notices
+              PactBroker::Client::ColorizeNotices.call(response_entity.notices.collect{ |n| OpenStruct.new(n) } )
+            elsif response_entity.logs
+              response_entity.logs.collect do | log |
+                colorized_message(log)
+              end
+            else
+              "Successfully published pacts"
+            end
           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.")
+            ::Term::ANSIColor.red(response_entity.response.body.to_s)
           end
-        elsif (branch || build_url) && can_create_version_with_branch?
-          true
+        end.join("\n")
+      end
+
+      def colorized_message(log)
+        color = color_for_level(log["level"])
+        if color
+          ::Term::ANSIColor.send(color, log["message"])
         else
-          false
+          log["message"]
         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
+      def color_for_level(level)
+        case level
+        when "warn" then :yellow
+        when "error" then :red
+        when "info" then :green
+        else nil
+        end
+      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
+      def contracts_for(consumer_name)
+        pact_files_for(consumer_name).group_by(&:pact_name).values.collect do | pact_files |
+          $stderr.puts "Merging #{pact_files.collect(&:path).join(", ")}" if pact_files.size > 1
+          pact_hash = PactHash[merge_contents(pact_files)]
+          {
+            consumerName: pact_hash.consumer_name,
+            providerName: pact_hash.provider_name,
+            specification: "pact",
+            contentType: "application/json",
+            content: Base64.strict_encode64(pact_hash.to_json),
+            writeMode: write_mode,
+            onConflict: write_mode
+          }
         end
       end
 
-      def version_body
-        {
-          branch: branch,
-          buildUrl: build_url
-        }.compact
+      def merge_contents(pact_files)
+        MergePacts.call(pact_files.collect(&:pact_hash))
       end
 
-      def apply_tags
-        return true if tags.empty?
-        tags.all? do | tag |
-          tag_consumer_version tag
-        end
+      def pact_files
+        @pact_files ||= pact_file_paths.collect{ |pact_file_path| PactFile.new(pact_file_path) }
       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
+      def pact_files_for(consumer_name)
+        pact_files.select{ | pact_file | pact_file.consumer_name == consumer_name }
       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
+      def consumer_names
+        pact_files.collect(&:consumer_name).uniq
+      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
+      def write_mode
+        options[:merge] ? "merge" : "overwrite"
       end
 
       def validate
@@ -184,6 +146,10 @@ module PactBroker
         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
+
+      def strip(maybe_string)
+        maybe_string.respond_to?(:strip) ? maybe_string.strip : maybe_string
+      end
     end
   end
 end