pact_broker 2.107.1 → 2.108.0

data/lib/pact_broker/matrix/row_ignorer.rb

@@ -0,0 +1,36 @@
+module PactBroker
+  module Matrix
+    class RowIgnorer
+
+      class << self
+        # Splits the matrix rows into considered rows and ignored rows, based on the
+        # ignore selectors specified by the user in the can-i-deploy command (eg. --ignore SomeProviderThatIsNotReadyYet).
+        # @param [Array<MatrixRow, EveryRow>] rows
+        # @param [<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors
+        # @return [Array<MatrixRow, EveryRow>] considered_rows, [Array<MatrixRow, EveryRow>] ignored_rows
+        def split_rows_into_considered_and_ignored(rows, resolved_ignore_selectors)
+          if resolved_ignore_selectors.any?
+            considered, ignored = [], []
+            rows.each do | row |
+              if ignore_row?(resolved_ignore_selectors, row)
+                ignored << row
+              else
+                considered << row
+              end
+            end
+            return considered, ignored
+          else
+            return rows, []
+          end
+        end
+
+        def ignore_row?(resolved_ignore_selectors, row)
+          resolved_ignore_selectors.any? do | s |
+            s.pacticipant_id == row.consumer_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.consumer_version_id) ||
+              s.pacticipant_id == row.provider_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.provider_version_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/selector_ignorer.rb

@@ -0,0 +1,59 @@
+# This class determines whether or not a resolved selector (both specified and inferred)
+# that is about to be created should be marked as "ignored".
+# It uses the ignore selectors are provided in the can-i-deploy CLI command like so:
+#   can-i-deploy --pacticipant Foo --version 234243 --to-environment prod --ignore SomeProviderThatIsNotReadyYet [--version SomeOptionalVersion]
+# The ignored flag on the ResolvedSelector is used to determine whether or not a failing/missing row
+# in the can-i-deploy matrix should be ignored.
+# This allows can-i-deploy to pass successfully when a dependency is known to be not ready,
+# but the developer wants to deploy the application anyway.
+
+# The only reason why we need to resolve the ignore selectors is that we check in PactBroker::Matrix::DeploymentStatusSummary
+# whether or not the pacticipant or version they specify actually exist.
+# We could actually have performed the ignore checks just using the name and version number.
+
+module PactBroker
+  module Matrix
+    class SelectorIgnorer
+
+      # @param [Array<PactBroker::Matrix::UnresolvedSelector>] resolved_ignore_selectors
+      def initialize(resolved_ignore_selectors)
+        @resolved_ignore_selectors = resolved_ignore_selectors
+      end
+
+      # Whether the pacticipant should be ignored if the verification results are missing/failed.
+      # @param [PactBroker::Domain::Pacticipant] pacticipant
+      # @return [Boolean]
+      def ignore_pacticipant?(pacticipant)
+        resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && s.only_pacticipant_name_specified?
+        end
+      end
+
+      # Whether the pacticipant version should be ignored if the verification results are missing/failed.
+      # @param [PactBroker::Domain::Pacticipant] pacticipant
+      # @param [PactBroker::Domain::Version] version
+      # @return [Boolean]
+      def ignore_pacticipant_version?(pacticipant, version)
+        resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == version.id)
+        end
+      end
+
+      private
+
+      attr_reader :resolved_ignore_selectors
+    end
+
+    # Used when resolving the ignore selecors in the first place - the process for resolving normal selectors
+    # and ignore selectors is almost the same, but it makes no sense to ignore an ignore selector.
+    class NilSelectorIgnorer
+      def ignore_pacticipant?(*)
+        false
+      end
+
+      def ignore_pacticipant_version?(*)
+        false
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/selector_resolver.rb

@@ -0,0 +1,130 @@
+require "pact_broker/repositories"
+require "pact_broker/matrix/resolved_selector"
+require "pact_broker/matrix/resolved_selector_builder"
+require "pact_broker/matrix/selector_ignorer"
+
+
+# Take the selectors and options provided by the user (eg. [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }], { to_environment: "prod" })
+# that use pacticipant/version/branch/environment names,
+# and look up the IDs of all the objects, and return them as ResolvedSelector objects.
+# For unresolved selectors that specify a collection of versions (eg. { branch: "main" }) a ResolvedSelector
+# will be returned for every pacticipant version found. This will eventually be used in the can-i-deploy
+# logic in PactBroker::Matrix::DeploymentStatusSummary to work out if there are any missing verifications.
+
+module PactBroker
+  module Matrix
+    class SelectorResolver
+      class << self
+        include PactBroker::Repositories
+
+        # Resolve any ignore selectors used in the can-i-deploy command e.g `--ignore SomeProviderThatIsNotReadyYet`
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_ignore_selectors
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolved_ignore_selectors(unresolved_ignore_selectors)
+          # When resolving the ignore_selectors, use the NilSelectorIgnorer because it doesn't make sense to ignore
+          # the ignore selectors.
+          resolve_versions_and_add_ids(unresolved_ignore_selectors, :ignored, NilSelectorIgnorer.new)
+        end
+
+        # Resolve the selectors that were specified in the can-i-deploy command eg. `--pacticipant Foo --version 43434`
+        # There may be one or multiple.
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_specified_selectors
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors previously resolved selectors for the versions to ignore
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_specified_selectors(unresolved_specified_selectors, resolved_ignore_selectors)
+          resolve_versions_and_add_ids(unresolved_specified_selectors, :specified, SelectorIgnorer.new(resolved_ignore_selectors))
+        end
+
+        # When the can-i-deploy command uses any of the `--to` options (eg. `--to-environment ENV` or `--to TAG`)
+        # we need to create the inferred selectors for the pacticipant versions in that environment/with that tag/branch.
+        # eg. if A -> B, and the CLI command is `can-i-deploy --pacticipant A --version 3434 --to-environment prod`,
+        # then we need to make the inferred selector for pacticipant B with the version that is in prod.
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_specified_selectors
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors
+        # @param [Array<PactBroker::Matrix::Integration>] integrations
+        # @param [Hash] options
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
+          all_pacticipant_names = integrations.collect(&:pacticipant_names).flatten.uniq
+          specified_names = resolved_specified_selectors.collect{ |s| s[:pacticipant_name] }
+          inferred_pacticipant_names = all_pacticipant_names - specified_names
+          unresolved_selectors = build_unresolved_selectors_for_inferred_pacticipants(inferred_pacticipant_names, options)
+          resolve_versions_and_add_ids(unresolved_selectors, :inferred, SelectorIgnorer.new(resolved_ignore_selectors))
+        end
+
+        # Find the IDs of every pacticipant and version in the UnresolvedSelectors, and return them as ResolvedSelectors,
+        # expanding selectors for multiple versions.
+        # This gets called first for the ignore selectors, then the specified selectors, and then the inferred selectors.
+        # When it gets called for the first time for the ignore selectors, they will be passed in as the unresolved_selectors, and the resolved_ignore_selectors
+        # will be empty.
+        # The next times it is called with the specified selectors and the inferred selectors, the previously resolved ignore selectors will be passed in
+        # as resolved_ignore_selectors so we can work out which of those selectors needs to be ignored.
+        #
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_selectors
+        # @param [Symbol] selector_type which may be :specified or :inferred
+        # @param [SelectorIgnorer] selector_ignorer
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_versions_and_add_ids(unresolved_selectors, selector_type, selector_ignorer)
+          pacticipants_hash = find_pacticipants_for_selectors(unresolved_selectors)
+          unresolved_selectors.collect do | unresolved_selector |
+            build_selectors(pacticipants_hash, unresolved_selector, selector_type, selector_ignorer)
+          end.flatten
+        end
+
+        private :resolve_versions_and_add_ids
+
+        # Return a Hash of the pacticipant names used in the selectors, where the key is the name and the value is the pacticipant
+        # @return [Hash<String, PactBroker::Domain::Pacticipant>]
+        def find_pacticipants_for_selectors(unresolved_selectors)
+          names = unresolved_selectors.collect(&:pacticipant_name)
+          PactBroker::Domain::Pacticipant.where(name: names).all.group_by(&:name).transform_values(&:first)
+        end
+
+        private :find_pacticipants_for_selectors
+
+        def build_selectors(pacticipants_hash, unresolved_selector, selector_type, selector_ignorer)
+          selector_builder = ResolvedSelectorBuilder.new(unresolved_selector, selector_type, selector_ignorer)
+          selector_builder.pacticipant = pacticipants_hash[unresolved_selector.pacticipant_name]
+          if selector_builder.pacticipant
+            versions = find_versions_for_selector(unresolved_selector)
+            selector_builder.versions = versions
+          end
+          selector_builder.build
+        end
+
+        # Find the pacticipant versions for the unresolved selector.
+        # @param [PactBroker::Matrix::UnresolvedSelector] unresolved_selector
+        def find_versions_for_selector(unresolved_selector)
+          # For selectors that just set the pacticipant name, there's no need to resolve the version -
+          # only the pacticipant ID will be used in the query
+          return nil if unresolved_selector.all_for_pacticipant?
+          versions = version_repository.find_versions_for_selector(unresolved_selector)
+
+          if unresolved_selector.latest
+            [versions.first]
+          else
+            versions.empty? ? [nil] : versions
+          end
+        end
+
+        private :find_versions_for_selector
+
+        # Build an unresolved selector for the integrations that we have inferred for the target environment/branch/tag
+        # @param [Array<String>] inferred_pacticipant_names the names of the pacticipants that we have determined to be integrated with the versions for the specified selectors
+        def build_unresolved_selectors_for_inferred_pacticipants(inferred_pacticipant_names, options)
+          inferred_pacticipant_names.collect do | pacticipant_name |
+            selector = UnresolvedSelector.new(pacticipant_name: pacticipant_name)
+            selector.tag = options[:tag] if options[:tag]
+            selector.branch = options[:branch] if options[:branch]
+            selector.main_branch = options[:main_branch] if options[:main_branch]
+            selector.latest = options[:latest] if options[:latest]
+            selector.environment_name = options[:environment_name] if options[:environment_name]
+            selector
+          end
+        end
+
+        private :build_unresolved_selectors_for_inferred_pacticipants
+      end
+    end
+  end
+end

data/lib/pact_broker/metrics/service.rb

@@ -101,8 +101,8 @@ module PactBroker
       end
 
       def pact_revision_counts
-        query = "select revision_count as number_of_revisions, count(consumer_version_id) as consumer_version_count
-          from (select consumer_version_id, count(*) as revision_count from pact_publications group by consumer_version_id) foo
+        query = "select revision_count as number_of_revisions, count(*) as consumer_version_count
+          from (select count(*) as revision_count from pact_publications group by consumer_version_id, provider_id) foo
           group by revision_count
           order by 1"
         PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_revisions]] = row[:consumer_version_count] }
@@ -116,14 +116,9 @@ module PactBroker
           PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_verifications]] = row[:pact_version_count] }
       end
 
+      # This count has no real meaning and takes too long to do. Hardcode it to -1
       def matrix_count
-        begin
-          PactBroker::Matrix::EveryRow.db.with_statement_timeout(PactBroker.configuration.metrics_sql_statement_timeout) do
-            PactBroker::Matrix::EveryRow.default_scope.count
-          end
-        rescue Sequel::DatabaseError => _ex
-          -1
-        end
+        -1
       end
     end
   end

data/lib/pact_broker/pacticipants/latest_version_for_pacticipant_eager_loader.rb

@@ -0,0 +1,33 @@
+module PactBroker
+  module Pacticipants
+    class LatestVersionForPacticipantEagerLoader
+      def self.call(eo, **_other)
+        populate_associations(eo[:rows])
+      end
+
+      def self.populate_associations(pacticipants)
+        pacticipants.each { | pacticipant | pacticipant.associations[:latest_version] = nil }
+        pacticipant_ids = pacticipants.collect(&:id)
+
+        max_orders = PactBroker::Domain::Version
+                      .where(pacticipant_id: pacticipant_ids)
+                      .select_group(:pacticipant_id)
+                      .select_append { max(order).as(latest_order) }
+
+        max_orders_join = {
+          Sequel[:max_orders][:latest_order] => Sequel[:versions][:order],
+          Sequel[:max_orders][:pacticipant_id] => Sequel[:versions][:pacticipant_id]
+        }
+
+        latest_versions = PactBroker::Domain::Version
+                            .select_all_qualified
+                            .join(max_orders, max_orders_join, { table_alias: :max_orders})
+
+        latest_versions.each do | version |
+          pacticipant = pacticipants.find{ | p | p.id == version.pacticipant_id }
+          pacticipant.associations[:latest_version] = version
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/pacticipants/repository.rb

@@ -1,6 +1,4 @@
-require "sequel"
 require "pact_broker/domain/pacticipant"
-require "pact_broker/repositories/helpers"
 require "pact_broker/error"
 require "pact_broker/repositories/scopes"
 
@@ -9,11 +7,10 @@ module PactBroker
     class Repository
 
       include PactBroker::Repositories
-      include PactBroker::Repositories::Helpers
       include PactBroker::Repositories::Scopes
 
       def find_by_name name
-        pacticipants = PactBroker::Domain::Pacticipant.where(name_like(:name, name)).all
+        pacticipants = PactBroker::Domain::Pacticipant.where(Sequel.name_like(:name, name)).all
         handle_multiple_pacticipants_found(name, pacticipants) if pacticipants.size > 1
         pacticipants.first
       end
@@ -27,7 +24,7 @@ module PactBroker
       # @param [Array<String>] the array of names by which to find the pacticipants
       def find_by_names(names)
         return [] if names.empty?
-        name_likes = names.collect{ | name | name_like(:name, name) }
+        name_likes = names.collect{ | name | Sequel.name_like(:name, name) }
         scope_for(PactBroker::Domain::Pacticipant).where(Sequel.|(*name_likes)).all
       end
 
@@ -35,14 +32,15 @@ module PactBroker
         PactBroker::Domain::Pacticipant.where(id: id).single_record
       end
 
-      def find_all(pagination_options = {})
-        find({}, pagination_options)
+      def find_all(options = {}, pagination_options = {}, eager_load_associations = [])
+        find(options, pagination_options, eager_load_associations)
       end
 
-      def find(options = {}, pagination_options = {})
+      def find(options = {}, pagination_options = {}, eager_load_associations = [])
         query = scope_for(PactBroker::Domain::Pacticipant).select_all_qualified
+        query = query.filter(:name, options[:query_string]) if options[:query_string]
         query = query.label(options[:label_name]) if options[:label_name]
-        query.order_ignore_case(Sequel[:pacticipants][:name]).eager(:labels).eager(:latest_version).all_with_pagination_options(pagination_options)
+        query.order_ignore_case(Sequel[:pacticipants][:name]).eager(*eager_load_associations).all_with_pagination_options(pagination_options)
       end
 
       def find_by_name_or_create name

data/lib/pact_broker/pacticipants/service.rb

@@ -32,8 +32,8 @@ module PactBroker
           } .collect{ | name | pacticipant_repository.find_by_name(name) }
       end
 
-      def self.find_all_pacticipants(pagination_options = {})
-        pacticipant_repository.find_all(pagination_options)
+      def self.find_all_pacticipants(filter_options = {}, pagination_options = {}, eager_load_associations = [])
+        pacticipant_repository.find_all(filter_options, pagination_options, eager_load_associations)
       end
 
       def self.find_pacticipant_by_name(name)

data/lib/pact_broker/pacts/latest_pact_publication_id_for_consumer_version.rb

@@ -1,4 +1,4 @@
-require "pact_broker/repositories/helpers"
+require "pact_broker/dataset"
 
 module PactBroker
   module Pacts
@@ -7,9 +7,7 @@ module PactBroker
       unrestrict_primary_key
       plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
 
-      dataset_module do
-        include PactBroker::Repositories::Helpers
-      end
+      dataset_module PactBroker::Dataset
     end
   end
 end

data/lib/pact_broker/pacts/metadata.rb

@@ -12,6 +12,7 @@ module PactBroker
         [:consumer_version_selectors, "s"],
         [:tag, "t"],
         [:branch, "b"],
+        [:environment, "e"],
         [:latest, "l"]
       ]
 
@@ -45,6 +46,7 @@ module PactBroker
       # parameters. This is part of ensuring that verification results webhooks
       # go back to the correct consumer version number (eg for git statuses)
       def build_metadata_for_webhook_triggered_by_pact_publication(pact)
+        # Should probably put the branch in here, but I don't think the tags are used for anything
         metadata = {
           "cvn" => pact.consumer_version_number,
           "cvt" => pact.consumer_version_tag_names
@@ -60,13 +62,13 @@ module PactBroker
             "w" => true
           }
         else
-          # TODO support deployed and released
           {
             "s" => verifiable_pact.selectors.collect do | selector |
               {
                 "b" => selector.branch,
                 "t" => selector.tag,
                 "l" => selector.latest,
+                "e" => selector.environment_name,
                 "cv" => selector.consumer_version.id
               }.compact
             end,

data/lib/pact_broker/pacts/pact_publication.rb

@@ -1,7 +1,7 @@
 require "forwardable"
+require "pact_broker/dataset"
 require "pact_broker/domain/pact"
 require "pact_broker/pacts/pact_version"
-require "pact_broker/repositories/helpers"
 require "pact_broker/integrations/integration"
 require "pact_broker/tags/head_pact_tags"
 require "pact_broker/pacts/pact_publication_dataset_module"
@@ -52,16 +52,22 @@ module PactBroker
       plugin :timestamps, update_on_create: true
 
       dataset_module do
-        include PactBroker::Repositories::Helpers
+        include PactBroker::Dataset
         include PactPublicationDatasetModule
         include PactPublicationCleanSelectorDatasetModule
         include PactPublicationWipDatasetModule
 
         def eager_for_domain_with_content
-          eager(:tags, :consumer, :provider, :consumer_version, :pact_version)
+          eager(:tags, :consumer, :provider, :pact_version, { consumer_version: :branch_versions })
         end
       end
 
+      def with_version_branches_and_tags
+        consumer_version.tags
+        consumer_version.branch_versions
+        self
+      end
+
       def self.subtract(a, *b)
         b_ids = b.flat_map{ |pact_publications| pact_publications.collect(&:id) }
         a.reject{ |pact_publication| b_ids.include?(pact_publication.id) }
@@ -125,8 +131,9 @@ module PactBroker
         @latest_for_branch
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def to_domain
-        PactBroker::Domain::Pact.new(
+        attributes = {
           id: id,
           provider: provider,
           consumer: consumer,
@@ -139,8 +146,19 @@ module PactBroker
           created_at: created_at,
           head_tag_names: [],
           db_model: self
-        )
+        }
+
+        if associations[:tags] || consumer_version.associations[:tags]
+          attributes[:consumer_version_tag_names] = associations[:tags]&.collect(&:name) || consumer_version.associations[:tags]&.collect(&:name)
+        end
+
+        if consumer_version.associations[:branch_versions]
+          attributes[:consumer_version_branch_names] = consumer_version.branch_versions.collect(&:branch_name)
+        end
+
+        PactBroker::Domain::Pact.new(attributes)
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def to_domain_lightweight
         PactBroker::Domain::Pact.new(

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -132,10 +132,14 @@ module PactBroker
           .remove_overridden_revisions_from_complete_query
       end
 
+      # The pact that belongs to the branch head.
+      # May return nil if the branch head does not have a pact published for it.
       def latest_for_consumer_branch(branch_name)
         for_branch_heads(branch_name)
       end
 
+      # The latest pact that belongs to a version on the specified branch (might not be the version that is the branch head)
+      # Always returns a pact, if any pacts exist for this branch.
       def old_latest_for_consumer_branch(branch_name)
         branch_versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_versions][:version_id]
@@ -148,7 +152,7 @@ module PactBroker
 
         max_orders = join(:branch_versions, branch_versions_join)
                       .join(:branches, branches_join)
-                      .select_group(:consumer_id, :provider_id, Sequel[:branches][:name].as(:branch_name))
+                      .select_group(Sequel[:pact_publications][:consumer_id], Sequel[:pact_publications][:provider_id], Sequel[:branches][:name].as(:branch_name))
                       .select_append{ max(consumer_version_order).as(latest_consumer_version_order) }
 
         max_join = {

data/lib/pact_broker/pacts/pact_version.rb

@@ -1,5 +1,4 @@
-require "sequel"
-require "pact_broker/repositories/helpers"
+require "pact_broker/dataset"
 require "pact_broker/pacts/content"
 require "pact_broker/pacts/pact_version_association_loaders"
 
@@ -52,7 +51,7 @@ module PactBroker
       )
 
       dataset_module do
-        include PactBroker::Repositories::Helpers
+        include PactBroker::Dataset
 
         def for_pact_domain(pact_domain)
           where(

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -1,9 +1,7 @@
-require "sequel"
 require "pact_broker/logging"
 require "pact_broker/pacts/pact_publication"
 require "pact_broker/domain"
 require "pact_broker/pacts/verifiable_pact"
-require "pact_broker/repositories/helpers"
 require "pact_broker/pacts/selected_pact"
 require "pact_broker/pacts/selector"
 require "pact_broker/pacts/selectors"
@@ -17,7 +15,6 @@ module PactBroker
       include PactBroker::Logging
       include PactBroker::Repositories
       include PactBroker::Services
-      include PactBroker::Repositories::Helpers
       include PactBroker::Repositories::Scopes
 
       PUBLICATION_ASSOCIATIONS_FOR_EAGER_LOAD = [
@@ -221,9 +218,9 @@ module PactBroker
 
       def create_selectors_for_wip_pact(pact_publication)
         if pact_publication.values[:tag_name]
-          Selectors.create_for_latest_for_tag(pact_publication.values[:tag_name])
+          Selectors.create_for_latest_for_tag(pact_publication.values[:tag_name]).resolve(pact_publication.consumer_version)
         else
-          Selectors.create_for_latest_for_branch(pact_publication.values.fetch(:branch_name))
+          Selectors.create_for_latest_for_branch(pact_publication.values.fetch(:branch_name)).resolve(pact_publication.consumer_version)
         end
       end
 

data/lib/pact_broker/pacts/placeholder_pact.rb

@@ -6,11 +6,13 @@ module PactBroker
       def initialize
         consumer = OpenStruct.new(name: "placeholder-consumer", labels: [OpenStruct.new(name: "placeholder-consumer-label")])
         @provider = OpenStruct.new(name: "placeholder-provider", labels: [OpenStruct.new(name: "placeholder-provider-label")])
-        @consumer_version = OpenStruct.new(number: "gggghhhhjjjjkkkkllll66667777888899990000", pacticipant: consumer, tags: [OpenStruct.new(name: "master")])
+        @consumer_version = OpenStruct.new(number: "gggghhhhjjjjkkkkllll66667777888899990000", pacticipant: consumer)
         @consumer_version_number = @consumer_version.number
         @created_at = DateTime.now
         @revision_number = 1
         @pact_version_sha = "5d445a4612743728dfd99ccd4210423c052bb9db"
+        @consumer_version_tag_names = ["dev"]
+        @consumer_version_branch_names = ["main"]
       end
     end
   end

data/lib/pact_broker/pacts/repository.rb

@@ -1,4 +1,3 @@
-require "sequel"
 require "ostruct"
 require "pact_broker/logging"
 require "pact_broker/pacts/generate_sha"
@@ -9,7 +8,6 @@ require "pact_broker/domain"
 require "pact_broker/pacts/parse"
 require "pact_broker/pacts/latest_pact_publication_id_for_consumer_version"
 require "pact_broker/pacts/verifiable_pact"
-require "pact_broker/repositories/helpers"
 require "pact_broker/pacts/selected_pact"
 require "pact_broker/pacts/selector"
 require "pact_broker/pacts/selectors"
@@ -24,7 +22,6 @@ module PactBroker
     class Repository
       include PactBroker::Logging
       include PactBroker::Repositories
-      include PactBroker::Repositories::Helpers
 
       def scope_for(scope)
         PactBroker.policy_scope!(scope)
@@ -53,7 +50,7 @@ module PactBroker
           consumer_version_order: params.fetch(:version).order,
         ).upsert
         update_latest_pact_publication_ids(pact_publication)
-        pact_publication.to_domain
+        pact_publication.with_version_branches_and_tags.to_domain
       end
 
       def update id, params
@@ -75,9 +72,9 @@ module PactBroker
             created_at: Sequel.datetime_class.now
           ).upsert
           update_latest_pact_publication_ids(pact_publication)
-          pact_publication.to_domain
+          pact_publication.with_version_branches_and_tags.to_domain
         else
-          existing_model.to_domain
+          existing_model.with_version_branches_and_tags.to_domain
         end
       end
 
@@ -201,7 +198,7 @@ module PactBroker
           .sort
       end
 
-      def find_latest_pact(consumer_name, provider_name, tag = nil)
+      def find_latest_pact(consumer_name, provider_name, tag = nil, branch_name = nil)
         query = scope_for(PactPublication)
           .eager_for_domain_with_content
           .select_all_qualified
@@ -212,6 +209,8 @@ module PactBroker
           query = query.untagged
         elsif tag
           query = query.for_consumer_version_tag_all_revisions(tag)
+        elsif branch_name
+          query = query.old_latest_for_consumer_branch(branch_name)
         end
         query.latest_by_consumer_version_order.all.collect(&:to_domain_with_content)[0]
       end
@@ -253,23 +252,24 @@ module PactBroker
             .reverse_order(:consumer_version_order, :revision_number)
             .limit(1)
 
+        # Must use .all to trigger the eager loading
         if consumer_version_number && !pact_version_sha
           pact_publication_by_consumer_version
-            .first&.to_domain_with_content
+            .all.first&.to_domain_with_content
         elsif pact_version_sha && !consumer_version_number
           latest_pact_publication_by_sha
-            .first&.to_domain_with_content
+            .all.first&.to_domain_with_content
         elsif consumer_version_number && pact_version_sha
-          pact_publication = pact_publication_by_consumer_version.first
+          pact_publication = pact_publication_by_consumer_version.all.first
           if pact_publication && pact_publication.pact_version.sha == pact_version_sha
             pact_publication.to_domain_with_content
           else
-            latest_pact_publication_by_sha.first&.to_domain_with_content
+            latest_pact_publication_by_sha.all.first&.to_domain_with_content
           end
         else
           pact_publication_by_consumer_version
             .reverse_order(:consumer_version_order, :revision_number)
-            .first&.to_domain_with_content
+            .all.first&.to_domain_with_content
         end
       end
       # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength

data/lib/pact_broker/pacts/service.rb

@@ -23,7 +23,7 @@ module PactBroker
       extend SquashPactsForVerification
 
       def find_latest_pact params
-        pact_repository.find_latest_pact(params[:consumer_name], params[:provider_name], params[:tag])
+        pact_repository.find_latest_pact(params[:consumer_name], params[:provider_name], params[:tag], params[:branch_name])
       end
 
       def search_for_latest_pact params