pact_broker 2.95.1 → 2.98.0

data/lib/pact_broker/api/middleware/http_debug_logs.rb

@@ -0,0 +1,36 @@
+require "pact_broker/logging"
+
+module PactBroker
+  module Api
+    module Middleware
+      class HttpDebugLogs
+        include PactBroker::Logging
+
+        EXCLUDE_HEADERS = ["puma.", "rack.", "pactbroker."]
+        RACK_SESSION = "rack.session"
+
+        def initialize(app)
+          @app = app
+          @logger = logger
+        end
+
+        def call(env)
+          env_to_log = env.reject { | header, _ | header.start_with?(*EXCLUDE_HEADERS) }
+          env_to_log["rack.session"] = env["rack.session"].to_hash if env["rack.session"]
+          env_to_log["rack.input"] = request_body(env) if env["rack.input"]
+          logger.debug("env", payload: env_to_log)
+          status, headers, body = @app.call(env)
+          logger.debug("response", payload: { "status" => status, "headers" => headers, "body" => body })
+          [status, headers, body]
+        end
+
+        def request_body(env)
+          buffer = env["rack.input"]
+          request_body = buffer.read
+          buffer.respond_to?(:rewind) && buffer.rewind
+          JSON.parse(request_body) rescue request_body
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/app.rb

@@ -29,6 +29,7 @@ require "pact_broker/api/middleware/configuration"
 require "pact_broker/api/middleware/basic_auth"
 require "pact_broker/config/basic_auth_configuration"
 require "pact_broker/api/authorization/resource_access_policy"
+require "pact_broker/api/middleware/http_debug_logs"
 
 module PactBroker
 
@@ -134,17 +135,11 @@ module PactBroker
       # Keep this configuration in sync with lib/db.rb
       configuration.database_connection ||= PactBroker.create_database_connection(configuration.database_configuration, configuration.logger)
       PactBroker::DB.connection = configuration.database_connection
-      PactBroker::DB.connection.extend_datasets do
-        # rubocop: disable Lint/NestedMethodDefinition
-        def any?
-          !empty?
-        end
-        # rubocop: enable Lint/NestedMethodDefinition
-      end
       PactBroker::DB.validate_connection_config if configuration.validate_database_connection_config
       PactBroker::DB.set_mysql_strict_mode_if_mysql
       PactBroker::DB.connection.extension(:pagination)
       PactBroker::DB.connection.extension(:statement_timeout)
+      PactBroker::DB.connection.extension(:any_not_empty)
       PactBroker::DB.connection.timezone = :utc
       Sequel.datetime_class = DateTime
       Sequel.database_timezone = :utc # Store all dates in UTC, assume any date without a TZ is UTC
@@ -180,6 +175,7 @@ module PactBroker
     end
 
     def configure_middleware
+      @app_builder.use PactBroker::Api::Middleware::HttpDebugLogs if configuration.http_debug_logging_enabled
       configure_basic_auth
       configure_rack_protection
       @app_builder.use Rack::PactBroker::InvalidUriProtection

data/lib/pact_broker/config/basic_auth_configuration.rb

@@ -20,6 +20,13 @@ module PactBroker
 
           sensitive_values(:basic_auth_password, :basic_auth_read_only_password)
 
+          coerce_types(
+            basic_auth_username: :string,
+            basic_auth_password: :string,
+            basic_auth_read_only_username: :string,
+            basic_auth_read_only_password: :string
+          )
+
           def basic_auth_credentials_provided?
             basic_auth_username&.not_blank? && basic_auth_password&.not_blank?
           end

data/lib/pact_broker/config/runtime_configuration.rb

@@ -39,7 +39,8 @@ module PactBroker
         log_format: nil,
         warning_error_class_names: ["Sequel::ForeignKeyConstraintViolation"],
         hide_pactflow_messages: false,
-        log_configuration_on_startup: true
+        log_configuration_on_startup: true,
+        http_debug_logging_enabled: false
       )
 
       on_load :validate_logging_attributes!
@@ -52,9 +53,12 @@ module PactBroker
         webhook_scheme_whitelist: ["https"],
         webhook_host_whitelist: [],
         disable_ssl_verification: false,
-        webhook_certificates: [],
-        user_agent: "Pact Broker v#{PactBroker::VERSION}",
+        user_agent: "Pact Broker v#{PactBroker::VERSION}"
       )
+      # no default, if you set it to [] or nil, then anyway config blows up when it tries to merge in the
+      # numerically indexed hash from the environment variables.
+      attr_config :webhook_certificates
+      on_load :set_webhook_attribute_defaults
 
       # resource attributes
       attr_config(
@@ -178,8 +182,14 @@ module PactBroker
       def webhook_certificates= webhook_certificates
         if webhook_certificates.is_a?(Array)
           super(webhook_certificates.collect(&:symbolize_keys))
+        elsif webhook_certificates.is_a?(Hash)
+          if all_keys_are_number_strings?(webhook_certificates)
+            super(convert_hash_with_number_string_keys_to_array(webhook_certificates).collect(&:symbolize_keys))
+          else
+            raise_validation_error("webhook_certificates must be an array, or a hash where each key is an integer in string format.")
+          end
         elsif !webhook_certificates.nil?
-          raise_validation_error("webhook_certificates must be an array")
+          raise_validation_error("webhook_certificates cannot be set using a #{webhook_certificates.class}")
         end
       end
 
@@ -208,6 +218,14 @@ module PactBroker
       def raise_validation_error(msg)
         raise PactBroker::ConfigurationError, msg
       end
+
+      def set_webhook_attribute_defaults
+        # can't set a default on this, or anyway config blows up when trying to merge the
+        # hash from the env vars into an array/nil.
+        if webhook_certificates.nil?
+          self.webhook_certificates = []
+        end
+      end
     end
   end
 end

data/lib/pact_broker/config/runtime_configuration_coercion_methods.rb

@@ -4,6 +4,17 @@ require "pact_broker/config/space_delimited_integer_list"
 module PactBroker
   module Config
     module RuntimeConfigurationCoercionMethods
+
+      def all_keys_are_number_strings?(hash)
+        hash.keys.all? { | k | k.to_s.to_i.to_s == k } # is an integer as a string
+      end
+
+      def convert_hash_with_number_string_keys_to_array(hash)
+        hash.keys.collect{ |k| [k, k.to_i]}.sort_by(&:last).collect(&:first).collect do | key |
+          hash[key]
+        end
+      end
+
       def value_to_string_array value, property_name
         if value.is_a?(String)
           PactBroker::Config::SpaceDelimitedStringList.parse(value)

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
@@ -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
@@ -82,14 +80,6 @@ module PactBroker
       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
@@ -108,7 +107,7 @@ module PactBroker
       # rubocop: disable Metrics/CyclomaticComplexity
       def self.latest_verification_for_pseudo_branch(pact_publication, is_overall_latest, latest_verifications_for_cv_tags, tags_option, options)
         if options[:view] == "branch" || (options[:view] == "all" && pact_publication.consumer_version.branch_heads.any?)
-          pact_publication.latest_verification || pact_publication.latest_verification_for_consumer_branches(forbid_lazy_load: false)
+          pact_publication.latest_verification || pact_publication.latest_verification_for_consumer_branches
         elsif tags_option == true
           latest_verifications_for_cv_tags
             .select{ | v | v.consumer_id == pact_publication.consumer_id && v.provider_id == pact_publication.provider_id && pact_publication.head_pact_tags.collect(&:name).include?(v.consumer_version_tag_name) }

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]

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

@@ -20,12 +20,11 @@ module PactBroker
       delegate [:consumer_version_number, :name, :provider_name, :consumer_name] => :cached_domain_for_delegation
 
       set_primary_key :id
-      associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id], forbid_lazy_load: false)
-
+      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_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], 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)

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