pact_broker 2.38.1 → 2.39.0

data/lib/pact_broker/index/service.rb

@@ -13,51 +13,41 @@ module PactBroker
       extend PactBroker::Services
       extend PactBroker::Logging
 
+      # This method provides data for both the OSS server side rendered index (with and without tags)
+      # 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 = {}
         rows = PactBroker::Matrix::HeadRow
           .select_all_qualified
           .eager(:latest_triggered_webhooks)
           .eager(:webhooks)
 
-        rows = rows.consumer(options[:consumer_name]) if options[:consumer_name]
-        rows = rows.provider(options[:provider_name]) if options[:provider_name]
-
         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)
+                      .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 |
-          # The concept of "stale" (the pact used to be verified but then it changed and we haven't got
-          # a new verification result yet) only really make sense if we're trying to summarise
-          # the latest state of an integration. Once we start showing multiple pacts for each
-          # integration (ie. the latest for each tag) then each pact version is either verified,
-          # or it's not verified.
-          # For backwards compatiblity with the existing UI, don't change the 'stale' concept for the OSS
-          # UI - just ensure we don't use it for the new dashboard endpoint with the consumer/provider specified.
-          latest_verification = if options[:dashboard]
-            row.latest_verification_for_pact_version
-          else
-            row.latest_verification_for_pseudo_branch
-          end
-
           # TODO simplify. Do we really need 3 layers of abstraction?
           PactBroker::Domain::IndexItem.create(
             row.consumer,
             row.provider,
             row.pact,
             row.overall_latest?,
-            latest_verification,
+            row.latest_verification_for_pseudo_branch,
             row.webhooks,
             row.latest_triggered_webhooks,
             options[:tags] ? row.consumer_head_tag_names : [],
@@ -65,6 +55,34 @@ module PactBroker
           )
         end
       end
+
+      def self.find_index_items_for_api(consumer_name: nil, provider_name: nil, **ignored)
+        rows = PactBroker::Matrix::HeadRow
+          .eager(:consumer_version_tags)
+          .eager(:provider_version_tags)
+          .select_all_qualified
+
+        rows = rows.consumer(consumer_name) if consumer_name
+        rows = rows.provider(provider_name) if provider_name
+
+        rows = rows.all.group_by(&:pact_publication_id).values.collect{ | rows| Matrix::AggregatedRow.new(rows) }
+
+        rows.sort.collect do | row |
+          # TODO separate this model from IndexItem
+          # webhook status not currently displayed in Pactflow UI, so don't query for it.
+          PactBroker::Domain::IndexItem.create(
+            row.consumer,
+            row.provider,
+            row.pact,
+            row.overall_latest?,
+            row.latest_verification_for_pact_version,
+            [],
+            [],
+            row.consumer_head_tag_names,
+            row.provider_version_tags.select(&:latest?)
+          )
+        end
+      end
     end
   end
 end

data/lib/pact_broker/integrations/integration.rb

@@ -1,10 +1,26 @@
 require 'pact_broker/db'
+require 'pact_broker/verifications/pseudo_branch_status'
+require 'pact_broker/domain/verification'
 
 module PactBroker
   module Integrations
     class Integration < Sequel::Model
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
       associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
+      associate(:one_to_one, :latest_pact, :class => "PactBroker::Pacts::LatestPactPublications", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
+      associate(:one_to_one, :latest_verification, :class => "PactBroker::Verifications::LatestVerificationForConsumerAndProvider", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
+
+      def verification_status_for_latest_pact
+        @verification_status_for_latest_pact ||= PactBroker::Verifications::PseudoBranchStatus.new(latest_pact, latest_pact&.latest_verification)
+      end
+
+      def latest_pact_or_verification_publication_date
+        [latest_pact.created_at, latest_verification_publication_date].compact.max
+      end
+
+      def latest_verification_publication_date
+        latest_verification&.execution_date
+      end
     end
   end
 end

data/lib/pact_broker/integrations/service.rb

@@ -11,7 +11,21 @@ module PactBroker
       include PactBroker::Logging
 
       def self.find_all
-        PactBroker::Integrations::Integration.eager(:consumer).eager(:provider).all
+        # The only reason the pact_version needs to be loaded is that
+        # the Verification::PseudoBranchStatus uses it to determine if
+        # the pseudo branch is 'stale'.
+        # Because this is the status for a pact, and not a pseudo branch,
+        # the status can never be 'stale',
+        # so it would be better to create a Verification::PactStatus class
+        # that doesn't have the 'stale' logic in it.
+        # Then we can remove the eager loading of the pact_version
+        PactBroker::Integrations::Integration
+          .eager(:consumer)
+          .eager(:provider)
+          .eager(latest_pact: [:latest_verification, :pact_version])
+          .eager(:latest_verification)
+          .all
+          .sort { | a, b| b.latest_pact_or_verification_publication_date <=> a.latest_pact_or_verification_publication_date }
       end
 
       def self.delete(consumer_name, provider_name)

data/lib/pact_broker/matrix/can_i_deploy_query_schema.rb

@@ -0,0 +1,25 @@
+require 'dry-validation'
+
+module PactBroker
+  module Api
+    module Contracts
+      class CanIDeployQuerySchema
+        SCHEMA = Dry::Validation.Schema do
+          required(:pacticipant).filled(:str?)
+          required(:version).filled(:str?)
+          optional(:to).filled(:str?)
+        end
+
+        def self.call(params)
+          select_first_message(SCHEMA.call(params).messages(full: true))
+        end
+
+        def self.select_first_message(messages)
+          messages.each_with_object({}) do | (key, value), new_messages |
+            new_messages[key] = [value.first]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/parse_can_i_deploy_query.rb

@@ -0,0 +1,29 @@
+require 'rack/utils'
+
+module PactBroker
+  module Matrix
+    class ParseCanIDeployQuery
+      def self.call params
+        selector = {}
+        options = {
+          latestby: 'cvp',
+          latest: true
+        }
+
+        if params[:pacticipant].is_a?(String)
+          selector[:pacticipant_name] = params[:pacticipant]
+        end
+
+        if params[:version].is_a?(String)
+          selector[:pacticipant_version_number] = params[:version]
+        end
+
+        if params[:to].is_a?(String)
+          options[:tag] = params[:to]
+        end
+
+        return [selector], options
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/quick_row.rb

@@ -0,0 +1,255 @@
+=begin
+The Matrix::Row is based on the matrix view which does a join of every pact/verification
+and then selects the relevant ones.
+
+The Matrix::QuickRow starts with the relevant rows, and builds the matrix query from that,
+making it much quicker.
+
+=end
+require 'sequel'
+require 'pact_broker/repositories/helpers'
+require 'pact_broker/logging'
+require 'pact_broker/pacts/pact_version'
+require 'pact_broker/domain/pacticipant'
+require 'pact_broker/domain/version'
+require 'pact_broker/domain/verification'
+require 'pact_broker/pacts/pact_publication'
+require 'pact_broker/tags/tag_with_latest_flag'
+
+module PactBroker
+  module Matrix
+    LV = :latest_verification_id_for_pact_version_and_provider_version
+    LP = :latest_pact_publication_ids_for_consumer_versions
+
+    CONSUMER_COLUMNS = [Sequel[:lp][:consumer_id], Sequel[:consumers][:name].as(:consumer_name), Sequel[:lp][:pact_publication_id], Sequel[:lp][:pact_version_id]]
+    PROVIDER_COLUMNS = [Sequel[:lp][:provider_id], Sequel[:providers][:name].as(:provider_name), Sequel[:lv][:verification_id]]
+    CONSUMER_VERSION_COLUMNS = [Sequel[:lp][:consumer_version_id], Sequel[:cv][:number].as(:consumer_version_number), Sequel[:cv][:order].as(:consumer_version_order)]
+    PROVIDER_VERSION_COLUMNS = [Sequel[:lv][:provider_version_id], Sequel[:pv][:number].as(:provider_version_number), Sequel[:pv][:order].as(:provider_version_order)]
+    ALL_COLUMNS = CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS
+
+    LP_LV_JOIN = { Sequel[:lp][:pact_version_id] => Sequel[:lv][:pact_version_id] }
+    CONSUMER_JOIN = { Sequel[:lp][:consumer_id] => Sequel[:consumers][:id] }
+    PROVIDER_JOIN = { Sequel[:lp][:provider_id] => Sequel[:providers][:id] }
+    CONSUMER_VERSION_JOIN = { Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id] }
+    PROVIDER_VERSION_JOIN = { Sequel[:lv][:provider_version_id] => Sequel[:pv][:id] }
+
+    RAW_QUERY = Sequel::Model.db[Sequel.as(LP, :lp)]
+      .select(*ALL_COLUMNS)
+      .left_outer_join(LV, LP_LV_JOIN, { table_alias: :lv } )
+      .join(:pacticipants, CONSUMER_JOIN, { table_alias: :consumers })
+      .join(:pacticipants, PROVIDER_JOIN, { table_alias: :providers })
+      .join(:versions, CONSUMER_VERSION_JOIN, { table_alias: :cv })
+      .left_outer_join(:versions, PROVIDER_VERSION_JOIN, { table_alias: :pv } )
+
+    ALIASED_QUERY = Sequel.as(RAW_QUERY, :smart_rows)
+
+    class QuickRow < Sequel::Model(ALIASED_QUERY)
+      CONSUMER_ID = Sequel[:smart_rows][:consumer_id]
+      PROVIDER_ID = Sequel[:smart_rows][:provider_id]
+      CONSUMER_VERSION_ID = Sequel[:smart_rows][:consumer_version_id]
+      PROVIDER_VERSION_ID = Sequel[:smart_rows][:provider_version_id]
+      PACT_PUBLICATION_ID = Sequel[:smart_rows][:pact_publication_id]
+      VERIFICATION_ID = Sequel[:smart_rows][:verification_id]
+
+      associate(:many_to_one, :pact_publication, :class => "PactBroker::Pacts::PactPublication", :key => :pact_publication_id, :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, :provider_version, :class => "PactBroker::Domain::Version", :key => :provider_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, :verification, class: "PactBroker::Domain::Verification", :key => :verification_id, :primary_key => :id)
+      associate(:one_to_many, :consumer_version_tags, :class => "PactBroker::Tags::TagWithLatestFlag", primary_key: :consumer_version_id, key: :version_id)
+      associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Tags::TagWithLatestFlag", primary_key: :provider_version_id, key: :version_id)
+
+      dataset_module do
+        include PactBroker::Repositories::Helpers
+        include PactBroker::Logging
+
+        def consumer_id consumer_id
+          where(CONSUMER_ID => consumer_id)
+        end
+
+        def matching_selectors selectors
+          if selectors.size == 1
+            where_consumer_or_provider_is(selectors.first)
+          else
+            where_consumer_and_provider_in(selectors)
+          end
+        end
+
+        # find rows where (the consumer (and optional version) matches any of the selectors)
+        # AND
+        # the (provider (and optional version) matches any of the selectors OR the provider matches
+        #      and the verification is missing (and hence the provider version is null))
+        def where_consumer_and_provider_in selectors
+          where{
+            Sequel.&(
+              Sequel.|(
+                *QueryHelper.consumer_and_maybe_consumer_version_match_any_selector(selectors)
+              ),
+              Sequel.|(
+                *QueryHelper.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
+              ),
+              QueryHelper.either_consumer_or_provider_was_specified_in_query(selectors)
+            )
+          }
+        end
+
+        # Can't access other dataset_module methods from inside the Sequel `where{ ... }` block, so make a private class
+        # with some helper methods
+        class QueryHelper
+          def self.consumer_and_maybe_consumer_version_match_any_selector(selectors)
+            selectors.collect { |s| consumer_and_maybe_consumer_version_match_selector(s) }
+          end
+
+          def self.consumer_and_maybe_consumer_version_match_selector(s)
+            if s[:pact_publication_ids]
+              Sequel.&(PACT_PUBLICATION_ID => s[:pact_publication_ids])
+            elsif s[:pacticipant_version_id]
+              Sequel.&(CONSUMER_ID => s[:pacticipant_id], CONSUMER_VERSION_ID => s[:pacticipant_version_id])
+            else
+              Sequel.&(CONSUMER_ID => s[:pacticipant_id])
+            end
+          end
+
+          def self.provider_and_maybe_provider_version_match_selector(s)
+            if s[:verification_ids]
+              Sequel.&(VERIFICATION_ID => s[:verification_ids])
+            elsif s[:pacticipant_version_id]
+              Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => s[:pacticipant_version_id])
+            else
+              Sequel.&(PROVIDER_ID => s[:pacticipant_id])
+            end
+          end
+
+          # if the pact for a consumer version has never been verified, it exists in the matrix as a row
+          # with a blank provider version id
+          def self.provider_verification_is_missing_for_matching_selector(s)
+            Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => nil)
+          end
+
+          def self.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
+            selectors.collect { |s|
+              provider_and_maybe_provider_version_match_selector(s)
+            } + selectors.collect { |s|
+              provider_verification_is_missing_for_matching_selector(s)
+            }
+          end
+
+          # Some selecters are specified in the query, others are implied (when only one pacticipant is specified,
+          # the integrations are automatically worked out, and the selectors for these are of type :implied )
+          # When there are 3 pacticipants that each have dependencies on each other (A->B, A->C, B->C), the query
+          # to deploy C (implied A, implied B, specified C) was returning the A->B row because it matched the
+          # implied selectors as well.
+          # This extra filter makes sure that every row that is returned actually matches one of the specified
+          # selectors.
+          def self.either_consumer_or_provider_was_specified_in_query(selectors)
+            specified_pacticipant_ids = selectors.select{ |s| s[:type] == :specified }.collect{ |s| s[:pacticipant_id] }
+            Sequel.|({ CONSUMER_ID => specified_pacticipant_ids } , { PROVIDER_ID => specified_pacticipant_ids })
+          end
+        end
+
+        def where_consumer_or_provider_is s
+          where{
+            Sequel.|(
+              s[:pacticipant_version_id] ? Sequel.&(CONSUMER_ID => s[:pacticipant_id], CONSUMER_VERSION_ID => s[:pacticipant_version_id]) :  Sequel.&(CONSUMER_ID => s[:pacticipant_id]),
+              s[:pacticipant_version_id] ? Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => s[:pacticipant_version_id]) :  Sequel.&(PROVIDER_ID => s[:pacticipant_id])
+            )
+          }
+        end
+
+        def order_by_names_ascending_most_recent_first
+          order(
+            Sequel.asc(:consumer_name),
+            Sequel.desc(:consumer_version_order),
+            Sequel.asc(:provider_name),
+            Sequel.desc(:provider_version_order),
+            Sequel.desc(:verification_id))
+        end
+
+        def eager_all_the_things
+          eager(:consumer)
+          .eager(:provider)
+          .eager(:consumer_version)
+          .eager(:provider_version)
+          .eager(:verification)
+          .eager(:pact_publication)
+          .eager(:pact_version)
+        end
+
+      end
+
+      def success
+        verification&.success
+      end
+
+      def pact_version_sha
+        pact_version.sha
+      end
+
+      def pact_revision_number
+        pact_publication.revision_number
+      end
+
+      def verification_number
+        verification&.number
+      end
+
+      def success
+        verification&.success
+      end
+
+      def pact_created_at
+        pact_publication.created_at
+      end
+
+      def verification_executed_at
+        verification.execution_date
+      end
+
+      # Add logic for ignoring case
+      def <=> other
+        comparisons = [
+          compare_name_asc(consumer_name, other.consumer_name),
+          compare_number_desc(consumer_version_order, other.consumer_version_order),
+          compare_number_desc(pact_revision_number, other.pact_revision_number),
+          compare_name_asc(provider_name, other.provider_name),
+          compare_number_desc(provider_version_order, other.provider_version_order),
+          compare_number_desc(verification_id, other.verification_id)
+        ]
+
+        comparisons.find{|c| c != 0 } || 0
+      end
+
+      def compare_name_asc name1, name2
+        name1 <=> name2
+      end
+
+      def to_s
+        "#{consumer_name} v#{consumer_version_number} #{provider_name} #{provider_version_number} #{success}"
+      end
+
+      def compare_number_desc number1, number2
+        if number1 && number2
+          number2 <=> number1
+        elsif number1
+          1
+        else
+          -1
+        end
+      end
+
+      def eql?(obj)
+        (obj.class == model) && (obj.values == values)
+      end
+
+      def pacticipant_names
+        [consumer_name, provider_name]
+      end
+
+      def involves_pacticipant_with_name?(pacticipant_name)
+        pacticipant_name.include?(pacticipant_name)
+      end
+    end
+  end
+end