pact_broker 2.38.1 → 2.39.0

data/lib/pact_broker/matrix/repository.rb

@@ -1,5 +1,6 @@
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/matrix/row'
+require 'pact_broker/matrix/quick_row'
 require 'pact_broker/matrix/head_row'
 require 'pact_broker/error'
 require 'pact_broker/matrix/query_results'
@@ -80,7 +81,7 @@ module PactBroker
       # If two or more are specified, just return the integrations that involve the specified pacticipants
       def find_integrations_for_specified_selectors(resolved_specified_selectors)
         specified_pacticipant_names = resolved_specified_selectors.collect(&:pacticipant_name)
-        Row
+        QuickRow
           .select(:consumer_name, :consumer_id, :provider_name, :provider_id)
           .matching_selectors(resolved_specified_selectors)
           .distinct
@@ -116,28 +117,15 @@ module PactBroker
 
         # The group with the nil provider_version_numbers will be the results of the left outer join
         # that don't have verifications, so we need to include them all.
-        remove_overwritten_revisions(lines).group_by{|line| group_by_columns.collect{|key| line.send(key) }}
+        lines.group_by{|line| group_by_columns.collect{|key| line.send(key) }}
           .values
           .collect{ | lines | lines.first.provider_version_number.nil? ? lines : lines.first }
           .flatten
       end
 
-      # It would be nicer to do this in the SQL, but it requires time that I don't have at the moment
-      def remove_overwritten_revisions lines
-        latest_revisions_keys = {}
-        latest_revisions = []
-        lines.each do | line |
-          key = "#{line.consumer_name}-#{line.provider_name}-#{line.consumer_version_number}"
-          if !latest_revisions_keys.key?(key) || latest_revisions_keys[key] == line.pact_revision_number
-            latest_revisions << line
-            latest_revisions_keys[key] ||= line.pact_revision_number
-          end
-        end
-        latest_revisions
-      end
-
       def query_matrix selectors, options
-        query = Row.select_all.matching_selectors(selectors)
+        query = options[:latestby] ? QuickRow.eager_all_the_things : Row
+        query = query.select_all.matching_selectors(selectors)
         query = query.limit(options[:limit]) if options[:limit]
         query
           .order_by_names_ascending_most_recent_first

data/lib/pact_broker/matrix/row.rb

@@ -7,7 +7,6 @@ require 'pact_broker/verifications/latest_verification_for_consumer_and_provider
 
 module PactBroker
   module Matrix
-
     class Row < Sequel::Model(:matrix)
 
       # Used when using table_print to output query results

data/lib/pact_broker/metrics/service.rb

@@ -8,6 +8,8 @@ require 'pact_broker/api/decorators/format_date_time'
 require 'pact_broker/webhooks/webhook'
 require 'pact_broker/webhooks/triggered_webhook'
 require 'pact_broker/webhooks/execution'
+require 'pact_broker/matrix/row'
+require 'pact_broker/matrix/head_row'
 
 module PactBroker
   module Metrics
@@ -32,10 +34,19 @@ module PactBroker
           pactVersions: {
             count: PactBroker::Pacts::PactVersion.count
           },
+          pactRevisionsPerConsumerVersion: {
+            distribution: pact_revision_counts
+          },
           verificationResults: {
             count: PactBroker::Domain::Verification.count,
-            first: format_date_time(PactBroker::Domain::Verification.order(:id).first.created_at),
-            last: format_date_time(PactBroker::Domain::Verification.order(:id).last.created_at)
+            successCount: PactBroker::Domain::Verification.where(success: true).count,
+            failureCount: PactBroker::Domain::Verification.where(success: false).count,
+            distinctCount: PactBroker::Domain::Verification.distinct.select(:provider_version_id, :pact_version_id, :success).count,
+            first: format_date_time(PactBroker::Domain::Verification.order(:id).first&.created_at),
+            last: format_date_time(PactBroker::Domain::Verification.order(:id).last&.created_at),
+          },
+          verificationResultsPerPactVersion: {
+            distribution: verification_distribution
           },
           pacticipantVersions: {
             count: PactBroker::Domain::Version.count
@@ -48,9 +59,32 @@ module PactBroker
           },
           webhookExecutions: {
             count: PactBroker::Webhooks::Execution.count
+          },
+          matrix: {
+            count: PactBroker::Matrix::Row.count
+          },
+          headMatrix: {
+            count: PactBroker::Matrix::HeadRow.count
           }
         }
       end
+
+      def pact_revision_counts
+        query = "select revision_count as number_of_revisions, count(consumer_version_id) as consumer_version_count
+          from (select consumer_version_id, count(*) as revision_count from pact_publications group by consumer_version_id) foo
+          group by revision_count
+          order by 1"
+        PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_revisions]] = row[:consumer_version_count] }
+      end
+
+#
+      def verification_distribution
+        query = "select verification_count as number_of_verifications, count(*) as pact_version_count
+          from (select pact_version_id, count(*) as verification_count from verifications group by pact_version_id) foo
+          group by verification_count
+          order by 1"
+          PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_verifications]] = row[:pact_version_count] }
+      end
     end
   end
 end

data/lib/pact_broker/pacts/all_pact_publications.rb

@@ -6,7 +6,6 @@ require 'pact_broker/repositories/helpers'
 
 module PactBroker
   module Pacts
-
     class AllPactPublications < Sequel::Model(:all_pact_publications)
 
       extend Forwardable
@@ -16,6 +15,7 @@ module PactBroker
       set_primary_key :id
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :reciprocal => :version, :key => :version_id, :primary_key => :consumer_version_id)
       associate(:many_to_one, :pact_version, :key => :pact_version_id, :primary_key => :id)
+      associate(:many_to_one, :latest_verification, :class => "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_id)
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -102,7 +102,8 @@ module PactBroker
           revision_number: revision_number,
           pact_version_sha: pact_version_sha,
           created_at: created_at,
-          head_tag_names: head_tag_names)
+          head_tag_names: head_tag_names,
+          db_model: self)
       end
 
       def head_tag_names

data/lib/pact_broker/pacts/head_pact.rb

@@ -0,0 +1,30 @@
+require 'delegate'
+
+# A head pact is the pact for the latest consumer version with the specified tag
+# (ignoring later versions that might have the specified tag but no pact)
+
+module PactBroker
+  module Pacts
+    class HeadPact < SimpleDelegator
+      attr_reader :tag, :consumer_version_number
+
+      def initialize(pact, consumer_version_number, tag)
+        super(pact)
+        @consumer_version_number = consumer_version_number
+        @tag = tag
+      end
+
+      # The underlying pact publication may well be the overall latest as well, but
+      # this row does not know that, as there will be a row with a nil tag
+      # if it is the overall latest as well as a row with the
+      # tag set, as the data is denormalised in the LatestTaggedPactPublications table.
+      def overall_latest?
+        tag.nil?
+      end
+
+      def pact
+        __getobj__()
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/latest_pact_publications.rb

@@ -1,12 +1,19 @@
 require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+require 'pact_broker/pacts/head_pact'
 
 module PactBroker
   module Pacts
 
+    # latest pact for each consumer/provider pair
     class LatestPactPublications < LatestPactPublicationsByConsumerVersion
       set_dataset(:latest_pact_publications)
-    end
 
+      # This pact may well be the latest for certain tags, but in this query
+      # we don't know what they are
+      def to_domain
+        HeadPact.new(super, consumer_version_number, nil)
+      end
+    end
   end
 end
 

data/lib/pact_broker/pacts/latest_tagged_pact_publications.rb

@@ -1,12 +1,16 @@
 require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+require 'pact_broker/pacts/head_pact'
 
 module PactBroker
   module Pacts
 
     class LatestTaggedPactPublications < LatestPactPublicationsByConsumerVersion
       set_dataset(:latest_tagged_pact_publications)
-    end
 
+      def to_domain
+        HeadPact.new(super, consumer_version_number, tag_name)
+      end
+    end
   end
 end
 

data/lib/pact_broker/pacts/pact_publication.rb

@@ -57,7 +57,8 @@ module PactBroker
           pact_version_sha: pact_version.sha,
           latest_verification: latest_verification,
           created_at: created_at,
-          head_tag_names: head_tag_names
+          head_tag_names: head_tag_names,
+          db_model: self
           )
       end
 

data/lib/pact_broker/pacts/pact_version.rb

@@ -50,6 +50,26 @@ module PactBroker
         latest_consumer_version.number
       end
 
+      def select_provider_tags_with_successful_verifications(tags)
+        tags.select do | tag |
+          PactVersion.where(Sequel[:pact_versions][:id] => id)
+            .join(:verifications, Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id])
+            .join(:versions, Sequel[:versions][:id] => Sequel[:verifications][:provider_version_id])
+            .join(:tags, Sequel[:tags][:version_id] => Sequel[:versions][:id])
+            .where(Sequel[:tags][:name] => tag)
+            .where(Sequel[:verifications][:success] => true)
+            .any?
+        end
+      end
+
+      def verified_successfully_by_any_provider_version?
+        PactVersion.where(Sequel[:pact_versions][:id] => id)
+          .join(:verifications, Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id])
+          .join(:versions, Sequel[:versions][:id] => Sequel[:verifications][:provider_version_id])
+          .where(Sequel[:verifications][:success] => true)
+          .any?
+      end
+
       def upsert
         self.class.upsert(to_hash, [:consumer_id, :provider_id, :sha])
       end

data/lib/pact_broker/pacts/repository.rb

@@ -12,6 +12,7 @@ require 'pact_broker/domain'
 require 'pact_broker/pacts/parse'
 require 'pact_broker/matrix/head_row'
 require 'pact_broker/pacts/latest_pact_publication_id_by_consumer_version'
+require 'pact_broker/pacts/verifiable_pact'
 
 module PactBroker
   module Pacts
@@ -124,10 +125,30 @@ module PactBroker
         end
       end
 
-      def find_pending_pact_versions_for_provider provider_name
-        provider_id = pacticipant_repository.find_by_name(provider_name).id
-        pact_publication_ids = PactBroker::Matrix::HeadRow.where(provider_id: provider_id).exclude(success: true).select_for_subquery(:pact_publication_id)
-        AllPactPublications.where(id: pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order).collect(&:to_domain)
+      def find_wip_pact_versions_for_provider provider_name, provider_tags = []
+        return [] if provider_tags.empty?
+        successfully_verified_pact_publication_ids_for_each_tag = provider_tags.collect do | provider_tag |
+          ids = LatestTaggedPactPublications
+            .join(:verifications, { pact_version_id: :pact_version_id })
+            .join(:tags, { Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id] }, {table_alias: :provider_tags})
+            .where(Sequel[:provider_tags][:name] => provider_tag)
+            .provider(provider_name)
+            .where(Sequel[:verifications][:success] => true)
+            .select(Sequel[:latest_tagged_pact_publications][:id].as(:id))
+            .collect(&:id)
+          [provider_tag, ids]
+        end
+
+        successfully_verified_pact_publication_ids_for_all_tags = successfully_verified_pact_publication_ids_for_each_tag.collect(&:last).reduce(:&)
+        pact_publication_ids = LatestTaggedPactPublications.provider(provider_name).exclude(id: successfully_verified_pact_publication_ids_for_all_tags).select_for_subquery(:id)
+
+        pacts = AllPactPublications.where(id: pact_publication_ids).order_ignore_case(:consumer_name).order_append(:consumer_version_order).collect(&:to_domain)
+        pacts.collect do | pact|
+          pending_tags = successfully_verified_pact_publication_ids_for_each_tag.select do | (provider_tag, pact_publication_ids) |
+           !pact_publication_ids.include?(pact.id)
+          end.collect(&:first)
+          VerifiablePact.new(pact, true, pending_tags, [], pact.consumer_version_tag_names)
+        end
       end
 
       def find_pact_versions_for_provider provider_name, tag = nil
@@ -263,6 +284,14 @@ module PactBroker
         end
       end
 
+      # Returns a list of Domain::Pact objects the represent pact publications
+      def find_for_verification(provider_name, consumer_version_selectors)
+        latest_tags = consumer_version_selectors.any? ?
+          consumer_version_selectors.select(&:latest).collect(&:tag) :
+          nil
+        find_latest_pact_versions_for_provider(provider_name, latest_tags)
+      end
+
       private
 
       def find_previous_distinct_pact_by_sha pact

data/lib/pact_broker/pacts/service.rb

@@ -2,6 +2,8 @@ require 'pact_broker/repositories'
 require 'pact_broker/services'
 require 'pact_broker/logging'
 require 'pact_broker/pacts/merger'
+require 'pact_broker/pacts/verifiable_pact'
+require 'pact_broker/pacts/squash_pacts_for_verification'
 
 module PactBroker
   module Pacts
@@ -12,6 +14,7 @@ module PactBroker
       extend PactBroker::Repositories
       extend PactBroker::Services
       include PactBroker::Logging
+      extend SquashPactsForVerification
 
       def find_latest_pact params
         pact_repository.find_latest_pact(params[:consumer_name], params[:provider_name], params[:tag])
@@ -80,8 +83,8 @@ module PactBroker
         pact_repository.find_latest_pact_versions_for_provider provider_name, options[:tag]
       end
 
-      def find_pending_pact_versions_for_provider provider_name
-        pact_repository.find_pending_pact_versions_for_provider provider_name
+      def find_wip_pact_versions_for_provider provider_name
+        pact_repository.find_wip_pact_versions_for_provider provider_name
       end
 
       def find_pact_versions_for_provider provider_name, options = {}
@@ -110,6 +113,16 @@ module PactBroker
         distinct
       end
 
+      def find_for_verification(provider_name, provider_version_tags, consumer_version_selectors)
+        pact_repository
+          .find_for_verification(provider_name, consumer_version_selectors)
+          .group_by(&:pact_version_sha)
+          .values
+          .collect do | head_pacts |
+            squash_pacts_for_verification(provider_version_tags, head_pacts)
+          end
+      end
+
       private
 
       # Overwriting an existing pact with the same consumer/provider/consumer version number

data/lib/pact_broker/pacts/squash_pacts_for_verification.rb

@@ -0,0 +1,37 @@
+# All of these pacts have the same underlying pact_version_sha (content)
+# No point verifying them multiple times, so squash all the relevant info into one
+# "verifiable pact"
+
+module PactBroker
+  module Pacts
+    module SquashPactsForVerification
+      def self.call(provider_version_tags, head_pacts)
+        domain_pact = head_pacts.first.pact
+        pending_provider_tags = []
+        pending = nil
+        if provider_version_tags.any?
+          pending_provider_tags = domain_pact.select_pending_provider_version_tags(provider_version_tags)
+          pending = pending_provider_tags.any?
+        else
+          pending = domain_pact.pending?
+        end
+
+        non_pending_provider_tags = provider_version_tags - pending_provider_tags
+
+        head_consumer_tags = head_pacts.collect(&:tag)
+        overall_latest = head_consumer_tags.include?(nil)
+        VerifiablePact.new(domain_pact,
+          pending,
+          pending_provider_tags,
+          non_pending_provider_tags,
+          head_consumer_tags.compact,
+          overall_latest
+        )
+      end
+
+      def squash_pacts_for_verification(*args)
+        SquashPactsForVerification.call(*args)
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/verifiable_pact.rb

@@ -0,0 +1,30 @@
+require 'delegate'
+
+module PactBroker
+  module Pacts
+    class VerifiablePact < SimpleDelegator
+      attr_reader :pending, :pending_provider_tags, :non_pending_provider_tags, :head_consumer_tags
+
+      def initialize(pact, pending, pending_provider_tags = [], non_pending_provider_tags = [], head_consumer_tags = [], overall_latest = false)
+        super(pact)
+        @pending = pending
+        @pending_provider_tags = pending_provider_tags
+        @non_pending_provider_tags = non_pending_provider_tags
+        @head_consumer_tags = head_consumer_tags
+        @overall_latest = overall_latest
+      end
+
+      def consumer_tags
+        head_consumer_tags
+      end
+
+      def overall_latest?
+        @overall_latest
+      end
+
+      def pending?
+        pending
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/verifiable_pact_messages.rb

@@ -0,0 +1,75 @@
+module PactBroker
+  module Pacts
+    class VerifiablePactMessages
+      extend Forwardable
+
+      READ_MORE = "Read more at https://pact.io/pending"
+
+      delegate [:consumer_name, :provider_name, :head_consumer_tags, :pending_provider_tags, :non_pending_provider_tags, :pending?] => :verifiable_pact
+
+      def initialize(verifiable_pact)
+        @verifiable_pact = verifiable_pact
+      end
+
+      def inclusion_reason
+        if head_consumer_tags.any?
+          version_text = head_consumer_tags.size == 1 ? "version" : "versions"
+          "This pact is being verified because it is the pact for the latest #{version_text} of Foo tagged with #{joined_head_consumer_tags}"
+        else
+          "This pact is being verified because it is the latest pact between #{consumer_name} and #{provider_name}."
+        end
+      end
+
+      def pending_reason
+        if pending?
+          "This pact is in pending state because it has not yet been successfully verified by #{pending_provider_tags_description}. If this verification fails, it will not cause the overall build to fail. #{READ_MORE}"
+        else
+          "This pact has previously been successfully verified by #{non_pending_provider_tags_description}. If this verification fails, it will fail the build. #{READ_MORE}"
+        end
+      end
+
+      private
+
+      attr_reader :verifiable_pact
+
+      def join(list, last_joiner = " and ")
+        quoted_list = list.collect { | tag | "'#{tag}'" }
+        comma_joined = quoted_list[0..-3] || []
+        and_joined =  quoted_list[-2..-1] || quoted_list
+        if comma_joined.any?
+          "#{comma_joined.join(', ')}, #{and_joined.join(last_joiner)}"
+        else
+          and_joined.join(last_joiner)
+        end
+      end
+
+      def joined_head_consumer_tags
+        join(head_consumer_tags) + same_content_note
+      end
+
+      def same_content_note
+        case head_consumer_tags.size
+        when 1 then ""
+        when 2 then " (both have the same content)"
+        else " (all have the same content)"
+        end
+      end
+
+      def pending_provider_tags_description
+        case pending_provider_tags.size
+        when 0 then provider_name
+        when 1 then "any version of #{provider_name} with tag '#{pending_provider_tags.first}'"
+        else "any versions of #{provider_name} with tag #{join(pending_provider_tags)}"
+        end
+      end
+
+      def non_pending_provider_tags_description
+        case non_pending_provider_tags.size
+        when 0 then provider_name
+        when 1 then "a version of #{provider_name} with tag '#{non_pending_provider_tags.first}'"
+        else "a version of #{provider_name} with tag #{join(non_pending_provider_tags)}"
+        end
+      end
+    end
+  end
+end