pact_broker 2.77.0 → 2.80.0

data/lib/pact_broker/matrix/repository.rb

@@ -1,16 +1,16 @@
-require 'pact_broker/repositories/helpers'
-require 'pact_broker/matrix/row'
-require 'pact_broker/matrix/quick_row'
-require 'pact_broker/matrix/every_row'
-require 'pact_broker/matrix/head_row'
-require 'pact_broker/error'
-require 'pact_broker/matrix/query_results'
-require 'pact_broker/matrix/integration'
-require 'pact_broker/matrix/query_results_with_deployment_status_summary'
-require 'pact_broker/matrix/resolved_selector'
-require 'pact_broker/matrix/unresolved_selector'
-require 'pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version'
-require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+require "pact_broker/repositories/helpers"
+require "pact_broker/matrix/row"
+require "pact_broker/matrix/quick_row"
+require "pact_broker/matrix/every_row"
+require "pact_broker/matrix/head_row"
+require "pact_broker/error"
+require "pact_broker/matrix/query_results"
+require "pact_broker/matrix/integration"
+require "pact_broker/matrix/query_results_with_deployment_status_summary"
+require "pact_broker/matrix/resolved_selector"
+require "pact_broker/matrix/unresolved_selector"
+require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
+require "pact_broker/pacts/latest_pact_publications_by_consumer_version"
 
 module PactBroker
   module Matrix
@@ -29,6 +29,7 @@ module PactBroker
       GROUP_BY_PROVIDER = [:consumer_name, :consumer_version_number, :provider_name]
       GROUP_BY_PACT = [:consumer_name, :provider_name]
 
+      # rubocop: disable Metrics/CyclomaticComplexity
       def find_ids_for_pacticipant_names params
         criteria  = {}
 
@@ -52,51 +53,62 @@ module PactBroker
         criteria[:tag_name] = params[:tag_name] if params[:tag_name].is_a?(String) # Could be a sym from resource parameters in api.rb
         criteria
       end
+      # rubocop: enable Metrics/CyclomaticComplexity
 
       # Return the latest matrix row (pact/verification) for each consumer_version_number/provider_version_number
       def find specified_selectors, options = {}
-        resolved_specified_selectors = resolve_versions_and_add_ids(specified_selectors, :specified)
+        resolved_ignore_selectors = resolve_ignore_selectors(options)
+        resolved_specified_selectors = resolve_versions_and_add_ids(specified_selectors, :specified, resolved_ignore_selectors)
         integrations = find_integrations_for_specified_selectors(resolved_specified_selectors, infer_selectors_for_integrations?(options))
-        resolved_selectors = if infer_selectors_for_integrations?(options)
-          resolved_specified_selectors + inferred_selectors(resolved_specified_selectors, integrations, options)
-        else
-          resolved_specified_selectors
-        end
-
-        all_lines = query_matrix(resolved_selectors, options)
-        lines = apply_latestby(options, all_lines)
-
-        # This needs to be done after the latestby, so can't be done in the db unless
-        # the latestby logic is moved to the db
-        if options.key?(:success)
-          lines = lines.select{ |l| options[:success].include?(l.success) }
-        end
-
-        QueryResults.new(lines.sort, specified_selectors, options, resolved_selectors, integrations)
+        resolved_selectors = add_any_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
+        considered_rows, ignored_rows = find_considered_and_ignored_rows(resolved_selectors, resolved_ignore_selectors, options)
+        QueryResults.new(considered_rows.sort, ignored_rows.sort, specified_selectors, options, resolved_selectors, resolved_ignore_selectors, integrations)
       end
 
       def find_for_consumer_and_provider pacticipant_1_name, pacticipant_2_name
         selectors = [ UnresolvedSelector.new(pacticipant_name: pacticipant_1_name), UnresolvedSelector.new(pacticipant_name: pacticipant_2_name)]
-        options = { latestby: 'cvpv' }
+        options = { latestby: "cvpv" }
         find(selectors, options)
       end
 
-      def find_compatible_pacticipant_versions selectors
-        find(selectors, latestby: 'cvpv').select(&:success)
+      private
+
+      def find_considered_and_ignored_rows(resolved_selectors, resolved_ignore_selectors, options)
+        rows = query_matrix(resolved_selectors, options)
+        rows = apply_latestby(options, rows)
+        rows = apply_success_filter(rows, options)
+        considered_rows, ignored_rows = split_rows_into_considered_and_ignored(rows, resolved_ignore_selectors)
+        return considered_rows, ignored_rows
       end
 
       def find_integrations_for_specified_selectors(resolved_specified_selectors, infer_integrations)
         specified_pacticipant_names = resolved_specified_selectors.collect(&:pacticipant_name)
-        QuickRow
+        base_model_for_integrations
           .distinct_integrations(resolved_specified_selectors, infer_integrations)
           .collect(&:to_hash)
-          .collect do | hash |
-            required = is_a_row_for_this_integration_required?(specified_pacticipant_names, hash[:consumer_name])
-            Integration.from_hash(hash.merge(required: required))
+          .collect do | integration_hash |
+            required = is_a_row_for_this_integration_required?(specified_pacticipant_names, integration_hash[:consumer_name])
+            Integration.from_hash(integration_hash.merge(required: required))
           end
       end
 
-      private
+      def add_any_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
+        if infer_selectors_for_integrations?(options)
+          resolved_specified_selectors + inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
+        else
+          resolved_specified_selectors
+        end
+      end
+
+      def apply_success_filter(rows_with_latest_by_applied, options)
+        # This needs to be done after the latestby, so can't be done in the db unless
+        # the latestby logic is moved to the db
+        if options.key?(:success)
+          rows_with_latest_by_applied.select{ |l| options[:success].include?(l.success) }
+         else
+           rows_with_latest_by_applied
+        end
+      end
 
       # If a specified pacticipant is a consumer, then its provider is required to be deployed
       # to the same environment before the consumer can be deployed.
@@ -106,22 +118,24 @@ module PactBroker
         specified_pacticipant_names.include?(consumer_name)
       end
 
+      # rubocop: disable Metrics/CyclomaticComplexity
       # It would be nicer to do this in the SQL, but it requires time that I don't have at the moment
       def apply_latestby options, lines
         return lines unless options[:latestby]
         group_by_columns = case options[:latestby]
-        when 'cvpv' then GROUP_BY_PROVIDER_VERSION_NUMBER
-        when 'cvp' then GROUP_BY_PROVIDER
-        when 'cp' then GROUP_BY_PACT
-        end
+                           when "cvpv" then GROUP_BY_PROVIDER_VERSION_NUMBER
+                           when "cvp" then GROUP_BY_PROVIDER
+                           when "cp" then GROUP_BY_PACT
+                           end
 
         # 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.
         lines.group_by{|line| group_by_columns.collect{|key| line.send(key) }}
           .values
-          .collect{ | lines | lines.first.provider_version_number.nil? ? lines : lines.sort_by(&:provider_version_order).last }
+          .collect{ | line | line.first.provider_version_number.nil? ? line : line.sort_by(&:provider_version_order).last }
           .flatten
       end
+      # rubocop: enable Metrics/CyclomaticComplexity
 
       def query_matrix selectors, options
         query = base_model(options).select_all_columns
@@ -132,24 +146,36 @@ module PactBroker
         query.eager_all_the_things.all
       end
 
-      def base_model(options)
+      def base_model(options = {})
         options[:latestby] ? QuickRow : EveryRow
       end
 
+      def resolve_ignore_selectors(options)
+        resolve_versions_and_add_ids(options.fetch(:ignore_selectors, []), :ignored)
+      end
+
+      # To make it easy for pf to override
+      def base_model_for_integrations
+        QuickRow
+      end
+
       # Find the version number for selectors with the latest and/or tag specified
-      def resolve_versions_and_add_ids(selectors, selector_type)
-        selectors.collect do | selector |
-          pacticipant = PactBroker::Domain::Pacticipant.find(name: selector.pacticipant_name)
-          versions = find_versions_for_selector(selector)
-          build_resolved_selectors(pacticipant, versions, selector, selector_type)
+      def resolve_versions_and_add_ids(unresolved_selectors, selector_type, resolved_ignore_selectors = [])
+        unresolved_selectors.collect do | unresolved_selector |
+          pacticipant = PactBroker::Domain::Pacticipant.find(name: unresolved_selector.pacticipant_name)
+          if pacticipant
+            versions = find_versions_for_selector(unresolved_selector)
+            build_resolved_selectors(pacticipant, versions, unresolved_selector, selector_type, resolved_ignore_selectors)
+          else
+            selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+          end
         end.flatten
       end
 
       def find_versions_for_selector(selector)
         # For selectors that just set the pacticipant name, there's no need to resolve the version -
         # only the pacticipant ID will be used in the query
-        return nil unless (selector.tag || selector.latest || selector.pacticipant_version_number)
-
+        return nil if selector.all_for_pacticipant?
         versions = version_repository.find_versions_for_selector(selector)
 
         if selector.latest
@@ -161,53 +187,98 @@ module PactBroker
 
       # When a single selector specifies multiple versions (eg. "all prod pacts"), this expands
       # the single selector into one selector for each version.
-      def build_resolved_selectors(pacticipant, versions, original_selector, selector_type)
+      def build_resolved_selectors(pacticipant, versions, unresolved_selector, selector_type, resolved_ignore_selectors)
         if versions
+          one_of_many = versions.compact.size > 1
           versions.collect do | version |
             if version
-              selector_for_version(pacticipant, version, original_selector, selector_type)
+              selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many, resolved_ignore_selectors)
             else
-              selector_for_non_existing_version(pacticipant, original_selector, selector_type)
+              selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
             end
           end
         else
-          selector_without_version(pacticipant, selector_type)
+          selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
         end
       end
 
       def infer_selectors_for_integrations?(options)
-        options[:latest] || options[:tag]
+        options[:latest] || options[:tag] || options[:branch] || options[:environment_name]
       end
 
       # When only one selector is specified, (eg. checking to see if Foo version 2 can be deployed to prod),
       # need to look up all integrated pacticipants, and determine their relevant (eg. latest prod) versions
-      def inferred_selectors(resolved_specified_selectors, integrations, options)
+      def inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
         all_pacticipant_names = integrations.collect(&:pacticipant_names).flatten.uniq
         specified_names = resolved_specified_selectors.collect{ |s| s[:pacticipant_name] }
         inferred_pacticipant_names = all_pacticipant_names - specified_names
-        build_inferred_selectors(inferred_pacticipant_names, options)
+        build_inferred_selectors(inferred_pacticipant_names, resolved_ignore_selectors, options)
       end
 
-      def build_inferred_selectors(inferred_pacticipant_names, options)
+      def build_inferred_selectors(inferred_pacticipant_names, resolved_ignore_selectors, options)
         selectors = inferred_pacticipant_names.collect do | pacticipant_name |
           selector = UnresolvedSelector.new(pacticipant_name: pacticipant_name)
           selector.tag = options[:tag] if options[:tag]
+          selector.branch = options[:branch] if options[:branch]
           selector.latest = options[:latest] if options[:latest]
+          selector.environment_name = options[:environment_name] if options[:environment_name]
           selector
         end
-        resolve_versions_and_add_ids(selectors, :inferred)
+        resolve_versions_and_add_ids(selectors, :inferred, resolved_ignore_selectors)
       end
 
-      def selector_for_non_existing_version(pacticipant, original_selector, selector_type)
-        ResolvedSelector.for_pacticipant_and_non_existing_version(pacticipant, original_selector, selector_type)
+      def selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
+        ignore = resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && s.only_pacticipant_name_specified?
+        end
+        ResolvedSelector.for_pacticipant_and_non_existing_version(pacticipant, unresolved_selector, selector_type, ignore)
       end
 
-      def selector_for_version(pacticipant, version, original_selector, selector_type)
-        ResolvedSelector.for_pacticipant_and_version(pacticipant, version, original_selector, selector_type)
+      # rubocop: disable Metrics/ParameterLists
+      def selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many, resolved_ignore_selectors)
+        ignore = resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == version.id)
+        end
+        ResolvedSelector.for_pacticipant_and_version(pacticipant, version, unresolved_selector, selector_type, ignore, one_of_many)
       end
+      # rubocop: enable Metrics/ParameterLists
 
-      def selector_without_version(pacticipant, selector_type)
-        ResolvedSelector.for_pacticipant(pacticipant, selector_type)
+      def selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
+        # Doesn't make sense to ignore this, as you can't have a can-i-deploy query
+        # for "all versions of a pacticipant". But whatever.
+        ignore = resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && s.only_pacticipant_name_specified?
+        end
+        ResolvedSelector.for_pacticipant(pacticipant, unresolved_selector, selector_type, ignore)
+      end
+
+      # only relevant for ignore selectors, validation stops this happening for the normal
+      # selectors
+      def selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+        ResolvedSelector.for_non_existing_pacticipant(unresolved_selector, selector_type, false)
+      end
+
+      def split_rows_into_considered_and_ignored(rows, resolved_ignore_selectors)
+        if resolved_ignore_selectors.any?
+          considered, ignored = [], []
+          rows.each do | row |
+            if ignore_row?(resolved_ignore_selectors, row)
+              ignored << row
+            else
+              considered << row
+            end
+          end
+          return considered, ignored
+        else
+          return rows, []
+        end
+      end
+
+      def ignore_row?(resolved_ignore_selectors, row)
+        resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == row.consumer_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.consumer_version_id) ||
+            s.pacticipant_id == row.provider_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.provider_version_id)
+        end
       end
     end
   end

data/lib/pact_broker/matrix/resolved_selector.rb

@@ -10,20 +10,34 @@ module PactBroker
       # A version ID of -1 will not match any rows, which is what we want to ensure that
       # no matrix rows are returned for a version that does not exist.
       NULL_VERSION_ID = -1
+      NULL_PACTICIPANT_ID = -1
 
       def initialize(params = {})
         merge!(params)
       end
 
-      def self.for_pacticipant(pacticipant, type)
+      def self.for_pacticipant(pacticipant, original_selector, type, ignore)
         ResolvedSelector.new(
           pacticipant_id: pacticipant.id,
           pacticipant_name: pacticipant.name,
-          type: type
+          type: type,
+          ignore: ignore,
+          original_selector: original_selector
         )
       end
 
-      def self.for_pacticipant_and_version(pacticipant, version, original_selector, type)
+      def self.for_non_existing_pacticipant(original_selector, type, ignore)
+        ResolvedSelector.new(
+          pacticipant_id: NULL_PACTICIPANT_ID,
+          pacticipant_name: original_selector[:pacticipant_name],
+          type: type,
+          ignore: ignore,
+          original_selector: original_selector
+        )
+      end
+
+      # rubocop: disable Metrics/ParameterLists
+      def self.for_pacticipant_and_version(pacticipant, version, original_selector, type, ignore, one_of_many = false)
         ResolvedSelector.new(
           pacticipant_id: pacticipant.id,
           pacticipant_name: pacticipant.name,
@@ -31,11 +45,17 @@ module PactBroker
           pacticipant_version_number: version.number,
           latest: original_selector[:latest],
           tag: original_selector[:tag],
-          type: type
+          branch: original_selector[:branch],
+          environment_name: original_selector[:environment_name],
+          type: type,
+          ignore: ignore,
+          one_of_many: one_of_many,
+          original_selector: original_selector
         )
       end
+      # rubocop: enable Metrics/ParameterLists
 
-      def self.for_pacticipant_and_non_existing_version(pacticipant, original_selector, type)
+      def self.for_pacticipant_and_non_existing_version(pacticipant, original_selector, type, ignore)
         ResolvedSelector.new(
           pacticipant_id: pacticipant.id,
           pacticipant_name: pacticipant.name,
@@ -43,10 +63,18 @@ module PactBroker
           pacticipant_version_number: original_selector[:pacticipant_version_number],
           latest: original_selector[:latest],
           tag: original_selector[:tag],
-          type: type
+          branch: original_selector[:branch],
+          environment_name: original_selector[:environment_name],
+          type: type,
+          ignore: ignore,
+          original_selector: original_selector
         )
       end
 
+      def pacticipant_version_specified_in_original_selector?
+        !!self.dig(:original_selector, :pacticipant_version_number)
+      end
+
       def pacticipant_id
         self[:pacticipant_id]
       end
@@ -71,6 +99,14 @@ module PactBroker
         self[:tag]
       end
 
+      def branch
+        self[:branch]
+      end
+
+      def environment_name
+        self[:environment_name]
+      end
+
       def most_specific_criterion
         if pacticipant_version_id
           { pacticipant_version_id: pacticipant_version_id }
@@ -80,13 +116,25 @@ module PactBroker
       end
 
       def only_pacticipant_name_specified?
-        pacticipant_name && !tag && !latest? && !pacticipant_version_number
+        !!pacticipant_name && !branch && !tag && !latest? && !pacticipant_version_number
       end
 
       def latest_tagged?
         latest? && tag
       end
 
+      def latest_from_branch?
+        latest? && branch
+      end
+
+      def pacticipant_or_version_does_not_exist?
+        pacticipant_does_not_exist? || version_does_not_exist?
+      end
+
+      def pacticipant_does_not_exist?
+        self[:pacticipant_id] == NULL_PACTICIPANT_ID
+      end
+
       def version_does_not_exist?
         !version_exists?
       end
@@ -114,11 +162,28 @@ module PactBroker
         self[:type] == :inferred
       end
 
+      def one_of_many?
+        self[:one_of_many]
+      end
+
+      def ignore?
+        self[:ignore]
+      end
+
+      def consider?
+        !ignore?
+      end
+
+      # rubocop: disable Metrics/CyclomaticComplexity
       def description
         if latest_tagged? && pacticipant_version_number
           "the latest version of #{pacticipant_name} with tag #{tag} (#{pacticipant_version_number})"
         elsif latest_tagged?
           "the latest version of #{pacticipant_name} with tag #{tag} (no such version exists)"
+        elsif latest_from_branch? && pacticipant_version_number
+          "the latest version of #{pacticipant_name} from branch #{branch} (#{pacticipant_version_number})"
+        elsif latest_from_branch?
+          "the latest version of #{pacticipant_name} from branch #{branch} (no such version exists)"
         elsif latest? && pacticipant_version_number
           "the latest version of #{pacticipant_name} (#{pacticipant_version_number})"
         elsif latest?
@@ -127,12 +192,22 @@ module PactBroker
           "a version of #{pacticipant_name} with tag #{tag} (#{pacticipant_version_number})"
         elsif tag
           "a version of #{pacticipant_name} with tag #{tag} (no such version exists)"
+        elsif environment_name && pacticipant_version_number
+          prefix = one_of_many? ? "one of the versions" : "the version"
+          "#{prefix} of #{pacticipant_name} currently deployed to #{environment_name} (#{pacticipant_version_number})"
+        elsif environment_name
+          "the version of #{pacticipant_name} currently deployed to #{environment_name} (no such version exists)"
+        elsif pacticipant_version_number && version_does_not_exist?
+          "version #{pacticipant_version_number} of #{pacticipant_name} (no such version exists)"
         elsif pacticipant_version_number
           "version #{pacticipant_version_number} of #{pacticipant_name}"
+        elsif pacticipant_does_not_exist?
+          "any version of #{pacticipant_name} (no such pacticipant exists)"
         else
           "any version of #{pacticipant_name}"
         end
       end
+      # rubocop: enable Metrics/CyclomaticComplexity
     end
   end
 end