pact_broker 2.95.0 → 2.95.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e077e361037618a0d58670de46b25753d8755cb1e21ef58e9f73a8fe5705cd7f
-  data.tar.gz: 0e64d6fee6eb4cf36f69dea5bf94c432c088c93984ca51783e68f20b7b2e3130
+  metadata.gz: f65cf2bd6eb2b3f0f7fd727e61fc73005817200f8e72bbab574493e4ea9b9ba3
+  data.tar.gz: aac1fb501fc5624227e63d424c8982f266fa0a9a2d80b1184844193347ba6724
 SHA512:
-  metadata.gz: 8c7bbae3ff3736576977f15aaef79a3d6635667de76b994a83c8c4613ce7fa9999808af70838014f7b5d7c26e7ffbda5da5e5813b1394dd6c4557fe597c9a11f
-  data.tar.gz: 4783820b31a355a9c2bf9a36151cc0730dba2a1424a1c68b8da39ac1f658cec3334b18c406b58d1b211cb0a5f3cc72b14a619066ca9d0c2daca828720f144d08
+  metadata.gz: 8272759e5880069606e56bea3893055df49543b76b237d7511ce8fa21c0414f1a0e593e98ed1f9e67c4b9048b4da1c2d3ef938b0dfea182406cda696111c2bc4
+  data.tar.gz: 426a032f0016c8952934fbf630420be42accf192baeaff3bd2651aefa75170d055d8a4ed125640a7b3cad124cf5a461d7c930e5d289f4a6e5bd666366661940a

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+<a name="v2.95.1"></a>
+### v2.95.1 (2022-03-18)
+
+#### Bug Fixes
+
+* **can-i-deploy**
+  * allow new provider to be introduced to existing consumer without can-i-deploy having circular dependency issues	 ([e43974ca](/../../commit/e43974ca))
+
 <a name="v2.95.0"></a>
 ### v2.95.0 (2022-03-16)
 

data/lib/db.rb

@@ -38,6 +38,7 @@ module DB
     con.extension(:connection_validator)
     con.extension(:pagination)
     con.extension(:statement_timeout)
+    #con.extension(:caller_logging)
     con.extend_datasets do
       # rubocop: disable Lint/NestedMethodDefinition
       def any?

data/lib/pact_broker/api/resources/base_resource.rb

@@ -1,9 +1,281 @@
+# frozen_string_literal: true
 require "pact_broker/configuration"
+require "webmachine"
+require "pact_broker/services"
+require "pact_broker/api/decorators"
+require "pact_broker/logging"
+require "pact_broker/api/pact_broker_urls"
+require "pact_broker/json"
+require "pact_broker/pacts/pact_params"
+require "pact_broker/api/resources/authentication"
+require "pact_broker/api/resources/authorization"
+require "pact_broker/errors"
 
 module PactBroker
   module Api
     module Resources
-      BaseResource = PactBroker.configuration.base_resource_class_factory.call
+      class InvalidJsonError < PactBroker::Error ; end
+
+      class BaseResource < Webmachine::Resource
+        include PactBroker::Services
+        include PactBroker::Api::PactBrokerUrls
+        include PactBroker::Api::Resources::Authentication
+        include PactBroker::Api::Resources::Authorization
+
+        include PactBroker::Logging
+
+        attr_accessor :user
+
+        def initialize
+          PactBroker.configuration.before_resource.call(self)
+          application_context.before_resource&.call(self)
+        end
+
+        def options
+          { "Access-Control-Allow-Methods" => allowed_methods.join(", ")}
+        end
+
+        def known_methods
+          super + ["PATCH"]
+        end
+
+        def finish_request
+          application_context.after_resource&.call(self)
+          PactBroker.configuration.after_resource.call(self)
+        end
+
+        def is_authorized?(authorization_header)
+          authenticated?(self, authorization_header)
+        end
+
+        def forbidden?
+          if application_context.resource_authorizer
+            !application_context.resource_authorizer.call(self)
+          elsif PactBroker.configuration.authorize
+            !PactBroker.configuration.authorize.call(self, {})
+          else
+            false
+          end
+        end
+
+        # The path_info segments aren't URL decoded
+        def identifier_from_path
+          @identifier_from_path ||= request.path_info.each_with_object({}) do | (key, value), hash|
+            if value.is_a?(String)
+              hash[key] = URI.decode(value)
+            elsif value.is_a?(Symbol) || value.is_a?(Numeric)
+              hash[key] = value
+            end
+          end
+        end
+
+        alias_method :path_info, :identifier_from_path
+
+        def base_url
+          # Have to use something for the base URL here - we can't use an empty string as we can in the UI.
+          # Can't work out if cache poisoning is a vulnerability for APIs or not.
+          # Using the request base URI as a fallback if the base_url is not configured may be a vulnerability,
+          # but the documentation recommends that the
+          # base_url should be set in the configuration to mitigate this.
+          request.env["pactbroker.base_url"] || request.base_uri.to_s.chomp("/")
+        end
+
+        # See comments for base_url in lib/pact_broker/doc/controllers/app.rb
+        def ui_base_url
+          request.env["pactbroker.base_url"] || ""
+        end
+
+        def charsets_provided
+          [["utf-8", :encode]]
+        end
+
+        # We only use utf-8 so leave encoding as it is
+        def encode(body)
+          body
+        end
+
+        def resource_url
+          request.uri.to_s.gsub(/\?.*/, "").chomp("/")
+        end
+
+        def decorator_context options = {}
+          application_context.decorator_context_creator.call(self, options)
+        end
+
+        def decorator_options options = {}
+          { user_options: decorator_context(options) }
+        end
+
+        def handle_exception(error)
+          error_reference = PactBroker::Errors.generate_error_reference
+          application_context.error_logger.call(error, error_reference, request.env)
+          if PactBroker::Errors.reportable_error?(error)
+            PactBroker::Errors.report(error, error_reference, request.env)
+          end
+          response.body = application_context.error_response_body_generator.call(error, error_reference, request.env)
+        end
+
+        # rubocop: disable Metrics/CyclomaticComplexity
+        def params(options = {})
+          return options[:default] if options.key?(:default) && request_body.empty?
+
+          symbolize_names = !options.key?(:symbolize_names) || options[:symbolize_names]
+          if symbolize_names
+            @params_with_symbol_keys ||= JSON.parse(request_body, { symbolize_names: true }.merge(PACT_PARSING_OPTIONS)) #Not load! Otherwise it will try to load Ruby classes.
+          else
+            @params_with_string_keys ||= JSON.parse(request_body, { symbolize_names: false }.merge(PACT_PARSING_OPTIONS)) #Not load! Otherwise it will try to load Ruby classes.
+          end
+        rescue JSON::JSONError => e
+          raise InvalidJsonError.new("Error parsing JSON - #{e.message}")
+        end
+        # rubocop: enable Metrics/CyclomaticComplexity
+
+        def params_with_string_keys
+          params(symbolize_names: false)
+        end
+
+        def pact_params
+          @pact_params ||= PactBroker::Pacts::PactParams.from_request request, identifier_from_path
+        end
+
+        def set_json_error_message message
+          response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
+          response.body = { error: message }.to_json
+        end
+
+        def set_json_validation_error_messages errors
+          response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
+          response.body = { errors: errors }.to_json
+        end
+
+        def request_body
+          @request_body ||= request.body.to_s
+        end
+
+        def consumer_name
+          identifier_from_path[:consumer_name]
+        end
+
+        def consumer_version_number
+          identifier_from_path[:consumer_version_number]
+        end
+
+        def pacticipant_version_number
+          identifier_from_path[:pacticipant_version_number]
+        end
+
+        def consumer_specified?
+          identifier_from_path.key?(:consumer_name)
+        end
+
+        def provider_specified?
+          identifier_from_path.key?(:provider_name)
+        end
+
+        def provider_name
+          identifier_from_path[:provider_name]
+        end
+
+        def pacticipant_name
+          identifier_from_path[:pacticipant_name]
+        end
+
+        def pacticipant_specified?
+          identifier_from_path.key?(:pacticipant_name)
+        end
+
+        def invalid_json?
+          begin
+            params
+            false
+          rescue StandardError => e
+            logger.info "Error parsing JSON #{e} - #{request_body}"
+            set_json_error_message "Error parsing JSON - #{e.message}"
+            response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
+            true
+          end
+        end
+
+        def validation_errors? model
+          if (errors = model.validate).any?
+            set_json_validation_error_messages errors
+            true
+          else
+            false
+          end
+        end
+
+        def contract_validation_errors? contract, params
+          if (invalid = !contract.validate(params))
+            set_json_validation_error_messages contract.errors.messages
+          end
+          invalid
+        end
+
+        def find_pacticipant name, role
+          pacticipant_service.find_pacticipant_by_name(name).tap do | pacticipant |
+            set_json_error_message("No #{role} with name '#{name}' found") if pacticipant.nil?
+          end
+        end
+
+        def consumer
+          @consumer ||= identifier_from_path[:consumer_name] && find_pacticipant(identifier_from_path[:consumer_name], "consumer")
+        end
+
+        def provider
+          @provider ||= identifier_from_path[:provider_name] && find_pacticipant(identifier_from_path[:provider_name], "provider")
+        end
+
+        def pacticipant
+          @pacticipant ||= identifier_from_path[:pacticipant_name] && find_pacticipant(identifier_from_path[:pacticipant_name], "pacticipant")
+        end
+
+        def pact
+          @pact ||= pact_service.find_pact(pact_params)
+        end
+
+        # Not necessarily an existing integration
+        def integration
+          if consumer_specified? && provider_specified?
+            OpenStruct.new(consumer: consumer, provider: provider)
+          else
+            nil
+          end
+        end
+
+        def database_connector
+          request.env["pactbroker.database_connector"]
+        end
+
+        def application_context
+          request.path_info[:application_context]
+        end
+
+        def decorator_class(name)
+          application_context.decorator_configuration.class_for(name)
+        end
+
+        def api_contract_class(name)
+          application_context.api_contract_configuration.class_for(name)
+        end
+
+        def schema
+          nil
+        end
+
+        def validation_errors_for_schema?(schema_to_use = schema, params_to_validate = params)
+          if (errors = schema_to_use.call(params_to_validate)).any?
+            set_json_validation_error_messages(errors)
+            true
+          else
+            false
+          end
+        end
+
+        def malformed_request_for_json_with_schema?(schema_to_use = schema, params_to_validate = params)
+          invalid_json? || validation_errors_for_schema?(schema_to_use, params_to_validate)
+        end
+      end
     end
   end
 end

data/lib/pact_broker/api/resources/default_base_resource.rb

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-require "webmachine"
-require "pact_broker/services"
-require "pact_broker/api/decorators"
-require "pact_broker/logging"
-require "pact_broker/api/pact_broker_urls"
-require "pact_broker/json"
-require "pact_broker/pacts/pact_params"
-require "pact_broker/api/resources/authentication"
-require "pact_broker/api/resources/authorization"
-require "pact_broker/errors"
-
-module PactBroker
-  module Api
-    module Resources
-      class InvalidJsonError < PactBroker::Error ; end
-
-      class DefaultBaseResource < Webmachine::Resource
-        include PactBroker::Services
-        include PactBroker::Api::PactBrokerUrls
-        include PactBroker::Api::Resources::Authentication
-        include PactBroker::Api::Resources::Authorization
-
-        include PactBroker::Logging
-
-        attr_accessor :user
-
-        def initialize
-          PactBroker.configuration.before_resource.call(self)
-          application_context.before_resource&.call(self)
-        end
-
-        def options
-          { "Access-Control-Allow-Methods" => allowed_methods.join(", ")}
-        end
-
-        def known_methods
-          super + ["PATCH"]
-        end
-
-        def finish_request
-          application_context.after_resource&.call(self)
-          PactBroker.configuration.after_resource.call(self)
-        end
-
-        def is_authorized?(authorization_header)
-          authenticated?(self, authorization_header)
-        end
-
-        def forbidden?
-          if application_context.resource_authorizer
-            !application_context.resource_authorizer.call(self)
-          elsif PactBroker.configuration.authorize
-            !PactBroker.configuration.authorize.call(self, {})
-          else
-            false
-          end
-        end
-
-        # The path_info segments aren't URL decoded
-        def identifier_from_path
-          @identifier_from_path ||= request.path_info.each_with_object({}) do | (key, value), hash|
-            if value.is_a?(String)
-              hash[key] = URI.decode(value)
-            elsif value.is_a?(Symbol) || value.is_a?(Numeric)
-              hash[key] = value
-            end
-          end
-        end
-
-        alias_method :path_info, :identifier_from_path
-
-        def base_url
-          # Have to use something for the base URL here - we can't use an empty string as we can in the UI.
-          # Can't work out if cache poisoning is a vulnerability for APIs or not.
-          # Using the request base URI as a fallback if the base_url is not configured may be a vulnerability,
-          # but the documentation recommends that the
-          # base_url should be set in the configuration to mitigate this.
-          request.env["pactbroker.base_url"] || request.base_uri.to_s.chomp("/")
-        end
-
-        # See comments for base_url in lib/pact_broker/doc/controllers/app.rb
-        def ui_base_url
-          request.env["pactbroker.base_url"] || ""
-        end
-
-        def charsets_provided
-          [["utf-8", :encode]]
-        end
-
-        # We only use utf-8 so leave encoding as it is
-        def encode(body)
-          body
-        end
-
-        def resource_url
-          request.uri.to_s.gsub(/\?.*/, "").chomp("/")
-        end
-
-        def decorator_context options = {}
-          application_context.decorator_context_creator.call(self, options)
-        end
-
-        def decorator_options options = {}
-          { user_options: decorator_context(options) }
-        end
-
-        def handle_exception(error)
-          error_reference = PactBroker::Errors.generate_error_reference
-          application_context.error_logger.call(error, error_reference, request.env)
-          if PactBroker::Errors.reportable_error?(error)
-            PactBroker::Errors.report(error, error_reference, request.env)
-          end
-          response.body = application_context.error_response_body_generator.call(error, error_reference, request.env)
-        end
-
-        # rubocop: disable Metrics/CyclomaticComplexity
-        def params(options = {})
-          return options[:default] if options.key?(:default) && request_body.empty?
-
-          symbolize_names = !options.key?(:symbolize_names) || options[:symbolize_names]
-          if symbolize_names
-            @params_with_symbol_keys ||= JSON.parse(request_body, { symbolize_names: true }.merge(PACT_PARSING_OPTIONS)) #Not load! Otherwise it will try to load Ruby classes.
-          else
-            @params_with_string_keys ||= JSON.parse(request_body, { symbolize_names: false }.merge(PACT_PARSING_OPTIONS)) #Not load! Otherwise it will try to load Ruby classes.
-          end
-        rescue JSON::JSONError => e
-          raise InvalidJsonError.new("Error parsing JSON - #{e.message}")
-        end
-        # rubocop: enable Metrics/CyclomaticComplexity
-
-        def params_with_string_keys
-          params(symbolize_names: false)
-        end
-
-        def pact_params
-          @pact_params ||= PactBroker::Pacts::PactParams.from_request request, identifier_from_path
-        end
-
-        def set_json_error_message message
-          response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
-          response.body = { error: message }.to_json
-        end
-
-        def set_json_validation_error_messages errors
-          response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
-          response.body = { errors: errors }.to_json
-        end
-
-        def request_body
-          @request_body ||= request.body.to_s
-        end
-
-        def consumer_name
-          identifier_from_path[:consumer_name]
-        end
-
-        def consumer_version_number
-          identifier_from_path[:consumer_version_number]
-        end
-
-        def pacticipant_version_number
-          identifier_from_path[:pacticipant_version_number]
-        end
-
-        def consumer_specified?
-          identifier_from_path.key?(:consumer_name)
-        end
-
-        def provider_specified?
-          identifier_from_path.key?(:provider_name)
-        end
-
-        def provider_name
-          identifier_from_path[:provider_name]
-        end
-
-        def pacticipant_name
-          identifier_from_path[:pacticipant_name]
-        end
-
-        def pacticipant_specified?
-          identifier_from_path.key?(:pacticipant_name)
-        end
-
-        def invalid_json?
-          begin
-            params
-            false
-          rescue StandardError => e
-            logger.info "Error parsing JSON #{e} - #{request_body}"
-            set_json_error_message "Error parsing JSON - #{e.message}"
-            response.headers["Content-Type"] = "application/hal+json;charset=utf-8"
-            true
-          end
-        end
-
-        def validation_errors? model
-          if (errors = model.validate).any?
-            set_json_validation_error_messages errors
-            true
-          else
-            false
-          end
-        end
-
-        def contract_validation_errors? contract, params
-          if (invalid = !contract.validate(params))
-            set_json_validation_error_messages contract.errors.messages
-          end
-          invalid
-        end
-
-        def find_pacticipant name, role
-          pacticipant_service.find_pacticipant_by_name(name).tap do | pacticipant |
-            set_json_error_message("No #{role} with name '#{name}' found") if pacticipant.nil?
-          end
-        end
-
-        def consumer
-          @consumer ||= identifier_from_path[:consumer_name] && find_pacticipant(identifier_from_path[:consumer_name], "consumer")
-        end
-
-        def provider
-          @provider ||= identifier_from_path[:provider_name] && find_pacticipant(identifier_from_path[:provider_name], "provider")
-        end
-
-        def pacticipant
-          @pacticipant ||= identifier_from_path[:pacticipant_name] && find_pacticipant(identifier_from_path[:pacticipant_name], "pacticipant")
-        end
-
-        def pact
-          @pact ||= pact_service.find_pact(pact_params)
-        end
-
-        # Not necessarily an existing integration
-        def integration
-          if consumer_specified? && provider_specified?
-            OpenStruct.new(consumer: consumer, provider: provider)
-          else
-            nil
-          end
-        end
-
-        def database_connector
-          request.env["pactbroker.database_connector"]
-        end
-
-        def application_context
-          request.path_info[:application_context]
-        end
-
-        def decorator_class(name)
-          application_context.decorator_configuration.class_for(name)
-        end
-
-        def api_contract_class(name)
-          application_context.api_contract_configuration.class_for(name)
-        end
-
-        def schema
-          nil
-        end
-
-        def validation_errors_for_schema?(schema_to_use = schema, params_to_validate = params)
-          if (errors = schema_to_use.call(params_to_validate)).any?
-            set_json_validation_error_messages(errors)
-            true
-          else
-            false
-          end
-        end
-
-        def malformed_request_for_json_with_schema?(schema_to_use = schema, params_to_validate = params)
-          invalid_json? || validation_errors_for_schema?(schema_to_use, params_to_validate)
-        end
-      end
-    end
-  end
-end

data/lib/pact_broker/configuration.rb

@@ -35,7 +35,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=
 
@@ -79,10 +79,6 @@ 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
 

data/lib/pact_broker/index/service.rb

@@ -108,7 +108,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
+          pact_publication.latest_verification || pact_publication.latest_verification_for_consumer_branches(forbid_lazy_load: false)
         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/matrix/repository.rb

@@ -84,7 +84,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 +101,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 +118,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 +260,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/pacts/pact_publication.rb

@@ -20,11 +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)
-      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, :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)
 
       # TODO rename to consumer_version_tags
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :key => :version_id, :primary_key => :consumer_version_id)
@@ -105,8 +105,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/pacts_for_verification_repository.rb

@@ -299,7 +299,15 @@ 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(:provider)
+                              .eager(:consumer)
+                              .eager(: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 +316,7 @@ module PactBroker
                       ""
                     end
 
-          "#{p.consumer_name} #{p.consumer_version_number}" + suffix
+          "#{p.consumer.name} #{p.consumer_version.number}" + suffix
         end
       end
 

data/lib/pact_broker/pacts/repository.rb

@@ -257,6 +257,7 @@ module PactBroker
             .collect(&:to_domain_with_content).first
         elsif consumer_version_number && pact_version_sha
           pact_publication = pact_publication_by_consumer_version.all.first
+          pact_publication&.allow_lazy_load
           if pact_publication && pact_publication.pact_version.sha == pact_version_sha
             pact_publication.tags
             pact_publication.to_domain_with_content

data/lib/pact_broker/repositories/helpers.rb

@@ -6,6 +6,10 @@ module PactBroker
 
       extend self
 
+      def all_forbidding_lazy_load
+        all.each{ | row | row.forbid_lazy_load if row.respond_to?(:forbid_lazy_load) }
+      end
+
       def name_like column_name, value
         if PactBroker.configuration.use_case_sensitive_resource_names
           if mysql?

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.95.0"
+  VERSION = "2.95.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.95.0
+  version: 2.95.1
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-16 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty