pact_broker-client 1.32.0 → 1.37.0

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

@@ -83,6 +83,10 @@ module PactBroker
             end
           end
 
+          def headers
+            __getobj__().to_hash
+          end
+
           def raw_body
             __getobj__().body
           end

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

@@ -0,0 +1,39 @@
+require 'uri'
+require 'delegate'
+
+module PactBroker
+  module Client
+    module Hal
+      class Links
+        def initialize(href, key, links)
+          @href = href
+          @key = key
+          @links = links
+        end
+
+        def names
+          @names ||= links.collect(&:name).compact.uniq
+        end
+
+        def find!(name, not_found_message = nil)
+          link = find(name)
+          if link
+            link
+          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 find(name)
+          links.find{ | link | link.name == name }
+        end
+
+        private
+
+        attr_reader :links, :key, :href
+      end
+    end
+  end
+end

data/lib/pact_broker/client/hal_client_methods.rb

@@ -1,4 +1,5 @@
 require 'pact_broker/client/hal'
+require 'pact_broker/client/retry'
 
 module PactBroker
   module Client
@@ -10,6 +11,16 @@ module PactBroker
       def create_http_client(pact_broker_client_options)
         PactBroker::Client::Hal::HttpClient.new(pact_broker_client_options.merge(pact_broker_client_options[:basic_auth] || {}))
       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
     end
   end
 end

data/lib/pact_broker/client/hash_refinements.rb

@@ -0,0 +1,19 @@
+module PactBroker
+  module Client
+    module HashRefinements
+      refine Hash do
+        def compact
+          h = {}
+          each do |key, value|
+            h[key] = value unless value == nil
+          end
+          h
+        end unless Hash.method_defined? :compact
+
+        def compact!
+          reject! {|_key, value| value == nil}
+        end unless Hash.method_defined? :compact!
+      end
+    end
+  end
+end

data/lib/pact_broker/client/matrix.rb

@@ -53,10 +53,11 @@ module PactBroker
           opts[:success] = [*options[:success]]
         end
         opts[:limit] = options[:limit] if options[:limit]
+        opts[:environment] = options[:to_environment] if options[:to_environment]
         if options[:to_tag]
           opts[:latest] = 'true'
           opts[:tag] = options[:to_tag]
-        elsif selectors.size == 1
+        elsif selectors.size == 1 && !options[:to_environment]
           opts[:latest] = 'true'
         end
         opts

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

@@ -1,41 +1,76 @@
 require 'table_print'
+require 'dig_rb'
+require 'pact_broker/client/hash_refinements'
 
 module PactBroker
   module Client
     class Matrix
       class TextFormatter
+        using PactBroker::Client::HashRefinements
 
-        Line = Struct.new(:consumer, :consumer_version, :provider, :provider_version, :success)
+        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?'} }
+          { success: {display_name: 'SUCCESS?'} },
+          { ref: { display_name: 'RESULT#' }}
         ]
 
         def self.call(matrix)
           matrix_rows = matrix[:matrix]
           return "" if matrix_rows.size == 0
-          data = matrix_rows.collect do | line |
+          verification_result_number = 0
+          data = 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),
-              lookup(line, :provider, :name),
-              lookup(line, :provider, :version, :number),
-              lookup(line, :verificationResult, :success).to_s
+              lookup(line, "???", :consumer, :name),
+              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 : ""
             )
           end
 
           printer = TablePrint::Printer.new(data, OPTIONS)
-          printer.table_print
+          printer.table_print + verification_result_urls_text(matrix)
         end
 
-        def self.lookup line, *keys
+        def self.lookup line, default, *keys
           keys.reduce(line) { | line, key | line[key] }
         rescue NoMethodError
-          "???"
+          default
+        end
+
+        def self.verification_results_urls_and_successes(matrix)
+          (matrix[:matrix] || []).collect do | row |
+            url = row.dig(:verificationResult, :_links, :self, :href)
+            if url
+              success = row.dig(:verificationResult, :success)
+              [url, success]
+            else
+              nil
+            end
+          end.compact
+        end
+
+        def self.verification_result_urls_text(matrix)
+          text = self.verification_results_urls_and_successes(matrix).each_with_index.collect do |(url, success), i|
+            status = success ? 'success' : 'failure'
+            "#{i+1}. #{url} (#{status})"
+          end.join("\n")
+
+          if text.size > 0
+            "\n\nVERIFICATION RESULTS\n--------------------\n#{text}"
+          else
+            text
+          end
         end
       end
     end

data/lib/pact_broker/client/publish_pacts.rb

@@ -4,39 +4,64 @@ 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
-        @tags = 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
+
       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
@@ -66,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
@@ -77,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
@@ -90,18 +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)
-            $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.)")
+          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)
+          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