pact_broker 2.107.1 → 2.108.0

data/lib/pact_broker/matrix/integration_row.rb

@@ -0,0 +1,95 @@
+# A Sequel model used for identifying potential and required integrations
+# between the versions described by the specified selectors
+# and other applications.
+# It is only meant to be used via the public dataset methods.
+
+module PactBroker
+  module Matrix
+    class IntegrationRow < Sequel::Model(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :p))
+      dataset_module do
+        select(:select_pacticipant_ids, Sequel[:p][:consumer_id], Sequel[:p][:provider_id])
+
+        # Return the distinct consumer/provider ids and names for the integrations which involve the given resolved selector
+        # in the role of consumer. The resolved selector must have a pacticipant_id, and may or may not have a pacticipant_version_id.
+        # @public
+        # @param [PactBroker::Matrix::ResolvedSelector] resolved_selector
+        # @return [Sequel::Dataset] for rows with consumer_id, consumer_name, provider_id and provider_name
+        def integrations_for_selector_as_consumer(resolved_selector)
+          select(:consumer_id, :provider_id)
+            .distinct
+            .where({ consumer_id: resolved_selector.pacticipant_id, consumer_version_id: resolved_selector.pacticipant_version_id }.compact)
+            .from_self(alias: :integrations)
+            .select(:consumer_id, :provider_id, Sequel[:consumers][:name].as(:consumer_name), Sequel[:providers][:name].as(:provider_name))
+            .join_consumers(:integrations, :consumers)
+            .join_providers(:integrations, :providers)
+        end
+
+        # Find all the integrations (consumer/provider pairs) that involve ONLY the given selectors.
+        # @public
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+        # @return [Sequel::Dataset] for rows with consumer_id, consumer_name, provider_id and provider_name
+        def distinct_integrations_between_given_selectors(resolved_selectors)
+          if resolved_selectors.size == 1
+            raise ArgumentError.new("Expected multiple selectors to be provided, but only received one #{selectors}")
+          end
+          query = pact_publications_matching_selectors_as_consumer(resolved_selectors)
+                    .select_pacticipant_ids
+                    .distinct
+
+          query.from_self(alias: :pacticipant_ids)
+            .select(
+              :consumer_id,
+              Sequel[:c][:name].as(:consumer_name),
+              :provider_id,
+              Sequel[:p][:name].as(:provider_name)
+            )
+            .join_consumers(:pacticipant_ids, :c)
+            .join_providers(:pacticipant_ids, :p)
+        end
+
+        # @public
+        def join_consumers qualifier = :p, table_alias = :consumers
+          join(
+            :pacticipants,
+            { Sequel[qualifier][:consumer_id] => Sequel[table_alias][:id] },
+            { table_alias: table_alias }
+          )
+        end
+
+        # @public
+        def join_providers qualifier = :p, table_alias = :providers
+          join(
+            :pacticipants,
+            { Sequel[qualifier][:provider_id] => Sequel[table_alias][:id] },
+            { table_alias: table_alias }
+          )
+        end
+
+        # @private
+        def pact_publications_matching_selectors_as_consumer(resolved_selectors)
+          pacticipant_ids = resolved_selectors.collect(&:pacticipant_id).uniq
+
+          self
+            .select_pacticipant_ids
+            .distinct
+            .inner_join_versions_for_selectors_as_consumer(resolved_selectors)
+            .where(provider_id: pacticipant_ids)
+        end
+
+        # @private
+        def inner_join_versions_for_selectors_as_consumer(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)
+          inner_join_versions_dataset(versions)
+        end
+
+        # @private
+        def inner_join_versions_dataset(versions)
+          versions_join = { Sequel[:p][:consumer_version_id] => Sequel[:versions][:id] }
+          join(versions, versions_join, table_alias: :versions)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/integrations_repository.rb

@@ -0,0 +1,133 @@
+require "pact_broker/matrix/integration_row"
+# A "find only" repository for the PactBroker::Matrix::Integration object.
+# The PactBroker::Matrix::Integration object is not a Sequel Model like the PactBroker::Integrations::Integration - it is built from the
+# matrix data specifically for a given matrix query, and as well as the consumer/provider attributes, it also
+# knows whether or not that particular depdency is required in the context of the specific matrix query.
+# eg. a HTTP consumer will always require that a provider is deployed, but a provider can be deployed if the consumer does not exist
+# in the given environment yet.
+# The "integrations for selectors" query is used to work out what what integrations are involved for a can-i-deploy query.
+
+module PactBroker
+  module Matrix
+    class IntegrationsRepository
+      # Find all the Integrations required for this query, using the options to determine whether to find
+      # the inferred integrations or not.
+      # The infer_selectors_for_integrations only makes a difference when there are multiple selectors.
+      # When it is false, then only integrations are returned that exist *between* the versions of
+      # the selectors. When it is true, then all integrations that involve any of the versions of the selectors
+      # are returned.
+      #
+      # eg.
+      # Foo v1 has verified contract with Bar v2
+      # Waffle v3 has verified contract with Bar v2
+      # Foo v1 has unverified contract with Frog
+      #
+      # With selectors Foo v1 and Bar v2, and infer_selectors_for_integrations false, the returned integrations are Foo/Bar
+      # With the same selectors and infer_selectors_for_integrations true, the returned integrations are Foo/Bar, Waffle/Bar and Foo/Frog.
+      #
+      # When there is a single selector, the result is exactly the same whether infer_selectors_for_integrations is true or false.
+      #
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_specified_selectors
+      # @param [Boolean] infer_selectors_for_integrations
+      # @return [Array<PactBroker::Matrix::Integration>]
+      def find_integrations_for_specified_selectors(resolved_specified_selectors, infer_selectors_for_integrations)
+        if infer_selectors_for_integrations || resolved_specified_selectors.size == 1
+          find_integrations_involving_any_specfied_selectors(resolved_specified_selectors).sort_by(&:pacticipant_names)
+        else
+          find_integrations_between_specified_selectors(resolved_specified_selectors).sort_by(&:pacticipant_names)
+        end
+      end
+
+      private
+
+      # Find the Integrations that only involve the versions from the selectors specifed in the query.
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_specified_selectors
+      # @return [Array<PactBroker::Matrix::Integration>]
+      def find_integrations_between_specified_selectors(resolved_specified_selectors)
+        specified_pacticipant_names = resolved_specified_selectors.collect(&:pacticipant_name)
+        IntegrationRow
+          .distinct_integrations_between_given_selectors(resolved_specified_selectors)
+          .all
+          .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
+
+      # Find all Integrations where any of the specified selectors are involved.
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_specified_selectors
+      # @return [Array<PactBroker::Matrix::Integration>]
+      def find_integrations_involving_any_specfied_selectors(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
+
+      # Find all the providers for the consumer versions specified in the query.
+      # We must identify the providers for the consumer *versions*, not just the *consumers* (via the integrations table)
+      # because the providers may change over time, as integrations get added and removed.
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] the resolved selectors that were specified in the query
+      # @return [Array<PactBroker::Matrix::Integration>]
+      def integrations_where_specified_selector_is_consumer(resolved_specified_selectors)
+        resolved_specified_selectors.flat_map do | selector |
+          # Could optimise this to all in one query, but it's a small gain
+          IntegrationRow
+            .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 # consumer requires the provider to be present
+              )
+            end
+        end
+      end
+
+      # Returns a list of *potential* integrations for the pacticipants in the selectors, where the pacticipant is a provider.
+      # Can't tell from the verifications table if a particular provider version has a consumer, as that is determined
+      # by what is deployed to the environment, not what is verified. By looking in the integration table, we can identify
+      # what consumers *may* be present in the target environment.
+      # Find all the consumers for the providers specified in the query. Does not take into consideration the provider version (not sure why).
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] the resolved selectors that were specified in the query
+      # @return [Array<PactBroker::Matrix::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 # provider does not require the consumer to be present
+          )
+        end
+      end
+
+      # Deduplicate a list of Integrations
+      # @param [Array<PactBroker::Matrix::Integration>] integrations
+      # @return [Array<PactBroker::Matrix::Integration>]
+      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 }
+      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, but cannot break an existing consumer.
+      def is_a_row_for_this_integration_required?(specified_pacticipant_names, consumer_name)
+        specified_pacticipant_names.include?(consumer_name)
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/matrix_row.rb

@@ -0,0 +1,88 @@
+require "pact_broker/dataset"
+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/domain/tag"
+require "pact_broker/pacts/pact_publication"
+require "pact_broker/matrix/matrix_row_dataset_module"
+require "pact_broker/matrix/matrix_row_instance_methods"
+require "pact_broker/matrix/matrix_row_verification_dataset_module"
+
+# The PactBroker::Matrix::MatrixRow represents a row in the table that is created when
+# the consumer versions are joined to the provider versions via the pacts and verifications tables,
+# aka "The Matrix". The difference between this class and the EveryRow class is that
+# the EveryRow class includes results for overridden pact verisons and verifications (used only when there is no latestby
+# set in the matrix query), where as the MatrixRow class only includes the latest pact for each consumer version,
+# and the latest verification for each provider version.
+
+module PactBroker
+  module Matrix
+    class MatrixRow < Sequel::Model(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :p))
+
+      class Verification < Sequel::Model(Sequel.as(:latest_verification_id_for_pact_version_and_provider_version, :v))
+        dataset_module do
+          select(:select_verification_columns_with_aliases,
+            Sequel[:v][:provider_version_id],
+            Sequel[:v][:verification_id],
+            Sequel[:v][:created_at].as(:provider_version_created_at),
+            Sequel[:v][:pact_version_id]
+          )
+
+          include PactBroker::Matrix::MatrixRowVerificationDatasetModule
+        end
+      end
+
+      PACT_COLUMNS_WITH_ALIASES = [
+        Sequel[:p][:consumer_id],
+        Sequel[:p][:provider_id],
+        Sequel[:p][:consumer_version_id],
+        Sequel[:p][:pact_publication_id],
+        Sequel[:p][:pact_version_id],
+        Sequel[:p][:created_at].as(:consumer_version_created_at),
+        Sequel[:p][:pact_publication_id].as(:pact_order)
+      ]
+
+      ALL_COLUMNS_AFTER_JOIN = [
+        Sequel[:p][:consumer_id],
+        Sequel[:p][:provider_id],
+        Sequel[:p][:consumer_version_id],
+        Sequel[:p][:pact_publication_id],
+        Sequel[:p][:pact_version_id],
+        Sequel[:p][:consumer_version_created_at],
+        Sequel[:p][:pact_order],
+        Sequel[:v][:verification_id],
+        Sequel[:v][:provider_version_id],
+        Sequel[:v][:provider_version_created_at]
+
+      ]
+
+      # Must be kept in sync with PactBroker::Matrix::EveryRow
+      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::Domain::Tag", primary_key: :consumer_version_id, key: :version_id)
+      associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Domain::Tag", primary_key: :provider_version_id, key: :version_id)
+
+      dataset_module do
+        include PactBroker::Dataset
+        include PactBroker::Matrix::MatrixRowDatasetModule
+
+        select(:select_pact_columns_with_aliases, *PACT_COLUMNS_WITH_ALIASES)
+        select(:select_all_columns_after_join, *ALL_COLUMNS_AFTER_JOIN)
+
+        # @private
+        def verification_dataset
+          MatrixRow::Verification
+        end
+      end
+
+      include PactBroker::Matrix::MatrixRowInstanceMethods
+    end
+  end
+end

data/lib/pact_broker/matrix/matrix_row_dataset_module.rb

@@ -0,0 +1,185 @@
+# The dataset methods used by both the MatrixRow and the EveryRow classes
+# Requires the following methods to be defined on the model
+#   - verification_dataset
+#   - select_pact_columns_with_aliases
+#   - select_all_columns_after_join
+
+module PactBroker
+  module Matrix
+    module MatrixRowDatasetModule
+      EAGER_LOADED_RELATIONSHIPS_FOR_VERSION = { current_deployed_versions: :environment, current_supported_released_versions: :environment, branch_versions: [:branch_head, :version, branch: :pacticipant] }
+      LAST_ACTION_DATE = Sequel.lit("CASE WHEN (provider_version_created_at IS NOT NULL AND provider_version_created_at > consumer_version_created_at) THEN provider_version_created_at ELSE consumer_version_created_at END").as(:last_action_date)
+
+      # The matrix query used to determine the final dataset
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      def matching_selectors(resolved_selectors, limit:)
+        if resolved_selectors.size == 1
+          matching_one_selector_for_either_consumer_or_provider(resolved_selectors, limit: limit)
+        else
+          matching_only_selectors_joining_verifications(resolved_selectors, limit: limit)
+        end
+      end
+
+      # @public
+      def order_by_last_action_date
+        from_self(alias: :unordered_rows).select(LAST_ACTION_DATE, Sequel[:unordered_rows].* ).order(Sequel.desc(:last_action_date), Sequel.desc(:pact_order), Sequel.desc(:verification_id))
+      end
+
+      # eager load tags?
+      # @public
+      def eager_all_the_things
+        eager(
+          :consumer,
+          :provider,
+          :verification,
+          :pact_publication,
+          :pact_version,
+          consumer_version: EAGER_LOADED_RELATIONSHIPS_FOR_VERSION,
+          provider_version: EAGER_LOADED_RELATIONSHIPS_FOR_VERSION,
+          consumer_version_tags: [:head_tag, { version: :pacticipant }],
+          provider_version_tags: [:head_tag, { version: :pacticipant }]
+        )
+      end
+
+      # Just for testing purposes
+      def default_scope
+        select_pact_columns_with_aliases
+          .from_self(alias: :p)
+          .left_outer_join_verifications
+          .select_all_columns_after_join
+      end
+
+      # PRIVATE METHODS
+
+      # Final matrix query with one selector (not the normal use case)
+      # When we have one selector, we need to join ALL the verifications to find out
+      # what integrations exist
+      # @private
+      def matching_one_selector_for_either_consumer_or_provider(resolved_selectors, limit: )
+        if resolved_selectors.size != 1
+          raise ArgumentError.new("Expected one selector to be provided, but received #{resolved_selectors.size}:  #{resolved_selectors}")
+        end
+
+        # consumer
+        pact_publication_matching_consumer = select_pact_columns_with_aliases.most_recent(limit).from_self(alias: :p).inner_join_versions_for_selectors_as_consumer(resolved_selectors)
+        rows_where_selector_matches_consumer = pact_publication_matching_consumer.left_outer_join_verifications.select_all_columns_after_join
+
+        # provider
+        verifications_matching_provider = verification_dataset.matching_selectors_as_provider_for_any_consumer(resolved_selectors)
+        rows_where_selector_matches_provider = select_pact_columns_with_aliases.most_recent(limit).from_self(alias: :p).inner_join_verifications_dataset(verifications_matching_provider).select_all_columns_after_join
+
+        # union
+        rows_where_selector_matches_consumer.union(rows_where_selector_matches_provider)
+      end
+
+      # Find the matrix rows
+      # When the user has specified multiple selectors, we only want to join the verifications for
+      # the specified selectors. This is because of the behaviour of the left outer join.
+      # Imagine a pact has been verified by a provider version that was NOT specified in the selectors.
+      # If we join all the verifications and THEN filter the rows to only show the versions specified
+      # in the selectors, we won't get a row for that pact, and hence, we won't
+      # know that it hasn't been verified by the provider version we're interested in.
+      # Instead, we need to filter the verifications dataset down to only the ones specified in the selectors first,
+      # and THEN join them to the pacts, so that we get a row for the pact with null provider version
+      # and verification fields.
+      # IDEA FOR OPTIMISATION - would it work to limit the pact_publications query and the verifications query to the limit of the overall query?
+      # @private
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      # @return [Sequel::Dataset<MatrixRow>]
+      def matching_only_selectors_joining_verifications(resolved_selectors, limit: )
+        pact_publications = matching_only_selectors_as_consumer(resolved_selectors, limit: limit)
+        verifications = verification_dataset.matching_only_selectors_as_provider(resolved_selectors)
+
+        specified_pacticipant_ids = resolved_selectors.select(&:specified?).collect(&:pacticipant_id).uniq
+
+        pact_publications
+          .from_self(alias: :p)
+          .select_all_columns_after_join
+          .left_outer_join_verifications_dataset(verifications)
+          .where(consumer_id: specified_pacticipant_ids).or(provider_id: specified_pacticipant_ids)
+      end
+
+      # Return pact publications where the consumer/consumer version is described by any of the resolved_selectors, AND the provider is described by any of the resolved selectors.
+      # @private
+      # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_selectors
+      # @return [Sequel::Dataset<MatrixRow>]
+      def matching_only_selectors_as_consumer(resolved_selectors, limit: )
+        [
+          matching_only_selectors_as_consumer_where_only_pacticipant_name_in_selector(resolved_selectors, limit: limit),
+          matching_only_selectors_as_consumer_where_not_only_pacticipant_name_in_selector(resolved_selectors, limit: limit),
+        ].compact.reduce(&:union)
+      end
+
+
+      # Return pact publications where the consumer is described by any of the resolved_selectors *that only specify the pacticipant NAME*, AND the provider 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 pact_publications.
+      # 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<MatrixRow>, nil]
+      def matching_only_selectors_as_consumer_where_only_pacticipant_name_in_selector(resolved_selectors, limit:)
+        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_pact_columns_with_aliases
+            .where(consumer_id: pacticipant_ids_for_pacticipant_only_selectors)
+            .where(provider_id: all_pacticipant_ids)
+            .most_recent(limit)
+        end
+      end
+
+      # Return pact publications where the consumer *version* is described by any of the resolved_selectors
+      # *that specify more than just the pacticipant name*,
+      # AND the provider 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 pact_publications.
+      # 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<MatrixRow>, nil]
+      def matching_only_selectors_as_consumer_where_not_only_pacticipant_name_in_selector(resolved_selectors, limit:)
+        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_pact_columns_with_aliases
+            .inner_join_versions_for_selectors_as_consumer(resolved_selectors_with_versions_specified)
+            .where(provider_id: all_pacticipant_ids)
+            .most_recent(limit)
+        end
+      end
+
+      # @private
+      def inner_join_versions_for_selectors_as_consumer(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)
+        inner_join_versions_dataset(versions)
+      end
+
+      # @private
+      def inner_join_versions_dataset(versions)
+        versions_join = { Sequel[:p][:consumer_version_id] => Sequel[:versions][:id] }
+        join(versions, versions_join, table_alias: :versions)
+      end
+
+      # @private
+      def left_outer_join_verifications
+        left_outer_join_verifications_dataset(verification_dataset.select_verification_columns_with_aliases)
+      end
+
+      def left_outer_join_verifications_dataset(verifications)
+        left_outer_join(verifications, { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }, { table_alias: :v } )
+      end
+
+      # @private
+      def inner_join_verifications_dataset(verifications_dataset)
+        join(verifications_dataset, { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }, { table_alias: :v } )
+      end
+
+      def most_recent(limit)
+        order(Sequel.desc(:created_at)).limit(limit)
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/matrix_row_instance_methods.rb

@@ -0,0 +1,150 @@
+# The instance methods
+module PactBroker
+  module Matrix
+    module MatrixRowInstanceMethods
+      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
+
+      def provider_version_id
+        # null when not verified
+        values[:provider_version_id]
+      end
+
+      def verification_id
+        # null when not verified
+        return_or_raise_if_not_set(:verification_id)
+      end
+
+      def consumer_name
+        consumer.name
+      end
+
+      def consumer_version_number
+        consumer_version.number
+      end
+
+      def consumer_version_branch_versions
+        consumer_version.branch_versions
+      end
+
+      def consumer_version_deployed_versions
+        consumer_version.current_deployed_versions
+      end
+
+      def consumer_version_released_versions
+        consumer_version.current_supported_released_versions
+      end
+
+      def consumer_version_order
+        consumer_version.order
+      end
+
+      def provider_name
+        provider.name
+      end
+
+      def provider_version_number
+        provider_version&.number
+      end
+
+      def provider_version_branch_versions
+        provider_version&.branch_versions || []
+      end
+
+      def provider_version_deployed_versions
+        provider_version&.current_deployed_versions || []
+      end
+
+      def provider_version_released_versions
+        provider_version&.current_supported_released_versions || []
+      end
+
+      def provider_version_order
+        provider_version&.order
+      end
+
+      def last_action_date
+        return_or_raise_if_not_set(:last_action_date)
+      end
+
+      def has_verification?
+        !!verification_id
+      end
+
+      # This model needs the verifications and pacticipants joined to it
+      # before it can be used, as it's not a "real" model.
+      def return_or_raise_if_not_set(key)
+        if values.key?(key)
+          values[key]
+        else
+          raise "Required table not joined"
+        end
+      end
+    end
+  end
+end