pact_broker 2.95.0 → 2.97.0

data/lib/pact_broker/config/runtime_configuration_database_methods.rb

@@ -31,6 +31,11 @@ module PactBroker
             database_connection_validation_timeout: nil
           )
 
+          coerce_types(
+            database_username: :string,
+            database_password: :string
+          )
+
           def database_configuration
             database_credentials
               .merge(
@@ -77,7 +82,7 @@ module PactBroker
           private :postgres?
 
           def driver_options
-            if postgres?
+            if postgres? && database_statement_timeout
               { options: "-c statement_timeout=#{database_statement_timeout}s" }
             end
           end

data/lib/pact_broker/config/runtime_configuration_logging_methods.rb

@@ -1,8 +1,11 @@
 require "uri"
+require "pact_broker/hash_refinements"
 
 module PactBroker
   module Config
     module RuntimeConfigurationLoggingMethods
+      using PactBroker::HashRefinements
+
       module ClassMethods
         def sensitive_values(*values)
           @sensitive_values ||= []
@@ -19,17 +22,25 @@ module PactBroker
       end
 
       module InstanceMethods
+        # base_url raises a not implemented error
         def log_configuration(logger)
-          to_source_trace.sort_by { |key, _| key }.each { |key, value| log_config_inner(key, value, logger) }
+          source_info = to_source_trace
+          (self.class.config_attributes - [:base_url]).collect(&:to_s).each_with_object({})do | key, new_hash |
+            new_hash[key] = {
+              value: self.send(key.to_sym),
+              source: source_info.dig(key, :source) || {:type=>:defaults}
+            }
+          end.sort_by { |key, _| key }.each { |key, value| log_config_inner(key, value, logger) }
         end
 
         def log_config_inner(key, value, logger)
+          # TODO fix the source display for webhook_certificates set by environment variables
           if !value.has_key? :value
             value.sort_by { |inner_key, _| inner_key }.each { |inner_key, inner_value| log_config_inner("#{key}.#{inner_key}", inner_value, logger) }
           elsif self.class.sensitive_value?(key)
             logger.info "#{key}=#{redact(key, value[:value])} source=#{value[:source]}"
           else
-            logger.info "#{key}=#{value[:value]} source=#{value[:source]}"
+            logger.info "#{key}=#{value[:value].inspect} source=#{value[:source]}"
           end
         end
         private :log_config_inner

data/lib/pact_broker/configuration.rb

@@ -15,10 +15,6 @@ module PactBroker
     RequestStore.store[:pact_broker_configuration] = configuration
   end
 
-  def self.with_runtime_configuration_overrides(overrides, &block)
-    self.configuration.with_runtime_configuration_overrides(overrides, &block)
-  end
-
   # @private, for testing only
   def self.reset_configuration
     RequestStore.store[:pact_broker_configuration] = Configuration.default_configuration
@@ -35,7 +31,7 @@ module PactBroker
     attr_accessor :content_security_policy, :hal_browser_content_security_policy_overrides
     attr_accessor :api_error_reporters
     attr_reader :custom_logger
-    attr_accessor :policy_builder, :policy_scope_builder, :base_resource_class_factory
+    attr_accessor :policy_builder, :policy_scope_builder
     alias_method :policy_finder=, :policy_builder=
     alias_method :policy_scope_finder=, :policy_scope_builder=
 
@@ -59,6 +55,8 @@ module PactBroker
       config.version_parser = PactBroker::Versions::ParseSemanticVersion
       config.sha_generator = PactBroker::Pacts::GenerateSha
       config.example_data_seeder = lambda do
+        # Do the require in the lambda, not at the top of the file, because we need
+        # the database connection to be made before loading any Sequel::Model classes.
         require "pact_broker/db/seed_example_data"
         PactBroker::DB::SeedExampleData.call
       end
@@ -79,21 +77,9 @@ module PactBroker
       }
       config.policy_builder = -> (object) { DefaultPolicy.new(nil, object) }
       config.policy_scope_builder = -> (scope) { scope }
-      config.base_resource_class_factory = -> () {
-        require "pact_broker/api/resources/default_base_resource"
-        PactBroker::Api::Resources::DefaultBaseResource
-      }
       config
     end
 
-    def with_runtime_configuration_overrides(overrides)
-      original_runtime_configuration = runtime_configuration
-      self.runtime_configuration = override_runtime_configuration!(overrides)
-      yield
-    ensure
-      self.runtime_configuration = original_runtime_configuration
-    end
-
     def override_runtime_configuration!(overrides)
       new_runtime_configuration = runtime_configuration.dup
       valid_overrides = {}

data/lib/pact_broker/db/models.rb

@@ -14,11 +14,11 @@ require "pact_broker/domain/pacticipant"
 require "pact_broker/deployments/environment"
 require "pact_broker/deployments/deployed_version"
 require "pact_broker/deployments/released_version"
-require "pact_broker/matrix/row"
-require "pact_broker/matrix/head_row"
 require "pact_broker/versions/branch"
 require "pact_broker/versions/branch_version"
 require "pact_broker/versions/branch_head"
+require "pact_broker/matrix/quick_row"
+require "pact_broker/matrix/every_row"
 
 module PactBroker
   INTEGRATIONS_TABLES = [

data/lib/pact_broker/index/service.rb

@@ -1,10 +1,9 @@
 require "pact_broker/repositories"
 require "pact_broker/logging"
 require "pact_broker/domain/index_item"
-require "pact_broker/matrix/head_row"
-require "pact_broker/matrix/aggregated_row"
 require "pact_broker/repositories/helpers"
 require "pact_broker/index/page"
+require "pact_broker/verifications/latest_verification_for_consumer_version_tag"
 
 module PactBroker
   module Index

data/lib/pact_broker/integrations/integration.rb

@@ -3,6 +3,7 @@ require "pact_broker/verifications/pseudo_branch_status"
 require "pact_broker/domain/verification"
 require "pact_broker/webhooks/latest_triggered_webhook"
 require "pact_broker/webhooks/webhook"
+require "pact_broker/verifications/latest_verification_for_consumer_and_provider"
 
 module PactBroker
   module Integrations
@@ -21,17 +22,30 @@ module PactBroker
           integration.associations[:latest_pact] = nil
         end
 
-        PactBroker::Pacts::PactPublication.overall_latest.each do | pact |
-          eo_opts[:rows].each do | integration |
-            if integration.consumer_id == pact.consumer_id && integration.provider_id == pact.provider_id
-              integration.associations[:latest_pact] = pact
-            end
+
+        # Would prefer to be able to eager load only the fields specified in the original Integrations
+        # query, but we don't seem to have that information in this context.
+        # Need the latest verification for the verification status in the index response.
+        latest_pact_publications_query = PactBroker::Pacts::PactPublication
+                                          .eager_for_domain_with_content
+                                          .eager(pact_version: :latest_verification)
+                                          .overall_latest
+
+        latest_pact_publications_query.all.each do | pact |
+          eo_opts[:id_map][[pact.consumer_id, pact.provider_id]]&.each do | integration |
+            integration.associations[:latest_pact] = pact
           end
         end
       end
 
       one_to_one(:latest_pact, class: "PactBroker::Pacts::PactPublication", :key => [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id], :eager_loader=> LATEST_PACT_EAGER_LOADER) do | _ds |
-        PactBroker::Pacts::PactPublication.overall_latest_for_consumer_id_and_provider_id(consumer_id, provider_id)
+        # Would prefer to be able to eager load only the fields specified in the original Integrations
+        # query, but we don't seem to have that information in this context.
+        # Need the latest verification for the verification status in the index response.
+        PactBroker::Pacts::PactPublication
+          .eager_for_domain_with_content
+          .eager(pact_version: :latest_verification)
+          .overall_latest_for_consumer_id_and_provider_id(consumer_id, provider_id)
       end
 
       # When viewing the index, every webhook in the database will match at least one of the rows, so
@@ -65,6 +79,7 @@ module PactBroker
         end
       end
 
+      # TODO make this the verification status for the latest from main branch
       def verification_status_for_latest_pact
         @verification_status_for_latest_pact ||= PactBroker::Verifications::PseudoBranchStatus.new(latest_pact, latest_pact&.latest_verification)
       end

data/lib/pact_broker/integrations/service.rb

@@ -26,7 +26,7 @@ module PactBroker
         scope_for(PactBroker::Integrations::Integration)
           .eager(:consumer)
           .eager(:provider)
-          .eager(latest_pact: [:latest_verification, :pact_version])
+          .eager(:latest_pact) # latest_pact eager loader is custom, can't take any more options
           .eager(:latest_verification)
           .all
           .sort { | a, b| Integration.compare_by_last_action_date(a, b) }

data/lib/pact_broker/matrix/repository.rb

@@ -1,9 +1,7 @@
 require "pact_broker/logging"
 require "pact_broker/repositories/helpers"
-require "pact_broker/matrix/row"
 require "pact_broker/matrix/quick_row"
 require "pact_broker/matrix/every_row"
-require "pact_broker/matrix/head_row"
 require "pact_broker/error"
 require "pact_broker/matrix/query_results"
 require "pact_broker/matrix/integration"
@@ -24,7 +22,8 @@ module PactBroker
 
       # TODO move latest verification logic in to database
 
-      TP_COLS = PactBroker::Matrix::Row::TP_COLS
+      # Used when using table_print to output query results
+      TP_COLS = [ :consumer_version_number, :pact_revision_number, :provider_version_number, :verification_number]
 
       GROUP_BY_PROVIDER_VERSION_NUMBER = [:consumer_name, :consumer_version_number, :provider_name, :provider_version_number]
       GROUP_BY_PROVIDER = [:consumer_name, :consumer_version_number, :provider_name]
@@ -84,7 +83,7 @@ module PactBroker
 
       def find_integrations_for_specified_selectors(resolved_specified_selectors, options)
         if infer_selectors_for_integrations?(options)
-          find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors, options)
+          find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors)
         else
           find_integrations_for_specified_selectors_only(resolved_specified_selectors)
         end
@@ -101,9 +100,9 @@ module PactBroker
           end
       end
 
-      def find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors, options)
+      def find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors)
         integrations = integrations_where_specified_selector_is_consumer(resolved_specified_selectors) +
-                        integrations_where_specified_selector_is_provider(resolved_specified_selectors, options)
+                        integrations_where_specified_selector_is_provider(resolved_specified_selectors)
         deduplicate_integrations(integrations)
       end
 
@@ -118,28 +117,25 @@ module PactBroker
                 consumer_name: integration[:consumer_name],
                 provider_id: integration[:provider_id],
                 provider_name: integration[:provider_name],
-                required: true
+                required: true # synchronous consumer requires the provider to be present
               )
             end
         end
       end
 
-      def integrations_where_specified_selector_is_provider(resolved_specified_selectors, options)
+      def integrations_where_specified_selector_is_provider(resolved_specified_selectors)
         integrations_involving_specified_providers = PactBroker::Integrations::Integration
                                                       .where(provider_id: resolved_specified_selectors.collect(&:pacticipant_id))
                                                       .eager(:consumer, :provider)
                                                       .all
 
-        destination_selector = PactBroker::Matrix::UnresolvedSelector.new(options.slice(:latest, :tag, :branch, :environment_name).compact)
-        required = PactBroker::Domain::Version.for_selector(destination_selector).pacticipants_set
-
         integrations_involving_specified_providers.collect do | integration |
           Integration.from_hash(
             consumer_id: integration.consumer.id,
             consumer_name: integration.consumer.name,
             provider_id: integration.provider.id,
             provider_name: integration.provider.name,
-            required: required.member?(integration.consumer.id)
+            required: false # synchronous provider does not require the consumer to be present
           )
         end
       end
@@ -263,6 +259,9 @@ module PactBroker
         end
       end
 
+      # The user has specified --to TAG or --to-environment ENVIRONMENT in the CLI
+      # (or nothing, which to defaults to "with the latest version of the other integrated applications")
+      # The branch isn't implemented in the CLI yet (March 2022), but the API supports it.
       def infer_selectors_for_integrations?(options)
         options[:latest] || options[:tag] || options[:branch] || options[:environment_name]
       end

data/lib/pact_broker/matrix/service.rb

@@ -1,6 +1,5 @@
 require "pact_broker/logging"
 require "pact_broker/repositories"
-require "pact_broker/matrix/row"
 require "pact_broker/matrix/deployment_status_summary"
 require "pact_broker/matrix/query_results_with_deployment_status_summary"
 require "pact_broker/messages"

data/lib/pact_broker/metrics/service.rb

@@ -118,8 +118,8 @@ module PactBroker
 
       def matrix_count
         begin
-          PactBroker::Matrix::Row.db.with_statement_timeout(PactBroker.configuration.metrics_sql_statement_timeout) do
-            PactBroker::Matrix::Row.count
+          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

data/lib/pact_broker/pacts/lazy_loaders.rb

@@ -9,6 +9,32 @@ module PactBroker
             .latest_for_consumer_tag(consumer_version_tag_names)
             .from_self.order_by(:tag_name)
       }
+
+      LATEST_VERIFICATION_FOR_CONSUMER_BRANCHES = lambda {
+        bv_pp_join = {
+          Sequel[:branch_versions][:version_id] => Sequel[:pact_publications][:consumer_version_id],
+          Sequel[:pact_publications][:provider_id] => provider_id
+        }
+
+        verifications_join = {
+          Sequel[:verifications][:pact_version_id] => Sequel[:pact_publications][:pact_version_id]
+        }
+
+        branch_ids = PactBroker::Versions::BranchVersion
+          .select(:branch_id)
+          .where(version_id: consumer_version_id)
+
+
+        latest_verification_id = PactBroker::Versions::BranchVersion
+          .select(Sequel[:verifications][:id])
+          .where(Sequel[:branch_versions][:branch_id] => branch_ids)
+          .join(:pact_publications, bv_pp_join)
+          .join(:verifications, verifications_join)
+          .order(Sequel.desc(Sequel[:verifications][:id]))
+          .limit(1)
+
+        PactBroker::Domain::Verification.where(id: latest_verification_id)
+      }
     end
   end
 end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -24,8 +24,7 @@ module PactBroker
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
       associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
       associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
-      associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
-
+      associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id], read_only: true, forbid_lazy_load: false)
       # TODO rename to consumer_version_tags
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :key => :version_id, :primary_key => :consumer_version_id)
 
@@ -34,43 +33,19 @@ module PactBroker
         read_only: true,
         key: :id,
         primary_key: :id,
-        dataset: lambda {
-
-          bv_pp_join = {
-            Sequel[:branch_versions][:version_id] => Sequel[:pact_publications][:consumer_version_id],
-            Sequel[:pact_publications][:provider_id] => provider_id
-          }
-
-          verifications_join = {
-            Sequel[:verifications][:pact_version_id] => Sequel[:pact_publications][:pact_version_id]
-          }
-
-          branch_ids = PactBroker::Versions::BranchVersion
-            .select(:branch_id)
-            .where(version_id: consumer_version_id)
-
-
-          latest_verification_id = PactBroker::Versions::BranchVersion
-            .select(Sequel[:verifications][:id])
-            .where(Sequel[:branch_versions][:branch_id] => branch_ids)
-            .join(:pact_publications, bv_pp_join)
-            .join(:verifications, verifications_join)
-            .order(Sequel.desc(Sequel[:verifications][:id]))
-            .limit(1)
-
-          PactBroker::Domain::Verification.where(id: latest_verification_id)
-        },
+        forbid_lazy_load: false,
+        dataset: PactBroker::Pacts::LazyLoaders::LATEST_VERIFICATION_FOR_CONSUMER_BRANCHES,
         eager_loader: proc do | _ |
           raise NotImplementedError
         end
       )
 
-
       one_to_many(:head_pact_publications_for_tags,
         class: PactPublication,
         read_only: true,
         dataset: PactBroker::Pacts::LazyLoaders::HEAD_PACT_PUBLICATIONS_FOR_TAGS,
-        eager_loader: PactBroker::Pacts::EagerLoaders::HeadPactPublicationsForTags
+        eager_loader: PactBroker::Pacts::EagerLoaders::HeadPactPublicationsForTags,
+        forbid_lazy_load: false
       )
 
       plugin :upsert, identifying_columns: [:consumer_version_id, :provider_id, :revision_number]
@@ -81,6 +56,10 @@ module PactBroker
         include PactPublicationDatasetModule
         include PactPublicationCleanSelectorDatasetModule
         include PactPublicationWipDatasetModule
+
+        def eager_for_domain_with_content
+          eager(:tags, :consumer, :provider, :consumer_version, :pact_version)
+        end
       end
 
       def self.subtract(a, *b)
@@ -105,8 +84,14 @@ module PactBroker
           .collect { | head_pact_publication| head_pact_publication.values.fetch(:tag_name) }
       end
 
+      # If the consumer_version is already loaded, and it already has tags, use those
+      # otherwise, load them directly.
       def consumer_version_tags
-        tags
+        if associations[:consumer_version] && associations[:consumer_version].associations[:tags]
+          consumer_version.tags
+        else
+          tags
+        end
       end
 
       def latest_verification

data/lib/pact_broker/pacts/pact_version.rb

@@ -1,39 +1,32 @@
 require "sequel"
 require "pact_broker/repositories/helpers"
-require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
 require "pact_broker/pacts/content"
+require "pact_broker/pacts/pact_version_association_loaders"
 
 module PactBroker
   module Pacts
     class PactVersion < Sequel::Model(:pact_versions)
+      include PactVersionAssociationLoaders
+
       plugin :timestamps
       plugin :upsert, identifying_columns: [:consumer_id, :provider_id, :sha]
 
-      one_to_many :pact_publications, reciprocal: :pact_version
-      one_to_many :verifications, reciprocal: :verification, order: :id, class: "PactBroker::Domain::Verification"
-      associate(:many_to_one, :provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
-      associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
-      associate(:many_to_many, :consumer_versions, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id, order: :order)
+      one_to_many(:pact_publications, reciprocal: :pact_version)
+      one_to_many(:verifications, reciprocal: :verification, order: :id, class: "PactBroker::Domain::Verification")
+      many_to_one(:provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
+      many_to_one(:consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
+      many_to_many(:consumer_versions,
+        class: "PactBroker::Domain::Version",
+        join_table: :pact_publications,
+        left_key: :pact_version_id,
+        right_key: :consumer_version_id,
+        order: :order
+      )
 
       one_to_one(:latest_main_branch_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,
-        dataset: lambda {
-          providers_join = {
-            Sequel[:providers][:id] => Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_id]
-          }
-
-          branch_versions_join = {
-            Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_version_id] => Sequel[:branch_versions][:version_id],
-            Sequel[:providers][:main_branch] => Sequel[:branch_versions][:branch_name]
-          }
-          max_verification_id_for_pact_version =  PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion
-                                                    .join(:pacticipants, providers_join, { table_alias: :providers })
-                                                    .join(:branch_versions, branch_versions_join)
-                                                    .select(Sequel.function(:max, :verification_id))
-                                                    .where(pact_version_id: id)
-          PactBroker::Domain::Verification.where(id: max_verification_id_for_pact_version)
-        },
+        dataset: LATEST_MAIN_BRANCH_VERIFICATION,
         key: :pact_version_id,
         primary_key: :id,
         eager_block: lambda { | ds | ds.from_provider_main_branch.latest_by_pact_version }
@@ -42,15 +35,18 @@ module PactBroker
       one_to_one(:latest_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,
-        dataset: lambda { PactBroker::Domain::Verification.where(id: PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion.select(Sequel.function(:max, :verification_id)).where(pact_version_id: id)) },
+        dataset: LATEST_VERIFICATION_DATASET,
         key: :pact_version_id, primary_key: :id,
         eager_block: lambda { | ds | ds.latest_by_pact_version }
       )
 
       # do not eager load this - it won't work because of the limit(1)
-      one_through_one(:latest_consumer_version, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id) do | ds |
-        ds.unlimited.order(Sequel.desc(:order)).limit(1)
-      end
+      one_through_one(:latest_consumer_version,
+        class: "PactBroker::Domain::Version",
+        join_table: :pact_publications,
+        left_key: :pact_version_id,
+        right_key: :consumer_version_id, &LATEST_CONSUMER_VERSION_LAZY_LOADER
+      )
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -89,11 +85,11 @@ module PactBroker
       end
 
       def provider_name
-        pact_publications.last.provider.name
+        provider.name
       end
 
       def consumer_name
-        pact_publications.last.consumer.name
+        consumer.name
       end
 
       def latest_pact_publication

data/lib/pact_broker/pacts/pact_version_association_loaders.rb

@@ -0,0 +1,36 @@
+require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
+
+module PactBroker
+  module Pacts
+    module PactVersionAssociationLoaders
+
+      LATEST_MAIN_BRANCH_VERIFICATION = lambda {
+        providers_join = {
+          Sequel[:providers][:id] => Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_id]
+        }
+
+        branch_versions_join = {
+          Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_version_id] => Sequel[:branch_versions][:version_id],
+          Sequel[:providers][:main_branch] => Sequel[:branch_versions][:branch_name]
+        }
+        max_verification_id_for_pact_version =  PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion
+                                                  .join(:pacticipants, providers_join, { table_alias: :providers })
+                                                  .join(:branch_versions, branch_versions_join)
+                                                  .select(Sequel.function(:max, :verification_id))
+                                                  .where(pact_version_id: id)
+        PactBroker::Domain::Verification.where(id: max_verification_id_for_pact_version)
+      }
+
+      LATEST_VERIFICATION_DATASET = lambda {
+        PactBroker::Domain::Verification
+          .where(
+            id: PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion.select(
+              Sequel.function(:max, :verification_id)
+            ).where(pact_version_id: id)
+          )
+      }
+
+      LATEST_CONSUMER_VERSION_LAZY_LOADER = lambda { | ds | ds.unlimited.order(Sequel.desc(:order)).limit(1) }
+    end
+  end
+end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -23,7 +23,7 @@ module PactBroker
         :provider,
         :consumer,
         :consumer_version,
-        pact_version: :latest_verification
+        :pact_version
       ]
 
       def find(provider_name, consumer_version_selectors)
@@ -162,16 +162,14 @@ module PactBroker
 
       def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
         selectors.collect do | selector |
-          query = scope_for(PactPublication).for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
+          query = scope_for(PactPublication).eager_for_domain_with_content.for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
           query = query.for_consumer_name(selector.consumer) if selector.consumer
-          query.all
-            .collect do | latest_tagged_pact_publication |
-              pact_publication = unscoped(PactPublication).find(id: latest_tagged_pact_publication.id)
-              SelectedPact.new(
-                pact_publication.to_domain,
-                Selectors.new(selector.resolve_for_fallback(pact_publication.consumer_version))
-              )
-            end
+          query.all.collect do | pact_publication |
+            SelectedPact.new(
+              pact_publication.to_domain,
+              Selectors.new(selector.resolve_for_fallback(pact_publication.consumer_version))
+            )
+          end
         end.flatten
       end
 
@@ -299,7 +297,13 @@ module PactBroker
       end
 
       def collect_consumer_name_and_version_number(pact_publications_query)
-        pact_publications_query.eager(:provider).eager(:consumer).eager(:consumer_version).order(:consumer_version_order).all.sort.collect do |p|
+        pact_publications = pact_publications_query
+                              .eager(:consumer, :consumer_version)
+                              .order(:consumer_version_order)
+                              .all_forbidding_lazy_load
+                              .sort
+
+        pact_publications.collect do |p|
           suffix =  if p.values[:tag_name]
                       " (tag #{p.values[:tag_name]})"
                     elsif p.values[:branch_name]
@@ -308,7 +312,7 @@ module PactBroker
                       ""
                     end
 
-          "#{p.consumer_name} #{p.consumer_version_number}" + suffix
+          "#{p.consumer.name} #{p.consumer_version.number}" + suffix
         end
       end