pact_broker 2.58.0 → 2.59.2

data/lib/pact_broker/domain/version.rb

@@ -7,6 +7,7 @@ module PactBroker
   module Domain
     class Version < Sequel::Model
       plugin :timestamps, update_on_create: true
+      plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
 
       set_primary_key :id
       one_to_many :pact_publications, order: :revision_number, class: "PactBroker::Pacts::PactPublication", key: :consumer_version_id
@@ -86,7 +87,9 @@ module PactBroker
       end
 
       def after_create
+        super
         OrderVersions.(self)
+        refresh
       end
 
       def before_destroy

data/lib/pact_broker/groups/service.rb

@@ -16,7 +16,7 @@ module PactBroker
       end
 
       def groups
-        Relationships::Groupify.call index_service.find_index_items
+        Relationships::Groupify.call(index_service.find_all_index_items)
       end
     end
   end

data/lib/pact_broker/index/service.rb

@@ -28,51 +28,17 @@ module PactBroker
       # and the Pactflow UI. It really needs to be broken into to separate methods, as it's getting too messy
       # supporting both
 
-      def self.find_index_items options = {}
-        if options[:optimised]
-          find_index_items_optimised(options)
-        else
-          find_index_items_original(options)
-        end
+      def self.pact_publication_scope
+        PactBroker.policy_scope!(PactBroker::Pacts::PactPublication)
       end
 
-      def self.find_index_items_original options = {}
-        rows = PactBroker::Matrix::HeadRow
-          .select_all_qualified
-          .eager(:latest_triggered_webhooks)
-          .eager(:webhooks)
-
-        if !options[:tags]
-          # server side rendered index page without tags
-          rows = rows.where(consumer_version_tag_name: nil)
-        else
-          # server side rendered index page with tags=true or tags[]=a&tags=[]b
-          if options[:tags].is_a?(Array)
-            rows = rows.where(consumer_version_tag_name: options[:tags]).or(consumer_version_tag_name: nil)
-          end
-          rows = rows.eager(:consumer_version_tags)
-                      .eager(:provider_version_tags)
-                      .eager(:latest_verification_for_consumer_version_tag)
-                      .eager(:latest_verification_for_consumer_and_provider)
-        end
-        rows = rows.all.group_by(&:pact_publication_id).values.collect{ | rows| Matrix::AggregatedRow.new(rows) }
-
-        rows.sort.collect do | row |
-          PactBroker::Domain::IndexItem.create(
-            row.consumer,
-            row.provider,
-            row.pact,
-            row.overall_latest?,
-            row.latest_verification_for_pseudo_branch,
-            row.webhooks,
-            row.latest_triggered_webhooks,
-            options[:tags] ? row.consumer_head_tag_names : [],
-            options[:tags] ? row.provider_version_tags.select(&:latest?) : []
-          )
-        end
+      def self.find_all_index_items
+        # Is there a better way to do this? Setting a page_size of nil or -1 doesn't work
+        # If we get to 100000000000 index items, we're probably going to have bigger issues...
+        find_index_items(page_number: 1, page_size: 100000000000)
       end
 
-      def self.find_index_items_optimised options = {}
+      def self.find_index_items options = {}
         latest_verifications_for_cv_tags = latest_verifications_for_consumer_version_tags(options)
         latest_pact_publication_ids = latest_pact_publications.select(:id).all.collect{ |h| h[:id] }
 
@@ -82,7 +48,7 @@ module PactBroker
         pact_publication_ids = head_pact_publication_ids(options)
         pagination_record_count = pact_publication_ids.pagination_record_count
 
-        pact_publications = PactBroker::Pacts::PactPublication
+        pact_publications = pact_publication_scope
           .where(id: pact_publication_ids)
           .select_all_qualified
           .eager(:consumer)
@@ -144,7 +110,7 @@ module PactBroker
         latest_pact_publication_ids = latest_pact_publications.select(:id).all.collect{ |h| h[:id] }
         pact_publication_ids = head_pact_publication_ids(consumer_name: consumer_name, provider_name: provider_name, tags: true)
 
-        pact_publications = PactBroker::Pacts::PactPublication
+        pact_publications = pact_publication_scope
           .where(id: pact_publication_ids)
           .select_all_qualified
           .eager(:consumer)

data/lib/pact_broker/matrix/deployment_status_summary.rb

@@ -195,7 +195,7 @@ module PactBroker
               InteractionsMissingVerifications.new(selector_for(row.consumer_name), selector_for(row.provider_name), row.verification.interactions_missing_test_results)
             end
           rescue StandardError => e
-            log_error(e, "Error determining if there were missing interaction verifications")
+            logger.warn("Error determining if there were missing interaction verifications", e)
             nil
           end
         end.compact.tap { |it| report_missing_interaction_verifications(it) if it.any? }

data/lib/pact_broker/pacticipants/repository.rb

@@ -54,12 +54,12 @@ module PactBroker
       # TODO raise error if attributes apart from name are different, because this indicates that
       # the second request is not at the same time.
       def create args
-        PactBroker::Domain::Pacticipant.dataset.insert_ignore.insert(
+        PactBroker::Domain::Pacticipant.new(
           name: args[:name],
           repository_url: args[:repository_url],
           created_at: Sequel.datetime_class.now,
           updated_at: Sequel.datetime_class.now
-        )
+        ).insert_ignore
         PactBroker::Domain::Pacticipant.find(name: args[:name])
       end
 

data/lib/pact_broker/pacts/content.rb

@@ -32,7 +32,8 @@ module PactBroker
       end
 
       def interactions_missing_test_results
-        interactions.reject do | interaction |
+        return [] unless messages_or_interactions
+        messages_or_interactions.reject do | interaction |
           interaction['tests']&.any?
         end
       end

data/lib/pact_broker/pacts/latest_pact_publication_id_for_consumer_version.rb

@@ -4,16 +4,13 @@ require 'pact_broker/repositories/helpers'
 module PactBroker
   module Pacts
     class LatestPactPublicationIdForConsumerVersion < Sequel::Model(:latest_pact_publication_ids_for_consumer_versions)
-
+      set_primary_key [:provider_id, :consumer_version_id]
       unrestrict_primary_key
+      plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
 
       dataset_module do
         include PactBroker::Repositories::Helpers
       end
-
-      def upsert
-        self.class.upsert(to_hash, [:provider_id, :consumer_version_id])
-      end
     end
   end
 end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -7,7 +7,6 @@ require 'pact_broker/tags/head_pact_tags'
 module PactBroker
   module Pacts
     class PactPublication < Sequel::Model(:pact_publications)
-      UNIQUE_CONSTRAINT_KEYS = [:consumer_version_id, :provider_id, :revision_number].freeze
 
       extend Forwardable
 
@@ -22,6 +21,9 @@ module PactBroker
       one_to_one(:latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_id)
       one_to_many(:head_pact_tags, class: "PactBroker::Tags::HeadPactTag", primary_key: :id, key: :pact_publication_id)
 
+      plugin :upsert, identifying_columns: [:consumer_version_id, :provider_id, :revision_number]
+      plugin :timestamps, update_on_create: true
+
       dataset_module do
         include PactBroker::Repositories::Helpers
 
@@ -71,6 +73,14 @@ module PactBroker
           where(name_like(Sequel[:providers][:name], name))
         end
 
+        def consumer_name_like(name)
+          where(name_like(Sequel[:consumers][:name], name))
+        end
+
+        def consumer_version_number_like(number)
+          where(name_like(Sequel[:cv][:number], number))
+        end
+
         def consumer_version_tag(tag)
           where(Sequel[:ct][:name] => tag)
         end
@@ -150,20 +160,12 @@ module PactBroker
         OpenStruct.new(number: consumer_version.number, pacticipant: consumer, order: consumer_version.order)
       end
 
-      def upsert
-        params = to_hash.merge(created_at: Sequel.datetime_class.now)
-        self.id = PactPublication.upsert(params, UNIQUE_CONSTRAINT_KEYS).id
-        self.refresh
-      end
-
       private
 
       def cached_domain_for_delegation
         @domain_object ||= to_domain
       end
     end
-
-    PactPublication.plugin :timestamps, update_on_create: true
   end
 end
 

data/lib/pact_broker/pacts/pact_version.rb

@@ -6,6 +6,8 @@ module PactBroker
   module Pacts
     class PactVersion < Sequel::Model(:pact_versions)
       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"
       one_to_one :latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :id
@@ -79,14 +81,11 @@ module PactBroker
           .join(:versions, Sequel[:versions][:id] => Sequel[:verifications][:provider_version_id])
           .any?
       end
-
-      def upsert
-        self.class.upsert(to_hash, [:consumer_id, :provider_id, :sha])
-      end
     end
   end
 end
 
+
 # Table: pact_versions
 # Columns:
 #  id          | integer                     | PRIMARY KEY DEFAULT nextval('pact_versions_id_seq'::regclass)

data/lib/pact_broker/pacts/repository.rb

@@ -26,6 +26,16 @@ module PactBroker
       include PactBroker::Repositories
       include PactBroker::Repositories::Helpers
 
+      def scope_for(scope)
+        PactBroker.policy_scope!(scope)
+      end
+
+      # For the times when it doesn't make sense to use the scoped class, this is a way to
+      # indicate that it is an intentional use of the PactVersion class directly.
+      def unscoped(scope)
+        scope
+      end
+
       def create params
         pact_version = find_or_create_pact_version(
           params.fetch(:consumer_id),
@@ -87,16 +97,19 @@ module PactBroker
       end
 
       def delete params
-        id = AllPactPublications
-          .consumer(params.consumer_name)
-          .provider(params.provider_name)
-          .consumer_version_number(params.consumer_version_number)
-          .select_for_subquery(:id)
-        PactPublication.where(id: id).delete
+        id = scope_for(PactPublication)
+          .join_consumers
+          .join_providers
+          .join_consumer_versions
+          .consumer_name_like(params.consumer_name)
+          .provider_name_like(params.provider_name)
+          .consumer_version_number_like(params.consumer_version_number)
+          .select_for_subquery(Sequel[:pact_publications][:id].as(:id))
+        unscoped(PactPublication).where(id: id).delete
       end
 
       def delete_by_version_id version_id
-        Sequel::Model.db[:pact_publications].where(consumer_version_id: version_id).delete
+        scope_for(PactPublication).where(consumer_version_id: version_id).delete
       end
 
       def find_all_pact_versions_between consumer_name, options
@@ -109,25 +122,25 @@ module PactBroker
       def delete_all_pact_publications_between consumer_name, options
         consumer = pacticipant_repository.find_by_name!(consumer_name)
         provider = pacticipant_repository.find_by_name!(options.fetch(:and))
-        query = PactPublication.where(consumer: consumer, provider: provider)
+        query = scope_for(PactPublication).where(consumer: consumer, provider: provider)
         query = query.tag(options[:tag]) if options[:tag]
 
         ids = query.select_for_subquery(:id)
         webhook_repository.delete_triggered_webhooks_by_pact_publication_ids(ids)
-        PactPublication.where(id: ids).delete
+        unscoped(PactPublication).where(id: ids).delete
       end
 
       def delete_all_pact_versions_between consumer_name, options
         consumer = pacticipant_repository.find_by_name(consumer_name)
         provider = pacticipant_repository.find_by_name(options.fetch(:and))
-        PactVersion.where(consumer: consumer, provider: provider).delete
+        scope_for(PactVersion).where(consumer: consumer, provider: provider).delete
       end
 
       def find_latest_pact_versions_for_provider provider_name, tag = nil
         if tag
-          LatestTaggedPactPublications.provider(provider_name).order_ignore_case(:consumer_name).where(tag_name: tag).collect(&:to_domain)
+          scope_for(LatestTaggedPactPublications).provider(provider_name).order_ignore_case(:consumer_name).where(tag_name: tag).collect(&:to_domain)
         else
-          LatestPactPublications.provider(provider_name).order_ignore_case(:consumer_name).collect(&:to_domain)
+          scope_for(LatestPactPublications).provider(provider_name).order_ignore_case(:consumer_name).collect(&:to_domain)
         end
       end
 
@@ -135,7 +148,7 @@ module PactBroker
         provider = pacticipant_repository.find_by_name(provider_name)
         consumer = selector.consumer ? pacticipant_repository.find_by_name(selector.consumer) : nil
 
-        PactPublication
+        scope_for(PactPublication)
           .select_all_qualified
           .select_append(Sequel[:cv][:order].as(:consumer_version_order))
           .select_append(Sequel[:ct][:name].as(:consumer_version_tag_name))
@@ -189,7 +202,7 @@ module PactBroker
           non_wip_pact_publication_ids,
           options)
 
-        wip_pacts = AllPactPublications.where(id: wip_pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order)
+        wip_pacts = scope_for(PactPublication).where(id: wip_pact_publication_ids)
 
         # The first instance (by date) of each provider tag with that name
         provider_tag_collection = PactBroker::Domain::Tag
@@ -212,12 +225,12 @@ module PactBroker
             selectors = Selectors.create_for_latest_of_each_tag(pact.head_tag_names)
             VerifiablePact.new(pact.to_domain, selectors, true, pre_existing_pending_tags, [], true)
           end
-        end.compact
+        end.compact.sort
       end
 
       def find_pact_versions_for_provider provider_name, tag = nil
         if tag
-          LatestPactPublicationsByConsumerVersion
+          scope_for(LatestPactPublicationsByConsumerVersion)
             .join(:tags, {version_id: :consumer_version_id})
             .provider(provider_name)
             .order_ignore_case(:consumer_name)
@@ -225,7 +238,7 @@ module PactBroker
             .where(Sequel[:tags][:name] => tag)
             .collect(&:to_domain)
         else
-          LatestPactPublicationsByConsumerVersion
+          scope_for(LatestPactPublicationsByConsumerVersion)
             .provider(provider_name)
             .order_ignore_case(:consumer_name)
             .order_append(:consumer_version_order)
@@ -235,25 +248,25 @@ module PactBroker
 
       # Returns latest pact version for the consumer_version_number
       def find_by_consumer_version consumer_name, consumer_version_number
-        LatestPactPublicationsByConsumerVersion
+        scope_for(LatestPactPublicationsByConsumerVersion)
           .consumer(consumer_name)
           .consumer_version_number(consumer_version_number)
           .collect(&:to_domain_with_content)
       end
 
       def find_by_version_and_provider version_id, provider_id
-        LatestPactPublicationsByConsumerVersion
+        scope_for(LatestPactPublicationsByConsumerVersion)
           .eager(:tags)
           .where(consumer_version_id: version_id, provider_id: provider_id)
           .limit(1).collect(&:to_domain_with_content)[0]
       end
 
       def find_latest_pacts
-        LatestPactPublications.order(:consumer_name, :provider_name).collect(&:to_domain)
+        scope_for(LatestPactPublications).order(:consumer_name, :provider_name).collect(&:to_domain)
       end
 
       def find_latest_pact(consumer_name, provider_name, tag = nil)
-        query = LatestPactPublicationsByConsumerVersion
+        query = scope_for(LatestPactPublicationsByConsumerVersion)
           .select_all_qualified
           .consumer(consumer_name)
           .provider(provider_name)
@@ -267,7 +280,7 @@ module PactBroker
 
       # Allows optional consumer_name and provider_name
       def search_for_latest_pact(consumer_name, provider_name, tag = nil)
-        query = LatestPactPublicationsByConsumerVersion.select_all_qualified
+        query = scope_for(LatestPactPublicationsByConsumerVersion).select_all_qualified
         query = query.consumer(consumer_name) if consumer_name
         query = query.provider(provider_name) if provider_name
 
@@ -281,12 +294,12 @@ module PactBroker
 
       def find_pact consumer_name, consumer_version, provider_name, pact_version_sha = nil
         query = if pact_version_sha
-          AllPactPublications
+          scope_for(AllPactPublications)
             .pact_version_sha(pact_version_sha)
             .reverse_order(:consumer_version_order)
             .limit(1)
         else
-          LatestPactPublicationsByConsumerVersion
+          scope_for(LatestPactPublicationsByConsumerVersion)
         end
         query = query
           .eager(:tags)
@@ -297,7 +310,7 @@ module PactBroker
       end
 
       def find_all_revisions consumer_name, consumer_version, provider_name
-        AllPactPublications
+        scope_for(AllPactPublications)
           .consumer(consumer_name)
           .provider(provider_name)
           .consumer_version_number(consumer_version)
@@ -305,7 +318,7 @@ module PactBroker
       end
 
       def find_previous_pact pact, tag = nil
-        query = LatestPactPublicationsByConsumerVersion
+        query = scope_for(LatestPactPublicationsByConsumerVersion)
             .eager(:tags)
             .consumer(pact.consumer.name)
             .provider(pact.provider.name)
@@ -321,7 +334,7 @@ module PactBroker
       end
 
       def find_next_pact pact
-        LatestPactPublicationsByConsumerVersion
+        scope_for(LatestPactPublicationsByConsumerVersion)
           .eager(:tags)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
@@ -384,7 +397,7 @@ module PactBroker
 
       def find_pacts_for_which_the_latest_version_is_required(provider_name, consumer_version_selectors)
         if consumer_version_selectors.empty?
-          LatestPactPublications
+          scope_for(LatestPactPublications)
             .provider(provider_name)
             .order_ignore_case(:consumer_name)
             .collect do | latest_pact_publication |
@@ -403,7 +416,7 @@ module PactBroker
         # TODO make this an efficient query!
         # These are not yet de-duped. Should make the behaviour consistent between this and find_pacts_for_which_all_versions_for_the_tag_are_required ?
         if tag_names.any?
-          LatestTaggedPactPublications
+          scope_for(LatestTaggedPactPublications)
             .provider(provider_name)
             .where(tag_name: tag_names)
             .all
@@ -421,7 +434,7 @@ module PactBroker
         selector_tag_names = pact_publications.collect(&:tag_name)
         selectors = Selectors.create_for_latest_of_each_tag(selector_tag_names)
         last_pact_publication = pact_publications.sort_by(&:consumer_version_order).last
-        pact_publication = PactPublication.find(id: last_pact_publication.id)
+        pact_publication = scope_for(PactPublication).find(id: last_pact_publication.id)
         SelectedPact.new(
           pact_publication.to_domain,
           selectors
@@ -432,7 +445,7 @@ module PactBroker
         selector_tag_names = pact_publications.collect(&:tag_name)
         selectors = Selectors.create_for_latest_fallback_of_each_tag(selector_tag_names)
         last_pact_publication = pact_publications.sort_by(&:consumer_version_order).last
-        pact_publication = PactPublication.find(id: last_pact_publication.id)
+        pact_publication = unscoped(PactPublication).find(id: last_pact_publication.id)
         SelectedPact.new(
           pact_publication.to_domain,
           selectors
@@ -441,12 +454,12 @@ module PactBroker
 
       def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
         selectors.collect do | selector |
-          LatestTaggedPactPublications
+          scope_for(LatestTaggedPactPublications)
             .provider(provider_name)
             .where(tag_name: selector.fallback_tag)
             .all
             .collect do | latest_tagged_pact_publication |
-              pact_publication = PactPublication.find(id: latest_tagged_pact_publication.id)
+              pact_publication = unscoped(PactPublication).find(id: latest_tagged_pact_publication.id)
               SelectedPact.new(
                 pact_publication.to_domain,
                 Selectors.new(selector)
@@ -467,13 +480,13 @@ module PactBroker
 
       def find_previous_distinct_pact_by_sha pact
         current_pact_content_sha =
-          LatestPactPublicationsByConsumerVersion.select(:pact_version_sha)
+          scope_for(LatestPactPublicationsByConsumerVersion).select(:pact_version_sha)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
           .consumer_version_number(pact.consumer_version_number)
           .limit(1)
 
-        LatestPactPublicationsByConsumerVersion
+        scope_for(LatestPactPublicationsByConsumerVersion)
           .eager(:tags)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
@@ -488,7 +501,8 @@ module PactBroker
       end
 
       def find_or_create_pact_version consumer_id, provider_id, pact_version_sha, json_content
-        PactVersion.find(sha: pact_version_sha, consumer_id: consumer_id, provider_id: provider_id) || create_pact_version(consumer_id, provider_id, pact_version_sha, json_content)
+        unscoped(PactVersion).find(sha: pact_version_sha, consumer_id: consumer_id, provider_id: provider_id) ||
+          create_pact_version(consumer_id, provider_id, pact_version_sha, json_content)
       end
 
       def create_pact_version consumer_id, provider_id, sha, json_content
@@ -504,7 +518,7 @@ module PactBroker
       def find_all_database_versions_between(consumer_name, options, base_class = LatestPactPublicationsByConsumerVersion)
         provider_name = options.fetch(:and)
 
-        query = base_class
+        query = scope_for(base_class)
           .consumer(consumer_name)
           .provider(provider_name)
 
@@ -535,7 +549,7 @@ module PactBroker
 
       def find_head_pacts_that_have_not_been_successfully_verified_by_all_provider_tags(provider_id, pact_publication_ids_successfully_verified_by_all_provider_tags, options)
         # Exclude the head pacts that have been successfully verified by all the specified provider tags
-        LatestTaggedPactPublications
+        scope_for(LatestTaggedPactPublications)
           .where(provider_id: provider_id)
           .where(Sequel.lit('latest_tagged_pact_publications.created_at > ?', options.fetch(:include_wip_pacts_since)))
           .exclude(id: pact_publication_ids_successfully_verified_by_all_provider_tags)
@@ -557,7 +571,7 @@ module PactBroker
             Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
             Sequel[:provider_tags][:name] => provider_tag
           }
-          head_pacts = LatestTaggedPactPublications
+          head_pacts = scope_for(LatestTaggedPactPublications)
             .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
             .join(:verifications, verifications_join)
             .join(:tags, tags_join, { table_alias: :provider_tags } )