pact_broker 2.76.2 → 2.77.0

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -0,0 +1,297 @@
+module PactBroker
+  module Pacts
+    module PactPublicationDatasetModule
+      def for_provider provider
+        where(provider: provider)
+      end
+
+      def for_consumer consumer
+        where(consumer: consumer)
+      end
+
+      def for_provider_and_consumer_version_selector provider, selector
+        # Does not yet support "all pacts for specified tag" - that code is still in the Pact::Repository
+        query = for_provider(provider)
+        query = query.for_consumer(PactBroker::Domain::Pacticipant.find_by_name(selector.consumer)) if selector.consumer
+        # Do this last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
+        query = query.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?
+        query = query.latest_for_consumer_tag(selector.tag) if selector.latest_for_tag?
+        query = query.overall_latest if selector.overall_latest?
+        query
+      end
+
+      def latest_by_consumer_branch
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id]
+        }
+
+        base_query = join(:versions, versions_join, { table_alias: :cv }) do
+          Sequel.lit("cv.branch is not null")
+        end
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
+        }
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:cv][:branch])
+        end
+
+        base_query.left_join(base_query.select(:consumer_id, :branch, :order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def overall_latest
+        base_query = join_consumer_versions # won't need to do this when we add the order to latest_pact_publication_ids_for_consumer_versions
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id]
+        }
+
+        base_query = base_query.select_all_qualified if no_columns_selected?
+
+        base_query.left_join(base_query.select(:consumer_id, :provider_id, :order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_for_consumer_branch(branch)
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id],
+          Sequel[:cv][:branch] => branch
+        }
+
+        base_query = join(:versions, versions_join, { table_alias: :cv }) do
+          Sequel.lit("cv.branch is not null")
+        end
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
+        }
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:cv][:branch])
+        end
+
+        base_query.left_join(base_query.select(:consumer_id, :branch, :order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_by_consumer_tag
+        tags_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id]
+        }
+
+        base_query = join(:tags, tags_join)
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+        end
+
+        joined_query = base_query.select(
+          Sequel[:pact_publications][:consumer_id],
+          Sequel[:tags][:version_order],
+          Sequel[:tags][:name].as(:tag_name)
+        )
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
+        }
+        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
+        end
+        .where(Sequel[:pp2][:version_order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_for_consumer_tag(tag_name)
+        tags_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
+          Sequel[:tags][:name] => tag_name
+        }
+
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+        end
+
+        base_query = base_query
+          .join(:tags, tags_join)
+          .where(Sequel[:tags][:name] => tag_name)
+
+        joined_query = base_query.select(
+          Sequel[:pact_publications][:consumer_id],
+          Sequel[:tags][:name].as(:tag_name),
+          Sequel[:tags][:version_order]
+        )
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
+        }
+
+        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
+        end
+        .where(Sequel[:pp2][:version_order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def successfully_verified_by_provider_branch(provider_id, provider_version_branch)
+        verifications_join = {
+          pact_version_id: :pact_version_id,
+          Sequel[:verifications][:success] => true,
+          Sequel[:verifications][:wip] => false,
+          Sequel[:verifications][:provider_id] => provider_id
+        }
+        versions_join = {
+          Sequel[:verifications][:provider_version_id] => Sequel[:provider_versions][:id],
+          Sequel[:provider_versions][:branch] => provider_version_branch,
+          Sequel[:provider_versions][:pacticipant_id] => provider_id
+        }
+
+        from_self(alias: :pp).select(Sequel[:pp].*)
+          .join(:verifications, verifications_join)
+          .join(:versions, versions_join, { table_alias: :provider_versions } )
+          .where(Sequel[:pp][:provider_id] => provider_id)
+          .distinct
+      end
+
+      def successfully_verified_by_provider_tag(provider_id, provider_tag)
+        verifications_join = {
+          pact_version_id: :pact_version_id,
+          Sequel[:verifications][:success] => true,
+          Sequel[:verifications][:wip] => false,
+          Sequel[:verifications][:provider_id] => provider_id
+        }
+        tags_join = {
+          Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
+          Sequel[:provider_tags][:name] => provider_tag
+        }
+
+        from_self(alias: :pp).select(Sequel[:pp].*)
+          .join(:verifications, verifications_join)
+          .join(:tags, tags_join, { table_alias: :provider_tags } )
+          .where(Sequel[:pp][:provider_id] => provider_id)
+          .distinct
+      end
+
+      def created_after date
+        where(Sequel.lit("#{first_source_alias}.created_at > ?", date))
+      end
+
+      def remove_overridden_revisions(pact_publications_alias = :pact_publications)
+        join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[:lp][:pact_publication_id] => Sequel[pact_publications_alias][:id] }, { table_alias: :lp})
+      end
+
+      def remove_overridden_revisions_from_complete_query
+        from_self(alias: :p)
+        .select(Sequel[:p].*)
+        .remove_overridden_revisions(:p)
+      end
+
+      def join_consumer_versions(table_alias = :cv, extra_join_criteria = {}, &block)
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:versions, versions_join, { table_alias: table_alias }, &block)
+      end
+
+      def join_consumer_version_tags(table_alias = :ct)
+        join(:tags, { Sequel[table_alias][:version_id] => Sequel[:pact_publications][:consumer_version_id]}, { table_alias: table_alias })
+      end
+
+      def join_consumer_version_tags_with_names(consumer_version_tag_names)
+        join(:tags, {
+          Sequel[:ct][:version_id] => Sequel[:pact_publications][:consumer_version_id],
+          Sequel[:ct][:name] => consumer_version_tag_names
+        }, {
+          table_alias: :ct
+        })
+      end
+
+      def join_providers(table_alias = :providers, base_table = :pact_publications, extra_join_criteria = {})
+        provider_join = {
+          Sequel[base_table][:provider_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:pacticipants, provider_join, { table_alias: table_alias })
+      end
+
+      def join_consumers(table_alias = :consumers, base_table = :pact_publications, extra_join_criteria = {})
+        consumer_join = {
+          Sequel[base_table][:consumer_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:pacticipants, consumer_join, { table_alias: table_alias })
+      end
+
+      def join_pact_versions
+        join(:pact_versions, { Sequel[:pact_publications][:pact_version_id] => Sequel[:pact_versions][:id] })
+      end
+
+      def eager_load_pact_versions
+        eager(:pact_versions)
+      end
+
+      def tag tag_name
+        filter = name_like(Sequel.qualify(:tags, :name), tag_name)
+        join(:tags, {version_id: :consumer_version_id}).where(filter)
+      end
+
+      def provider_name_like(name)
+        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
+
+      def order_by_consumer_name
+        order_append_ignore_case(Sequel[:consumers][:name])
+      end
+
+      def order_by_consumer_version_order
+        order_append(Sequel[:cv][:order])
+      end
+
+      def where_consumer_if_set(consumer)
+        if consumer
+          where(consumer: consumer)
+        else
+          self
+        end
+      end
+
+      def delete
+        require 'pact_broker/webhooks/triggered_webhook'
+        PactBroker::Webhooks::TriggeredWebhook.where(pact_publication: self).delete
+        super
+      end
+
+      private
+
+      def no_columns_selected?
+        opts[:select].nil?
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/pact_version.rb

@@ -85,10 +85,9 @@ module PactBroker
   end
 end
 
-
 # Table: pact_versions
 # Columns:
-#  id          | integer                     | PRIMARY KEY DEFAULT nextval('pact_versions_id_seq'::regclass)
+#  id          | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
 #  consumer_id | integer                     | NOT NULL
 #  provider_id | integer                     | NOT NULL
 #  sha         | text                        | NOT NULL

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -0,0 +1,286 @@
+require 'sequel'
+require 'pact_broker/logging'
+require 'pact_broker/pacts/pact_publication'
+require 'pact_broker/domain'
+require 'pact_broker/pacts/verifiable_pact'
+require 'pact_broker/repositories/helpers'
+require 'pact_broker/pacts/selected_pact'
+require 'pact_broker/pacts/selector'
+require 'pact_broker/pacts/selectors'
+require 'pact_broker/feature_toggle'
+
+module PactBroker
+  module Pacts
+    class PactsForVerificationRepository
+      include PactBroker::Logging
+      include PactBroker::Repositories
+      include PactBroker::Repositories::Helpers
+
+      def find(provider_name, consumer_version_selectors)
+        selected_pacts = find_pacts_for_which_the_latest_version_of_something_is_required(provider_name, consumer_version_selectors) +
+          find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+        selected_pacts = selected_pacts + find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
+        merge_selected_pacts(selected_pacts)
+      end
+
+      # To find the work in progress pacts for this verification execution:
+      # For each provider tag that will be applied to this verification result (usually there will just be one, but
+      # we have to allow for multiple tags),
+      # find the head pacts (the pacts that are the latest for their tag) that have been successfully
+      # verified against the provider tag.
+      # Then, find all the head pacts, and remove the ones that have been successfully verified by ALL
+      # of the provider tags supplied, and the ones that were published before the include_wip_pacts_since date.
+      # Then, for all of the head pacts that are remaining (these are the WIP ones) work out which
+      # provider tags they are pending for.
+      # Don't include pact publications that were created before the provider tag was first used
+      # (that is, before the provider's git branch was created).
+      def find_wip provider_name, provider_version_branch, provider_tags_names = [], options = {}
+        # TODO not sure about this
+        return [] if provider_tags_names.empty? && provider_version_branch == nil
+
+        if provider_version_branch
+          return find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, options)
+        end
+
+        provider = pacticipant_repository.find_by_name(provider_name)
+        wip_start_date = options.fetch(:include_wip_pacts_since)
+        provider_tags = provider_tag_objects_for(provider, provider_tags_names)
+
+        wip_by_consumer_tags = find_wip_pact_versions_for_provider_by_provider_tags(
+          provider,
+          provider_tags_names,
+          provider_tags,
+          wip_start_date,
+          :latest_by_consumer_tag)
+
+        wip_by_consumer_branches = find_wip_pact_versions_for_provider_by_provider_tags(
+          provider,
+          provider_tags_names,
+          provider_tags,
+          wip_start_date,
+          :latest_by_consumer_branch)
+
+        deduplicate_verifiable_pacts(wip_by_consumer_tags + wip_by_consumer_branches).sort
+      end
+
+      private
+
+      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
+
+      # Note: created_at is coming back as a string for sqlite
+      # Can't work out how to to tell Sequel that this should be a date
+      def to_datetime string_or_datetime
+        if string_or_datetime.is_a?(String)
+          Sequel.string_to_datetime(string_or_datetime)
+        else
+          string_or_datetime
+        end
+      end
+
+      def find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
+        # TODO at the moment, the validation doesn't stop fallback being used with 'all' selectors
+        selectors_with_fallback_tags = consumer_version_selectors.select(&:fallback_tag?)
+        selectors_missing_a_pact = selectors_with_fallback_tags.reject do | selector |
+          selected_pacts.any? do | selected_pact |
+            selected_pact.latest_for_tag?(selector.tag)
+          end
+        end
+
+        if selectors_missing_a_pact.any?
+          find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors_missing_a_pact)
+        else
+          []
+        end
+      end
+
+      def find_pacts_for_which_the_latest_version_of_something_is_required(provider_name, consumer_version_selectors)
+        provider = pacticipant_repository.find_by_name(provider_name)
+
+        selectors = if consumer_version_selectors.empty?
+          Selectors.create_for_overall_latest
+        else
+          consumer_version_selectors.select(&:latest_for_tag?) +
+            consumer_version_selectors.select(&:latest_for_branch?) +
+            consumer_version_selectors.select(&:overall_latest?)
+        end
+
+        selectors.flat_map do | selector |
+          query = scope_for(PactPublication).for_provider_and_consumer_version_selector(provider, selector)
+          query.all.collect do | pact_publication |
+            SelectedPact.new(
+              pact_publication.to_domain,
+              Selectors.new(selector.resolve(pact_publication.consumer_version))
+            )
+          end
+        end
+      end
+
+      def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
+        selectors.collect do | selector |
+          query = scope_for(LatestTaggedPactPublications).provider(provider_name).where(tag_name: selector.fallback_tag)
+          query = query.consumer(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
+        end.flatten
+      end
+
+
+      def find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+        # The tags for which all versions are specified
+        selectors = consumer_version_selectors.select(&:all_for_tag?)
+
+        selectors.flat_map do | selector |
+          find_all_pact_versions_for_provider_with_consumer_version_tags(provider_name, selector)
+        end
+      end
+
+      def find_provider_tags_for_which_pact_publication_id_is_pending(pact_publication, successfully_verified_head_pact_publication_ids_for_each_provider_tag)
+        successfully_verified_head_pact_publication_ids_for_each_provider_tag
+          .select do | _, pact_publication_ids |
+            !pact_publication_ids.include?(pact_publication.id)
+          end.keys
+      end
+
+      def find_provider_tag_names_that_were_first_used_before_pact_published(pact_publication, provider_tag_collection)
+        provider_tag_collection.select { | tag| to_datetime(tag.created_at) < pact_publication.created_at }.collect(&:name)
+      end
+
+      def deduplicate_verifiable_pacts(verifiable_pacts)
+        VerifiablePact.deduplicate(verifiable_pacts)
+      end
+
+      def merge_selected_pacts(selected_pacts)
+        selected_pacts
+          .group_by{ |p| [p.consumer_name, p.pact_version_sha] }
+          .values
+          .collect do | selected_pacts_for_pact_version_id |
+            SelectedPact.merge(selected_pacts_for_pact_version_id)
+          end
+      end
+
+      def provider_tag_objects_for(provider, provider_tags_names)
+        PactBroker::Domain::Tag
+          .select_group(Sequel[:tags][:name], Sequel[:pacticipant_id])
+          .select_append(Sequel.function(:min, Sequel[:tags][:created_at]).as(:created_at))
+          .distinct
+          .where(pacticipant_id: provider.id)
+          .where(name: provider_tags_names)
+          .all
+      end
+
+      def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, provider_tags, wip_start_date, pact_publication_scope)
+        potential_wip_pacts_by_consumer_tag_query = PactPublication.for_provider(provider).created_after(wip_start_date).send(pact_publication_scope)
+        potential_wip_pacts_by_consumer_tag = potential_wip_pacts_by_consumer_tag_query.all
+
+        tag_to_pact_publications = provider_tags_names.each_with_object({}) do | provider_tag_name, tag_to_pact_publications |
+          tag_to_pact_publications[provider_tag_name] = remove_already_verified_by_tag(
+            potential_wip_pacts_by_consumer_tag,
+            potential_wip_pacts_by_consumer_tag_query,
+            provider,
+            provider_tag_name
+          )
+        end
+
+        provider_has_no_versions = !provider.any_versions?
+
+        tag_to_pact_publications.flat_map do | provider_tag_name, pact_publications |
+          pact_publications.collect do | pact_publication |
+            force_include = PactBroker.feature_enabled?(:experimental_no_provider_versions_makes_all_head_pacts_wip) && provider_has_no_versions
+
+            pending_tag_names_to_use = if force_include
+              [provider_tag_name]
+            else
+              pre_existing_tag_names = find_provider_tag_names_that_were_first_used_before_pact_published(pact_publication, provider_tags)
+              [provider_tag_name] & pre_existing_tag_names
+            end
+
+            if pending_tag_names_to_use.any?
+              selectors = create_selectors_for_wip_pact(pact_publication)
+              VerifiablePact.create_for_wip_for_provider_tags(pact_publication.to_domain, selectors, pending_tag_names_to_use)
+            end
+          end
+        end.compact
+      end
+
+      def create_selectors_for_wip_pact(pact_publication)
+        if pact_publication.values[:tag_name]
+          Selectors.create_for_latest_for_tag(pact_publication.values[:tag_name])
+        else
+          Selectors.create_for_latest_for_branch(pact_publication.consumer_version.branch)
+        end
+      end
+
+      def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, options)
+        provider = pacticipant_repository.find_by_name(provider_name)
+        wip_start_date = options.fetch(:include_wip_pacts_since)
+
+        wip_pact_publications_by_branch = remove_already_verified_by_branch(
+          PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_branch,
+          provider,
+          provider_version_branch
+        )
+
+        wip_pact_publications_by_tag = remove_already_verified_by_branch(
+          PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_tag,
+          provider,
+          provider_version_branch
+        )
+
+        verifiable_pacts = (wip_pact_publications_by_branch + wip_pact_publications_by_tag).collect do | pact_publication |
+          selectors = create_selectors_for_wip_pact(pact_publication)
+          VerifiablePact.create_for_wip_for_provider_branch(pact_publication.to_domain, selectors, provider_version_branch)
+        end
+
+        deduplicate_verifiable_pacts(verifiable_pacts).sort
+      end
+
+      def find_all_pact_versions_for_provider_with_consumer_version_tags provider_name, selector
+        provider = pacticipant_repository.find_by_name(provider_name)
+        consumer = selector.consumer ? pacticipant_repository.find_by_name(selector.consumer) : nil
+
+        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))
+          .remove_overridden_revisions
+          .join_consumer_versions(:cv)
+          .join_consumer_version_tags_with_names(selector.tag)
+          .where(provider: provider)
+          .where_consumer_if_set(consumer)
+          .eager(:consumer)
+          .eager(:consumer_version)
+          .eager(:provider)
+          .eager(:pact_version)
+          .all
+          .group_by(&:pact_version_id)
+          .values
+          .collect do | pact_publications |
+            latest_pact_publication = pact_publications.sort_by{ |p| p.values.fetch(:consumer_version_order) }.last
+            SelectedPact.new(latest_pact_publication.to_domain, Selectors.new(selector).resolve(latest_pact_publication.consumer_version))
+          end
+      end
+
+      def remove_already_verified_by_branch(pact_publications, provider, provider_version_branch)
+        PactPublication.subtract(pact_publications.all, pact_publications.successfully_verified_by_provider_branch(provider.id, provider_version_branch).all)
+      end
+
+      def remove_already_verified_by_tag(pact_publications, query, provider, tag)
+        PactPublication.subtract(pact_publications, query.successfully_verified_by_provider_tag(provider.id, tag).all)
+      end
+    end
+  end
+end