pact_broker 2.121.2 → 2.123.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49b03441c7f3ea31c20e1db9c053c6b4ce782ad321007ae1da0614774a62d614
-  data.tar.gz: 4898703bc36456dfd31a8d590834c2e8fd6c6f7f2a3f1919285b6358cb7e1311
+  metadata.gz: e464517845e4046dd28826ab16b367d5080b69cb535f9a9d5901feda4f262bd8
+  data.tar.gz: 9959dfb3c78a5e3940a94306133b1e92244a2531cd275f2fb7353c98faa153a8
 SHA512:
-  metadata.gz: 54728a387b6667b0867929ad94eec94fcd0eb303a84c1e8fce2311705b7971c168205a62364f77fc5754483cef7605f582d3b820d833c25693cd6cd2d17c23f7
-  data.tar.gz: '069dbe6afe3197ef3ad6f8035d6aee22998d8ecdec1cd582dae0d94a5555741a347a5be2ba129609f97189526a5a2ca2469fe2673805dabf26b8c22abe9acab6'
+  metadata.gz: cfdf7a02904a49f475cc615a0a097eaa6b2a3d438df70e3523eae4fe29d7eb7052bc211a07bf70446d6ae76941309bc98846c155285d9ce1efae85718d39e94a
+  data.tar.gz: b8dd289895ecf228815e1532d607e15ce7ffd5d41b4ff43f141b2944239aec2f415152189fc73b9aa1725cb4d1dd1ab7a231563bdb0cf576ed4afa53d9067f65

data/CHANGELOG.md

@@ -1,3 +1,119 @@
+## [2.123.0] _2026-11-11_
+
+### 🚀 Features
+
+-   Add fallbackToMainBranch consumer version selector option
+
+### 🐛 Bug Fixes
+
+-   Stop the consumer version verification summary querying per verification
+-   Apply fallbackTag per consumer
+-   Honour fallbackBranch in consumer version selectors
+
+### 🚜 Refactor
+
+-   Name the fallback resolver for tags and branches
+
+### ⚡️ Performance
+
+-   Speed up publishing large contracts (PACT-7601) ([#1067](https://github.com/pact-foundation/pact_broker/issues/1067))
+    > **Migration note:** when contracts are published with /contracts/publish,
+    > the configured sha_generator is now called with a second argument,
+-   Exclude consumers in the fallback tag query
+-   Exclude consumers in the fallback branch query
+
+### 📚 Documentation
+
+-   Say fallbackTag applies per consumer
+-   Say fallbackBranch applies per consumer
+
+### 🧪 Testing
+
+-   Share one SQL query counter across feature specs
+-   Pin fallbackTag semantics in a table
+-   Cover fallbackTag dedup, branches and notices
+-   Pin fallbackBranch semantics in a table
+-   Cover the fallbackBranch request and notices end to end
+-   Pin fallbackToMainBranch semantics in the fallback branch table
+-   Cover the fallbackToMainBranch request and notices end to end
+
+### 🛠️ Miscellaneous Tasks
+
+-   Drop a TODO the selector contract already resolves
+
+## [2.122.0] _2026-10-01_
+
+### 🚀 Features
+
+-   Add a unified diff renderer
+-   Render pact diffs as unified diffs
+    > **Migration note:** the pact diff endpoints return a standard unified diff.
+    > This covers the `diff/previous-distinct`, `diff/version/{version}` and
+    > `pact-version/{sha}/diff/pact-version/{sha}` resources under
+    > `/pacts/provider/{provider}/consumer/{consumer}`, and the diff notice
+    > that `POST /contracts/publish` returns when a publish would modify an
+    > existing pact. Clients that parse this output must handle `@@` hunk
+    > headers and unchanged context lines. Keys that exist only in the newer
+    > pact now appear as `+` lines.
+    > 
+    > As an example, take an interaction whose request method changes from
+    > post to get and which gains an `Accept` header. The diff was previously:
+    > 
+    > ```diff
+    >    "interactions": [
+    >      {
+    >        "request": {
+    > -        "method": "post"
+    > +        "method": "get"
+    >        }
+    >      }
+    >    ]
+    > ```
+    > 
+    > It is now:
+    > 
+    > ```diff
+    > @@ -6,7 +6,10 @@
+    >      {
+    >        "description": "a request",
+    >        "request": {
+    > -        "method": "post",
+    > +        "headers": {
+    > +          "Accept": "application/json"
+    > +        },
+    > +        "method": "get",
+    >          "path": "/"
+    >        },
+    >        "response": {
+    > ```
+
+### 🐛 Bug Fixes
+
+-   Require date_helper in HtmlPactRenderer
+
+### 🚜 Refactor
+
+-   Remove unused pact/doc generator code
+-   Compare pact content with Hash equality
+-   Move lib/pact/doc under lib/pact_broker/api/renderers
+-   Move the markdown pact renderer under PactBroker
+-   Render pact HTML from the parsed hash
+
+### 🧪 Testing
+
+-   Stop snapshotting non-determinate response headers
+-   Replace Pact::Matchers in spec helpers with a subset matcher
+
+### 🛠️ Miscellaneous Tasks
+
+-   _(ci)_ Standardize renovate config
+-   _(ci)_ Remove stale internal workflow
+-   Remove the pact-support dependency
+    > **Migration note:** pact_broker no longer depends on pact-support, so code
+    > alongside the broker can no longer rely on Pact::* constants. Add
+    > pact-support to your own Gemfile if that code needs them.
+-   _(release)_ Render Migration-Note footers in the changelog
+
 ## [2.121.2] _2026-09-17_
 
 ### 🐛 Bug Fixes

data/Gemfile

@@ -26,7 +26,7 @@ group :test do
     gem "pact-ffi", path: "../pact-ruby-ffi"
   else
     gem "pact", ">=2.0.3"
-    gem "pact-ffi", "~>0.4.28"
+    gem "pact-ffi", "~>0.5.0"
   end
   gem "rack-test", ">= 0.6.3", "< 3.0.0"
   gem "bundler-audit", "~>0.4"
@@ -47,6 +47,3 @@ group :pg, optional: true do
   gem "pg", "~>1.6"
 end
 
-if ENV["X_PACT_DEVELOPMENT"] == "true"
-  gem "pact-support", path: "../pact-support"
-end

data/lib/pact_broker/api/contracts/consumer_version_selector_contract.rb

@@ -6,7 +6,7 @@ module PactBroker
       class ConsumerVersionSelectorContract < BaseContract
         option :parent # the parent hash in which the ConsumerVersionSelector is embedded
 
-        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :matchingBranch, :mainBranch]
+        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :fallbackToMainBranch, :matchingBranch, :mainBranch]
         ENVIRONMENT_KEYS = [:environment, :deployed, :released, :deployedOrReleased]
         ALL_KEYS = BRANCH_KEYS + ENVIRONMENT_KEYS + [:consumer]
 
@@ -18,6 +18,7 @@ module PactBroker
           optional(:latest).filled(included_in?: [true, false])
           optional(:fallbackTag).filled(:str?)
           optional(:fallbackBranch).filled(:str?)
+          optional(:fallbackToMainBranch).filled(included_in?: [true])
           optional(:consumer).filled(:str?)
           optional(:deployed).filled(included_in?: [true])
           optional(:released).filled(included_in?: [true])
@@ -108,6 +109,21 @@ module PactBroker
           end
         end
 
+        # fallbackToMainBranch
+        rule(:fallbackToMainBranch, :fallbackBranch, :branch, :latest) do
+          if values[:fallbackToMainBranch] && !values[:branch]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_requires_branch"))
+          end
+
+          if values[:fallbackToMainBranch] && values[:fallbackBranch]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_and_fallback_branch_disallowed"))
+          end
+
+          if values[:fallbackToMainBranch] && values[:latest] == false
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_and_latest_false_disallowed"))
+          end
+        end
+
         # branch/latest
         rule(:branch, :latest) do
           if values[:branch] && values[:latest] == false

data/lib/pact_broker/api/contracts/utf_8_validation.rb

@@ -5,7 +5,11 @@ module PactBroker
         extend self
 
         def fragment_before_invalid_utf_8_char(string)
-          string.force_encoding("UTF-8").each_char.with_index do | char, index |
+          # Iterating over each char allocates a String per char, which is very slow for large strings,
+          # so only do it to find the location of the invalid char once we know there is one.
+          return nil if string.force_encoding("UTF-8").valid_encoding?
+
+          string.each_char.with_index do | char, index |
             if !char.valid_encoding?
               fragment = index < 100 ? string[0...index] : string[index-100...index]
               return index + 1, fragment

data/lib/pact_broker/api/decorators/pacts_for_verification_query_decorator.rb

@@ -34,6 +34,7 @@ module PactBroker
             }
           property :fallback_tag
           property :fallback_branch
+          property :fallback_to_main_branch
           property :consumer
           property :environment_name, as: :environment
           property :currently_deployed, as: :deployed

data/lib/pact_broker/api/decorators/publish_contract_decorator.rb

@@ -11,10 +11,11 @@ module PactBroker
         property :provider_name
         property :specification
         property :content_type
-        property :decoded_content, setter: -> (fragment:, represented:, user_options:, **) {
+        property :decoded_content, setter: -> (fragment:, represented:, user_options:, doc:, **) {
           represented.decoded_content = fragment
-          # Set the pact version sha when we set the content
-          represented.pact_version_sha = user_options.fetch(:sha_generator).call(fragment)
+          # Set the pact version sha when we set the content, reusing the content that has already been
+          # parsed in the resource, as parsing very large pacts is expensive
+          represented.pact_version_sha = user_options.fetch(:sha_generator).call(fragment, parsed_content: doc["decodedParsedContent"])
         }
         property :on_conflict, default: "overwrite"
 

data/lib/pact_broker/api/decorators/verification_decorator.rb

@@ -24,7 +24,7 @@ module PactBroker
         end
 
         link :self do | options |
-          pact = options[:pact] || represented.latest_pact_publication
+          pact = pact_for(options)
           {
             title: "Verification result",
             name: "Verification result #{represented.number} for #{pact.name}",
@@ -33,7 +33,7 @@ module PactBroker
         end
 
         link "pb:pact-version" do | options |
-          pact = options[:pact] || represented.latest_pact_publication
+          pact = pact_for(options)
           {
             title: "Pact",
             name: pact.name,
@@ -47,6 +47,16 @@ module PactBroker
             href: verification_triggered_webhooks_url(represented, options.fetch(:base_url))
           }
         end
+
+        private
+
+        # A decorator rendering many verifications passes :pacts_by_pact_version_sha
+        # so each one avoids its own lookup.
+        def pact_for(options)
+          options[:pact] ||
+            options[:pacts_by_pact_version_sha]&.[](represented.pact_version_sha) ||
+            represented.latest_pact_publication
+        end
       end
     end
   end

data/lib/pact_broker/api/decorators/verification_summary_decorator.rb

@@ -25,6 +25,12 @@ module PactBroker
           }
         end
 
+        # representable passes through the kwargs from to_json as normal args
+        def to_hash(options)
+          user_options = options.fetch(:user_options, {}).merge(pacts_by_pact_version_sha: represented.pacts_by_pact_version_sha)
+          super(options.merge(user_options: user_options))
+        end
+
         def provider_summary
           OpenStruct.new(
             successful: represented.select(&:success).collect(&:provider_name),

data/lib/pact_broker/api/renderers/html_pact_renderer.rb

@@ -1,9 +1,8 @@
-require "pact/consumer_contract"
-require "pact/reification"
 require "redcarpet"
-require "pact/doc/markdown/consumer_contract_renderer"
+require "pact_broker/api/renderers/markdown/consumer_contract_renderer"
 require "pact_broker/api/pact_broker_urls"
 require "pact_broker/logging"
+require "pact_broker/date_helper"
 require "rack"
 
 module PactBroker
@@ -11,8 +10,6 @@ module PactBroker
     module Renderers
       class HtmlPactRenderer
 
-        class NotAPactError < StandardError; end
-
         include PactBroker::Logging
 
         def self.call pact, options = {}
@@ -182,10 +179,11 @@ module PactBroker
         end
 
         def markdown
-          Pact::Doc::Markdown::ConsumerContractRenderer.call consumer_contract
-        rescue StandardError
+          Markdown::ConsumerContractRenderer.call(JSON.parse(@json_content))
+        rescue StandardError => e
+          logger.info "Could not render the following content as a pact due to #{e.class} #{e.message}, showing raw content instead: #{@json_content}"
           heading = "### A contract between #{@pact.consumer.name} and #{@pact.provider.name}"
-          warning = "_Note: this contract could not be parsed to a v1 or v2 Pact, showing raw content instead._"
+          warning = "_Note: this content could not be rendered as a pact, showing raw JSON instead._"
           pretty_json = JSON.pretty_generate(@pact.content_hash)
           "#{heading}\n#{warning}\n```json\n#{pretty_json}\n```\n"
         end
@@ -194,67 +192,6 @@ module PactBroker
           Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true, :lax_spacing => true).render(markdown)
         end
 
-        def consumer_contract
-          pact_object = JSON.parse(@json_content)
-          convert_v3_messages_to_interactions(pact_object)
-
-          pact_object["interactions"]&.each do |interaction|
-            add_dummy_html_request_response_to_asynchronous_message(interaction)
-            add_dummy_html_request_response_to_synchronous_message(interaction)
-          end
-
-          new_json_content = pact_object.to_json  
-
-          Pact::ConsumerContract.from_json(new_json_content)
-        rescue => e
-          logger.info "Could not parse the following content to a Pact due to #{e.class} #{e.message}, showing raw content instead: #{@json_content}"
-          raise NotAPactError
-        end
-
-        def convert_v3_messages_to_interactions(pact_object)
-          return unless pact_object.key?("messages")
-
-          logger.warn "Detected a v3 Pact, converting 'messages' to 'interactions'."
-          pact_object["interactions"] = pact_object.delete("messages")
-        end        
-
-        def add_dummy_html_request_response_to_asynchronous_message(interaction)
-          if !interaction["request"] || !interaction["response"]
-            logger.warn "Interaction '#{interaction['description']}' does not have a request or response, adding dummy request and response so that they can be parsed and appear on the UI."
-          end
-
-          interaction["request"] ||= {
-            method: "FAKE_ASYNC_METHOD",
-            path: interaction["description"]
-          }
-
-          unless interaction.key?("response")
-            interaction["response"] = {
-              status: "FAKE_ASYNC_METHOD",
-              body: {
-                contents: interaction.delete("contents"),
-                metadata: interaction.delete("metadata")
-              }
-            }
-          end      
-        end
-
-        def add_dummy_html_request_response_to_synchronous_message(interaction)
-          if interaction["type"] == "Synchronous/Messages"
-            interaction["request"] = {
-              method: "FAKE_SYNC_METHOD",
-              path: interaction["description"],
-              body: interaction.delete("request"),
-            }
-            interaction["response"] = {
-              status: "FAKE_SYNC_METHOD",
-              body: {
-                contents: interaction.delete("response"),
-              }              
-            }              
-          end    
-        end
-
         def h string
           Rack::Utils.escape_html(string)
         end

data/lib/pact_broker/api/renderers/markdown/consumer_contract_renderer.rb

@@ -0,0 +1,87 @@
+require "pact_broker/api/renderers/markdown/interaction_renderer"
+require "pact_broker/api/renderers/markdown/interaction_view_model"
+require "rack/utils"
+require "pact_broker/api/renderers/markdown"
+
+module PactBroker
+  module Api
+    module Renderers
+      module Markdown
+        class ConsumerContractRenderer
+
+          # Raised when the content does not have the shape of a pact.
+          class NotAPactError < StandardError; end
+
+          def initialize pact_hash
+            unless pact_hash.is_a?(Hash) && pact_hash["consumer"].is_a?(Hash) && pact_hash["provider"].is_a?(Hash)
+              raise NotAPactError, "content does not have consumer and provider objects"
+            end
+            @pact_hash = pact_hash
+          end
+
+          def self.call pact_hash
+            new(pact_hash).call
+          end
+
+          def call
+            title + summaries_title + summaries + interactions_title + full_interactions
+          end
+
+          private
+
+          attr_reader :pact_hash
+
+          def title
+            "# A pact between #{consumer_name} and #{provider_name}\n\n"
+          end
+
+          def interaction_renderers
+            @interaction_renderers ||= sorted_interactions.collect { |view_model| InteractionRenderer.new(view_model) }
+          end
+
+          def summaries_title
+            "### Requests from #{consumer_name} to #{provider_name}\n\n"
+          end
+
+          def interactions_title
+            "### Interactions\n\n"
+          end
+
+          def summaries
+            interaction_renderers.collect(&:render_summary).join
+          end
+
+          def full_interactions
+            interaction_renderers.collect(&:render_full_interaction).join
+          end
+
+          def sorted_interactions
+            interactions.collect { |interaction| InteractionViewModel.new(interaction, pact_hash) }.sort_by(&:sortable_id)
+          end
+
+          # v3 message pacts keep their interactions under "messages"
+          def interactions
+            Array(pact_hash["interactions"] || pact_hash["messages"])
+          end
+
+          def consumer_name
+            h(markdown_escape pact_hash.dig("consumer", "name"))
+          end
+
+          def provider_name
+            h(markdown_escape pact_hash.dig("provider", "name"))
+          end
+
+          def markdown_escape string
+            return nil unless string
+            string.gsub(MARKDOWN_SPECIAL_CHARS_REGEXP) { |char| "\\#{char}" }
+          end
+
+          def h(text)
+            Rack::Utils.escape_html(text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/renderers/markdown/interaction_renderer.rb

@@ -0,0 +1,52 @@
+require "erb"
+require "rack/utils"
+
+module PactBroker
+  module Api
+    module Renderers
+      module Markdown
+        class InteractionRenderer
+          attr_reader :interaction
+
+          def initialize interaction_view_model
+            @interaction = interaction_view_model
+          end
+
+          def render_summary
+            formatted_provider_states = h(interaction.formatted_provider_states)
+            suffix = formatted_provider_states.empty? ? "" : " given #{formatted_provider_states}"
+            "* [#{h(interaction.description(true))}](##{interaction.id})#{suffix}\n\n"
+          end
+
+          def render_full_interaction
+            if interaction.async?
+              render("/interaction_async.erb")
+            else
+              render("/interaction.erb")
+            end
+          end
+
+          def render template_file
+            ERB.new(template_string(template_file)).result(binding)
+          end
+
+          # The template file is written with only ASCII range characters, so we
+          # can read as UTF-8. But rendered strings must have same encoding as
+          # script encoding because it will joined to strings which are produced by
+          # string literal.
+          def template_string(template_file)
+            File.read(template_contents(template_file), external_encoding: Encoding::UTF_8).force_encoding(__ENCODING__)
+          end
+
+          def template_contents(template_file)
+            File.dirname(__FILE__) + template_file
+          end
+
+          def h(text)
+            Rack::Utils.escape_html(text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/renderers/markdown/interaction_view_model.rb

@@ -0,0 +1,162 @@
+require "cgi"
+require "json"
+require "pact_broker/api/renderers/markdown"
+
+module PactBroker
+  module Api
+    module Renderers
+      module Markdown
+        # Presents one interaction from a parsed pact hash for the markdown
+        # templates. Bodies are printed as stored, so v1 pacts show their
+        # inline json_class matcher objects verbatim.
+        class InteractionViewModel
+          MARKDOWN_BOLD_CHARACTERS = "**"
+          ORDERED_KEYS = ["method", "path", "query", "status", "headers", "body"].freeze
+          ASYNC_REQUEST = "ASYNC_REQUEST"
+
+          def initialize interaction, pact
+            @interaction = interaction
+            @pact = pact
+          end
+
+          def id
+            @id ||= begin
+              full_desc = if has_provider_state?
+                            "#{description} given #{provider_state_name}"
+                          else
+                            description
+                          end
+              CGI.escapeHTML(full_desc.gsub(/\s+/, "_"))
+            end
+          end
+
+          def sortable_id
+            "#{(interaction["description"] || "").downcase} #{http_response["status"]} #{(provider_state_name || "").downcase}"
+          end
+
+          def consumer_name
+            markdown_escape pact.dig("consumer", "name")
+          end
+
+          def provider_name
+            markdown_escape pact.dig("provider", "name")
+          end
+
+          def has_provider_state?
+            !provider_state_name.nil? && !provider_state_name.empty?
+          end
+
+          def provider_state start_of_sentence = false
+            markdown_escape apply_capitals(provider_state_name.strip, start_of_sentence)
+          end
+
+          def formatted_provider_states mark_bold: false
+            bold_marker = mark_bold ? MARKDOWN_BOLD_CHARACTERS : ""
+
+            provider_state_names.map do |name|
+              "#{bold_marker}#{markdown_escape(apply_capitals(name.strip, false))}#{bold_marker}"
+            end.join(" and ")
+          end
+
+          def description start_of_sentence = false
+            return "" unless interaction["description"]
+            markdown_escape apply_capitals(interaction["description"].strip, start_of_sentence)
+          end
+
+          def request
+            return ASYNC_REQUEST if async?
+            JSON.pretty_generate(clean_request)
+          end
+
+          def response
+            JSON.pretty_generate(clean_response)
+          end
+
+          def async?
+            interaction["type"] == "Asynchronous/Messages" || !interaction.key?("request")
+          end
+
+          private
+
+          attr_reader :interaction, :pact
+
+          def sync?
+            interaction["type"] == "Synchronous/Messages"
+          end
+
+          def http_request
+            interaction["request"].is_a?(Hash) ? interaction["request"] : {}
+          end
+
+          def http_response
+            interaction["response"].is_a?(Hash) ? interaction["response"] : {}
+          end
+
+          def clean_request
+            if sync?
+              http_request.slice("contents", "metadata")
+            else
+              ordered_clean_hash(http_request).tap do |h|
+                h["body"] = http_request["body"] if http_request["body"]
+              end
+            end
+          end
+
+          def clean_response
+            if sync?
+              Array(interaction["response"]).map { |item| item.to_h.slice("contents", "metadata") }
+            elsif async?
+              { "contents" => interaction["contents"], "metadata" => interaction["metadata"] }
+            else
+              ordered_clean_hash(http_response)
+            end
+          end
+
+          # Removes empty header and body hashes, as an empty hash means
+          # "allow anything" and reads more cleanly when omitted.
+          def ordered_clean_hash source
+            ORDERED_KEYS.each_with_object({}) do |key, target|
+              if source.key? key
+                target[key] = source[key] unless value_is_an_empty_hash(source[key])
+              end
+            end
+          end
+
+          def value_is_an_empty_hash value
+            value.is_a?(Hash) && value.empty?
+          end
+
+          def provider_state_names
+            states = interaction["providerStates"]
+            if states.is_a?(Array) && states.any?
+              states.map { |state| state.is_a?(Hash) ? state["name"] : state }.compact
+            else
+              [interaction["providerState"] || interaction["provider_state"]].compact
+            end
+          end
+
+          def provider_state_name
+            provider_state_names.first
+          end
+
+          def apply_capitals string, start_of_sentence = false
+            start_of_sentence ? capitalize_first_letter(string) : lowercase_first_letter(string)
+          end
+
+          def capitalize_first_letter string
+            string[0].upcase + string[1..-1]
+          end
+
+          def lowercase_first_letter string
+            string[0].downcase + string[1..-1]
+          end
+
+          def markdown_escape string
+            return nil unless string
+            string.gsub(MARKDOWN_SPECIAL_CHARS_REGEXP) { |char| "\\#{char}" }
+          end
+        end
+      end
+    end
+  end
+end