pact_broker 2.107.1 → 2.108.0

data/lib/pact_broker/matrix/matrix_row_verification_dataset_module.rb

@@ -0,0 +1,83 @@
+#
+# The dataset methods to be included in the MatrixRow::Verification dataset module
+# and the EveryRow::Verification dataset module.
+# Expects the method `select_verification_columns_with_aliases` to be defined on the class
+#
+module PactBroker
+  module Matrix
+    module MatrixRowVerificationDatasetModule
+      # Verifications for the provider versions matching the given selectors, where the consumers match the pacticipants in the given selectors.
+      # @public
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] selectors
+      # @return [Sequel::Dataset<MatrixRow>]
+      def matching_only_selectors_as_provider(resolved_selectors)
+        [
+          matching_only_selectors_as_provider_where_only_pacticipant_name_in_selector(resolved_selectors),
+          matching_only_selectors_as_provider_where_not_only_pacticipant_name_in_selector(resolved_selectors)
+        ].compact.reduce(&:union)
+      end
+
+      # @public
+      # @return [Sequel::Dataset<Verification>, nil]
+      def matching_selectors_as_provider_for_any_consumer(resolved_selectors)
+        select_verification_columns_with_aliases
+          .inner_join_versions_for_selectors_as_provider(resolved_selectors)
+      end
+
+      # Return verifications where the provider is described by any of the resolved_selectors *that only specify the pacticipant NAME*,
+      # AND the consumer is described by any of the resolved selectors.
+      # If the original selector only specified the pacticipant name, we don't need to join to the versions table to identify the required verifications.
+      # Return nil if there are no resolved selectors where only the pacticipant name is specified.
+      # @private
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      # @return [Sequel::Dataset<Verification>, nil]
+      def matching_only_selectors_as_provider_where_only_pacticipant_name_in_selector(resolved_selectors)
+        all_pacticipant_ids = resolved_selectors.collect(&:pacticipant_id).uniq
+        pacticipant_ids_for_pacticipant_only_selectors = resolved_selectors.select(&:only_pacticipant_name_specified?).collect(&:pacticipant_id).uniq
+
+        if pacticipant_ids_for_pacticipant_only_selectors.any?
+          select_verification_columns_with_aliases
+            .where(provider_id: pacticipant_ids_for_pacticipant_only_selectors)
+            .where(consumer_id: all_pacticipant_ids)
+        end
+      end
+
+      # Return verifications where the provider *version* is described by any of the resolved_selectors
+      # *that specify more than just the pacticipant name*,
+      # AND the consumer is described by any of the resolved selectors.
+      # If the selector uses any of the tag/branch/environment/latest attributes, we need to join to the versions table to identify the required verifications.
+      # Return nil if there are no resolved selectors where anything other than the pacticipant name is specified.
+      # @private
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      # @return [Sequel::Dataset<Verification>, nil]
+      def matching_only_selectors_as_provider_where_not_only_pacticipant_name_in_selector(resolved_selectors)
+        # get the UnresolvedSelector objects back out of the resolved_selectors because the Version.for_selector() method uses the UnresolvedSelector
+        all_pacticipant_ids = resolved_selectors.collect(&:pacticipant_id).uniq
+        resolved_selectors_with_versions_specified = resolved_selectors.reject(&:only_pacticipant_name_specified?)
+
+        if resolved_selectors_with_versions_specified.any?
+          select_verification_columns_with_aliases
+            .inner_join_versions_for_selectors_as_provider(resolved_selectors_with_versions_specified)
+            .where(consumer_id: all_pacticipant_ids)
+        end
+      end
+
+      # Don't think it's worth splitting this into 2 different queries for selectors with only pacticipant name/selectors with version properties,
+      # as it's unlikely for there ever to be a query through the UI or CLI that results in 1 selector which only has a pacticipant name in it.
+      # @private
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      # @return [Sequel::Dataset<Verification>]
+      def inner_join_versions_for_selectors_as_provider(resolved_selectors)
+        # get the UnresolvedSelector objects back out of the resolved_selectors because the Version.for_selector() method uses the UnresolvedSelector
+        unresolved_selectors = resolved_selectors.collect(&:original_selector).uniq
+        versions = PactBroker::Domain::Version.ids_for_selectors(unresolved_selectors)
+        join_versions_dataset(versions)
+      end
+
+      # @private
+      def join_versions_dataset(versions_dataset)
+        join(versions_dataset, { Sequel[self.model.table_name][:provider_version_id] => Sequel[:versions][:id] }, table_alias: :versions)
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/parse_query.rb

@@ -26,6 +26,7 @@ module PactBroker
           options[:latestby] = params["latestby"]
         end
 
+        # Don't think this is used anywhere...
         if params.key?("days") && params["days"] != ""
           options[:days] = params["days"].to_i
         end

data/lib/pact_broker/matrix/repository.rb

@@ -1,71 +1,50 @@
-require "pact_broker/logging"
-require "pact_broker/repositories/helpers"
-require "pact_broker/matrix/quick_row"
+require "pact_broker/matrix/matrix_row"
 require "pact_broker/matrix/every_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/matrix/integrations_repository"
+require "pact_broker/matrix/resolved_selectors_builder"
+require "pact_broker/matrix/row_ignorer"
+require "pact_broker/matrix/integrations_repository"
 
 module PactBroker
   module Matrix
-
-    class Error < PactBroker::Error; end
-
     class Repository
-      include PactBroker::Repositories::Helpers
       include PactBroker::Repositories
-      include PactBroker::Logging
-
-      # TODO move latest verification logic in to database
 
       # Used when using table_print to output query results
       TP_COLS = [ :consumer_version_number, :pact_revision_number, :provider_version_number, :verification_number]
 
-      GROUP_BY_PROVIDER_VERSION_NUMBER = [:consumer_name, :consumer_version_number, :provider_name, :provider_version_number]
-      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  = {}
-
-        if params[:consumer_name] || params[:provider_name]
-          if params[:consumer_name]
-            pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:consumer_name])).single_record
-            criteria[:consumer_id] = pacticipant.id if pacticipant
-          end
-
-          if params[:provider_name]
-            pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:provider_name])).single_record
-            criteria[:provider_id] = pacticipant.id if pacticipant
-          end
-        end
-
-        if params[:pacticipant_name]
-          pacticipant = PactBroker::Domain::Pacticipant.where(name_like(:name, params[:pacticipant_name])).single_record
-          criteria[:pacticipant_id] = pacticipant.id if pacticipant
-        end
-
-        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_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, options)
-        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
+      GROUP_BY_CONSUMER_VERSION_AND_PROVIDER_VERSION = [:consumer_name, :consumer_version_number, :provider_name, :provider_version_number]
+      GROUP_BY_CONSUMER_VERSION_AND_PROVIDER = [:consumer_name, :consumer_version_number, :provider_name]
+      GROUP_BY_CONSUMER_AND_PROVIDER = [:consumer_name, :provider_name]
+
+      # THE METHOD for querying the Matrix
+      # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_specified_selectors
+      # @param [Hash] options
+      def find(unresolved_specified_selectors, options = {})
+        infer_selectors = infer_selectors_for_integrations?(options)
+        resolved_selectors_builder = ResolvedSelectorsBuilder.new
+        resolved_selectors_builder.resolve_selectors(unresolved_specified_selectors, options.fetch(:ignore_selectors, []))
+        integrations = matrix_integration_repository.find_integrations_for_specified_selectors(resolved_selectors_builder.specified_selectors, infer_selectors)
+        resolved_selectors_builder.resolve_inferred_selectors(integrations, options) if infer_selectors
+
+        considered_rows, ignored_rows = find_considered_and_ignored_rows(resolved_selectors_builder.all_selectors, resolved_selectors_builder.ignore_selectors, options)
+        QueryResults.new(
+          considered_rows.sort,
+          ignored_rows.sort,
+          unresolved_specified_selectors,
+          options,
+          resolved_selectors_builder.all_selectors,
+          resolved_selectors_builder.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" }
         find(selectors, options)
@@ -73,88 +52,26 @@ module PactBroker
 
       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
+      def matrix_integration_repository
+        PactBroker::Matrix::IntegrationsRepository.new
       end
 
-      def find_integrations_for_specified_selectors(resolved_specified_selectors, options)
-        if infer_selectors_for_integrations?(options)
-          find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors)
-        else
-          find_integrations_for_specified_selectors_only(resolved_specified_selectors)
-        end
-      end
-
-      def find_integrations_for_specified_selectors_only(resolved_specified_selectors)
-        specified_pacticipant_names = resolved_specified_selectors.collect(&:pacticipant_name)
-        base_model_for_integrations
-          .distinct_integrations(resolved_specified_selectors, false)
-          .collect(&:to_hash)
-          .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
-
-      def find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors)
-        integrations = integrations_where_specified_selector_is_consumer(resolved_specified_selectors) +
-                        integrations_where_specified_selector_is_provider(resolved_specified_selectors)
-        deduplicate_integrations(integrations)
-      end
-
-      def integrations_where_specified_selector_is_consumer(resolved_specified_selectors)
-        resolved_specified_selectors.flat_map do | selector |
-          base_model_for_integrations
-            .distinct_integrations_for_selector_as_consumer(selector)
-            .all
-            .collect do | integration |
-              Integration.from_hash(
-                consumer_id: integration[:consumer_id],
-                consumer_name: integration[:consumer_name],
-                provider_id: integration[:provider_id],
-                provider_name: integration[:provider_name],
-                required: true # synchronous consumer requires the provider to be present
-              )
-            end
-        end
-      end
-
-      # Why does the consumer equivalent of this method use the QuickRow distinct_integrations_for_selector_as_consumer
-      # while this method uses the Integration?
-      def integrations_where_specified_selector_is_provider(resolved_specified_selectors)
-        integrations_involving_specified_providers = PactBroker::Integrations::Integration
-                                                      .where(provider_id: resolved_specified_selectors.collect(&:pacticipant_id))
-                                                      .eager(:consumer, :provider)
-                                                      .all
-
-        integrations_involving_specified_providers.collect do | integration |
-          Integration.from_hash(
-            consumer_id: integration.consumer.id,
-            consumer_name: integration.consumer.name,
-            provider_id: integration.provider.id,
-            provider_name: integration.provider.name,
-            required: false # synchronous provider does not require the consumer to be present
-          )
-        end
-      end
-
-      def deduplicate_integrations(integrations)
-        integrations
-          .group_by{ | integration| [integration.consumer_id, integration.provider_id] }
-          .values
-          .collect { | duplicate_integrations | duplicate_integrations.find(&:required?) || duplicate_integrations.first }
+      # If the user has specified --to TAG or --to-environment ENVIRONMENT in the CLI
+      # (or nothing, which to defaults to latest=true - "with the latest version of the other integrated applications")
+      # we need to work out what the integrations are between the specified selectors and the other pacticipant versions
+      # in the target environment/branches/tags.
+      # @param [Hash] options the matrix options
+      # @return [Boolean]
+      def infer_selectors_for_integrations?(options)
+        options[:latest] || !!options[:tag] || !!options[:branch] || !!options[:environment_name] || options[:main_branch]
       end
 
-      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
+      def find_considered_and_ignored_rows(all_resolved_selectors, resolved_ignore_selectors, options)
+        rows = query_matrix(all_resolved_selectors, options)
+        rows = apply_latestby(options, rows)
+        rows = apply_success_filter(rows, options)
+        considered_rows, ignored_rows = RowIgnorer.split_rows_into_considered_and_ignored(rows, resolved_ignore_selectors)
+        return considered_rows, ignored_rows
       end
 
       def apply_success_filter(rows_with_latest_by_applied, options)
@@ -167,36 +84,32 @@ module PactBroker
         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.
-      # If a specified pacticipant is a provider only, then it may be deployed
-      # without the consumer being present.
-      def is_a_row_for_this_integration_required?(specified_pacticipant_names, consumer_name)
-        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
+      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
+                           when "cvpv" then GROUP_BY_CONSUMER_VERSION_AND_PROVIDER_VERSION
+                           when "cvp" then GROUP_BY_CONSUMER_VERSION_AND_PROVIDER
+                           when "cp" then GROUP_BY_CONSUMER_AND_PROVIDER
                            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) }}
+
+        lines
+          .group_by{ |line| group_by_columns.collect{ |key| line.send(key) } }
           .values
-          .collect{ | line | line.first.provider_version_number.nil? ? line : line.sort_by(&:provider_version_order).last }
+          .collect { | grouped_lines |
+            grouped_lines.first.provider_version_number.nil? ? grouped_lines.first : grouped_lines.sort_by(&:provider_version_order).last
+          }
           .flatten
       end
       # rubocop: enable Metrics/CyclomaticComplexity
 
-      def query_matrix selectors, options
-        query = base_model(options).select_all_columns
-                  .matching_selectors(selectors)
+      def query_matrix(all_resolved_selectors, options)
+        query = base_model(options)
+                  .matching_selectors(all_resolved_selectors, limit: options[:limit])
                   .order_by_last_action_date
 
         query = query.limit(options[:limit]) if options[:limit]
@@ -204,143 +117,7 @@ module PactBroker
       end
 
       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(unresolved_selectors, selector_type, resolved_ignore_selectors = [])
-        names = unresolved_selectors.collect(&:pacticipant_name)
-        pacticipants = PactBroker::Domain::Pacticipant.where(name: names).to_a.group_by(&:name).transform_values(&:first)
-        unresolved_selectors.collect do | unresolved_selector |
-          pacticipant = pacticipants[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 if selector.all_for_pacticipant?
-        versions = version_repository.find_versions_for_selector(selector)
-
-        if selector.latest
-          [versions.first]
-        else
-          versions.empty? ? [nil] : versions
-        end
-      end
-
-      # 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, unresolved_selector, selector_type, resolved_ignore_selectors)
-        if versions
-          one_of_many = versions.compact.size > 1
-          versions.collect do | version |
-            if version
-              selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many, resolved_ignore_selectors)
-            else
-              selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
-            end
-          end
-        else
-          selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type, resolved_ignore_selectors)
-        end
-      end
-
-      # The user has specified --to TAG or --to-environment ENVIRONMENT in the CLI
-      # (or nothing, which to defaults to latest=true - "with the latest version of the other integrated applications")
-      def infer_selectors_for_integrations?(options)
-        options[:latest] || options[:tag] || options[:branch] || options[:environment_name] || options[:main_branch]
-      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, 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, resolved_ignore_selectors, options)
-      end
-
-      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.main_branch = options[:main_branch] if options[:main_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, resolved_ignore_selectors)
-      end
-
-      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
-
-      # 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_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
+        options[:latestby] ? MatrixRow : EveryRow
       end
     end
   end

data/lib/pact_broker/matrix/resolved_selector.rb

@@ -4,7 +4,9 @@ require "pact_broker/hash_refinements"
 # This is created from either specified or inferred data, based on the user's query
 # eg.
 # can-i-deploy --pacticipant Foo --version 1 (this is a specified selector)
-#              --to prod (this is used to create inferred selectors)
+#              --to prod (this is used to create inferred selectors, one for each integrated pacticipant in that environment)
+# When an UnresolvedSelector specifies multiple application versions (eg. { tag: "prod" }) then a ResolvedSelector
+# is created for every Version object found for the original selector.
 
 module PactBroker
   module Matrix
@@ -31,6 +33,9 @@ module PactBroker
         )
       end
 
+      # This is not possible for specified selectors, as there is validation at the HTTP query level to
+      # ensure that all pacticipants in the specified selectors exist.
+      # It is possible for the ignore selectors however.
       def self.for_non_existing_pacticipant(original_selector, type, ignore)
         ResolvedSelector.new(
           pacticipant_id: NULL_PACTICIPANT_ID,
@@ -187,16 +192,20 @@ module PactBroker
         !ignore?
       end
 
+      def original_selector
+        self[:original_selector]
+      end
+
       # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       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 main_branch? && pacticipant_version_number.nil?
-          "a version of #{pacticipant_name} from the main branch (no such version exists)"
         elsif latest_from_main_branch? && pacticipant_version_number.nil?
-          "the latest version of #{pacticipant_name} from the main branch (no such verison exists)"
+          "the latest version of #{pacticipant_name} from the main branch (no versions exist for this branch)"
+        elsif main_branch? && pacticipant_version_number.nil?
+          "any version of #{pacticipant_name} from the main branch (no versions exist for this branch)"
         elsif latest_from_branch? && pacticipant_version_number
           "the latest version of #{pacticipant_name} from branch #{branch} (#{pacticipant_version_number})"
         elsif latest_from_branch?

data/lib/pact_broker/matrix/resolved_selector_builder.rb

@@ -0,0 +1,84 @@
+# Builds a PactBroker::Matrix::UnresolvedSelector based on the given
+# UnresolvedSelector, selector type, Pacticipant and Version objects,
+# using the selector_ignorer to work out if the built ResolvedSelector
+# should be marked as ignored or not.
+
+module PactBroker
+  module Matrix
+    class ResolvedSelectorBuilder
+
+      attr_accessor :pacticipant, :versions
+
+      # @param [PactBroker::Matrix::UnresolvedSelector] unresolved_selector
+      # @param [Symbol] selector_type :specified or :inferred
+      # @param [PactBroker::Matrix::Ignorer] selector_ignorer
+      def initialize(unresolved_selector, selector_type, selector_ignorer)
+        @unresolved_selector = unresolved_selector
+        @selector_type = selector_type
+        @selector_ignorer = selector_ignorer
+      end
+
+      def build
+        if pacticipant && versions
+          build_resolved_selectors_for_versions(pacticipant, versions, unresolved_selector, selector_type)
+        elsif pacticipant
+          selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type)
+        else
+          build_selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+        end
+      end
+
+      private
+
+      attr_reader :unresolved_selector, :selector_type, :selector_ignorer
+
+      # When a single selector specifies multiple versions (eg. "all prod pacts"), this expands
+      # the single selector into one selector for each version.
+      # When a pacticipant is found, but there are no versions matching the selector,
+      # the versions array will be have a single item which is nil (`[nil]`).
+      # See PactBroker::Matrix::SelectorResolver#find_versions_for_selector
+      # There may be a better way to pass in this information.
+      def build_resolved_selectors_for_versions(pacticipant, versions, unresolved_selector, selector_type)
+        one_of_many = versions.compact.size > 1
+        versions.collect do | version |
+          if version
+            selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many)
+          else
+            selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type)
+          end
+        end
+      end
+
+      def selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type)
+        ignore = selector_ignorer.ignore_pacticipant?(pacticipant)
+        ResolvedSelector.for_pacticipant_and_non_existing_version(pacticipant, unresolved_selector, selector_type, ignore)
+      end
+
+      def selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many)
+        ResolvedSelector.for_pacticipant_and_version(
+          pacticipant,
+          version,
+          unresolved_selector,
+          selector_type,
+          selector_ignorer.ignore_pacticipant_version?(pacticipant, version),
+          one_of_many
+        )
+      end
+
+      def selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type)
+        ResolvedSelector.for_pacticipant(
+          pacticipant,
+          unresolved_selector,
+          selector_type,
+          selector_ignorer.ignore_pacticipant?(pacticipant)
+        )
+      end
+
+      # only relevant for ignore selectors, validation stops this happening for the normal
+      # selectors
+      def build_selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+        ResolvedSelector.for_non_existing_pacticipant(unresolved_selector, selector_type, false)
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/resolved_selectors_builder.rb

@@ -0,0 +1,39 @@
+require "pact_broker/matrix/selector_resolver"
+
+# Builds the array of ResolvedSelector objects using the
+# ignore selectors, the specified selectors, and the inferred integrations.
+
+module PactBroker
+  module Matrix
+    class ResolvedSelectorsBuilder
+      attr_reader :ignore_selectors, :specified_selectors, :inferred_selectors
+
+      def initialize
+        @inferred_selectors = []
+      end
+
+      # @param [Array<PactBroker::Matrix::UnresolvedSelector>]
+      # @param [Hash] options
+      def resolve_selectors(unresolved_specified_selectors, unresolved_ignore_selectors)
+        # must do this first because we need the ignore selectors to resolve the specified selectors
+        @ignore_selectors = SelectorResolver.resolved_ignore_selectors(unresolved_ignore_selectors)
+        @specified_selectors = SelectorResolver.resolve_specified_selectors(unresolved_specified_selectors, ignore_selectors)
+      end
+
+      # Use the given Integrations to work out what the selectors are for the versions that the versions for the specified
+      # selectors should be deployed with.
+      # eg. For `can-i-deploy --pacticipant Foo --version adfjkwejr --to-environment prod`, work out the selectors for the integrated application
+      # versions in the prod environment.
+      # @param [Array<PactBroker::Matrix::Integration>] integrations
+      def resolve_inferred_selectors(integrations, options)
+        @inferred_selectors = SelectorResolver.resolve_inferred_selectors(specified_selectors, ignore_selectors, integrations, options)
+      end
+
+      # All the resolved selectors to be used in the matrix query, specified and inferred (if any)
+      # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+      def all_selectors
+        specified_selectors + inferred_selectors
+      end
+    end
+  end
+end