pact_broker 2.51.0 → 2.52.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565c8989eb13e279daeb24f881fd53d0c56d72676d6a9eecaecbb3c52f823fa9
-  data.tar.gz: 54f7d26ec49742622aeffc7d66b9ee7903718ae507671b1384283bdd6317f16c
+  metadata.gz: 9ac697acb622b83117ef653787076248bc6fc112a610b8534384483ee7bbec90
+  data.tar.gz: '09def84c04412f624739e75e5762452a5f16f8d01837b00b7728bc287c659a91'
 SHA512:
-  metadata.gz: 61ca9dfdbebf5faf32ab678e9e4ca9d4bad0604a2fdd0c69653820adb001647f74ec980620d7943b330f245a03b4e138df2ebd19ac49dadc0888a0e9dd1393fc
-  data.tar.gz: 47c0ca191417d87ac73ac99e61e1de1a11942f512f00c734c07bbd773e4d5ff373d13b2b640845dcd702d62876a6b661deeaa713220ce41c5a303a0d2c19e6da
+  metadata.gz: 2e7b3b8000991f4b4989ec1674d75c2b512605c8a7cc066ab101e8644163bfd2bba4a3a9d102e455e59c14649fbc250080b5d1498a46ac303663fbfc778b19c9
+  data.tar.gz: a5d00393a9237d10a27ea28b4cb4896b452957185db1ecee8a7ac6b0ef91c99dcf899024fa5ecd7949ee0fafab0128afd63a9e2f8146dbeabb22f6f01f4934c6

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+<a name="v2.52.0"></a>
+### v2.52.0 (2020-03-25)
+
+
+#### Features
+
+* **pact ui**
+  * update matrix URL to specify the latest provider version	 ([23b02c80](/../../commit/23b02c80))
+
+* **matrix ui**
+  * highlight rows with the same consumer/provider/consumer version/provider version	 ([99b36d50](/../../commit/99b36d50))
+
+* **matrix**
+  * speed up query for UI by reducing the number of joins and removing unncessary criteria (#332)	 ([9e5ea8be](/../../commit/9e5ea8be))
+
+* **pacts for verification**
+  * add validation to only allow consumer to be specified for 'all' versions for a tag	 ([b39ad193](/../../commit/b39ad193))
+  * update inclusion messages to specify consumer name when selecting all pacts for a given consumer	 ([fdff0c58](/../../commit/fdff0c58))
+  * support finding all pacts with a given tag for a specified consumer	 ([749e708d](/../../commit/749e708d))
+
+
+#### Bug Fixes
+
+* ensure requests for text/plain go to the API rather than the UI	 ([1cf28009](/../../commit/1cf28009))
+
+
 <a name="v2.51.0"></a>
 ### v2.51.0 (2020-03-11)
 

data/db/migrations/20200318_add_created_at_to_latest_pact_publications.rb

@@ -0,0 +1,9 @@
+Sequel.migration do
+  change do
+    # TODO
+    # alter_table(:latest_pact_publication_ids_for_consumer_versions) do
+    #   set_column_not_null(:created_at)
+    # end
+    add_column(:latest_pact_publication_ids_for_consumer_versions, :created_at, DateTime)
+  end
+end

data/db/migrations/20200319_add_created_at_to_latest_verifications.rb

@@ -0,0 +1,9 @@
+Sequel.migration do
+  change do
+    # TODO
+    # alter_table(:latest_verification_id_for_pact_version_and_provider_version) do
+    #   set_column_not_null(:created_at)
+    # end
+    add_column(:latest_verification_id_for_pact_version_and_provider_version, :created_at, DateTime)
+  end
+end

data/lib/pact_broker/api/contracts/dry_validation_predicates.rb

@@ -9,6 +9,10 @@ module PactBroker
         predicate(:date?) do |value|
           DateTime.parse(value) rescue false
         end
+
+        predicate(:not_blank?) do | value |
+          value && value.is_a?(String) && value.strip.size > 0
+        end
       end
     end
   end

data/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema.rb

@@ -13,6 +13,7 @@ module PactBroker
         SCHEMA = Dry::Validation.Schema do
           configure do
             predicates(DryValidationPredicates)
+            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
           end
           optional(:providerVersionTags).maybe(:array?)
           optional(:consumerVersionSelectors).each do
@@ -26,6 +27,7 @@ module PactBroker
               required(:tag).filled(:str?)
               optional(:latest).filled(included_in?: [true, false])
               optional(:fallbackTag).filled(:str?)
+              optional(:consumer).filled(:str?, :not_blank?)
 
               # rule(fallbackTagMustBeForLatest: [:fallbackTag, :latest]) do | fallback_tag, latest |
               #   fallback_tag.filled?.then(latest.eql?(true))
@@ -37,7 +39,30 @@ module PactBroker
         end
 
         def self.call(params)
-          select_first_message(flatten_indexed_messages(SCHEMA.call(params&.symbolize_keys).messages(full: true)))
+          symbolized_params = params&.symbolize_keys
+          results = select_first_message(flatten_indexed_messages(SCHEMA.call(symbolized_params).messages(full: true)))
+          add_cross_field_validation_errors(symbolized_params, results)
+          results
+        end
+
+        def self.add_cross_field_validation_errors(params, results)
+          # This is a ducking joke. Need to get rid of dry-validation
+          if params[:consumerVersionSelectors].is_a?(Array)
+            errors = []
+            params[:consumerVersionSelectors].each_with_index do | selector, index |
+              if selector[:fallbackTag] && !selector[:latest]
+                errors << "fallbackTag can only be set if latest is true (at index #{index})"
+              end
+
+              if selector[:consumer] && selector[:latest]
+                errors << "specifying a consumer with latest == true is not yet supported (at index #{index})"
+              end
+            end
+            if errors.any?
+              results[:consumerVersionSelectors] ||= []
+              results[:consumerVersionSelectors].concat(errors)
+            end
+          end
         end
       end
     end

data/lib/pact_broker/api/contracts/verifiable_pacts_query_schema.rb

@@ -12,6 +12,7 @@ module PactBroker
         SCHEMA = Dry::Validation.Schema do
           configure do
             predicates(DryValidationPredicates)
+            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
           end
           optional(:provider_version_tags).maybe(:array?)
           optional(:consumer_version_selectors).each do
@@ -19,6 +20,7 @@ module PactBroker
               required(:tag).filled(:str?)
               optional(:latest).filled(included_in?: ["true", "false"])
               optional(:fallback_tag).filled(:str?)
+              optional(:consumer).filled(:str?, :not_blank?)
             end
           end
           optional(:include_pending_status).filled(included_in?: ["true", "false"])

data/lib/pact_broker/api/decorators/matrix_text_decorator.rb

@@ -17,7 +17,7 @@ module PactBroker
         def to_text(options)
           json_decorator = PactBroker::Api::Decorators::MatrixDecorator.new(lines)
           data = lines.collect do | line |
-            Line.new(line[:consumer_name], line[:consumer_version_number], line[:pact_revision_number], line[:provider_name], line[:provider_version_number], line[:verification_number], line[:success])
+            Line.new(line.consumer_name, line.consumer_version_number, line.pact_revision_number, line.provider_name, line.provider_version_number, line.verification_number, line.success)
           end
           printer = TablePrint::Printer.new(data)
           printer.table_print + "\n\nDeployable: #{json_decorator.deployable.inspect}\nReason: #{json_decorator.reason}\n"

data/lib/pact_broker/api/decorators/verifiable_pacts_query_decorator.rb

@@ -20,6 +20,7 @@ module PactBroker
               represented.latest = (fragment == 'true' || fragment == true)
             }
           property :fallback_tag
+          property :consumer
         end
 
         property :include_pending_status, default: false,

data/lib/pact_broker/api/pact_broker_urls.rb

@@ -261,6 +261,17 @@ module PactBroker
         "#{base_url}/matrix?#{Rack::Utils.build_nested_query(query)}"
       end
 
+      def matrix_for_pact_url(pact, base_url = '')
+        query = {
+          q: [
+            { pacticipant: pact.consumer_name, version: pact.consumer_version_number },
+            { pacticipant: pact.provider_name, latest: true }
+          ],
+          latestby: 'cvpv'
+        }
+        "#{base_url}/matrix?#{Rack::Utils.build_nested_query(query)}"
+      end
+
       def matrix_url_from_params params, base_url = ''
         matrix_url(params.fetch(:consumer_name), params.fetch(:provider_name), base_url)
       end

data/lib/pact_broker/api/renderers/html_pact_renderer.rb

@@ -137,7 +137,7 @@ module PactBroker
         end
 
         def matrix_url
-          PactBroker::Api::PactBrokerUrls.matrix_for_pacticipant_version_url(@pact.consumer_version, base_url)
+          PactBroker::Api::PactBrokerUrls.matrix_for_pact_url(@pact, base_url)
         end
 
         def latest_pact_url

data/lib/pact_broker/db/data_migrations/set_created_at_for_latest_pact_publications.rb

@@ -0,0 +1,25 @@
+require 'pact_broker/db/data_migrations/helpers'
+
+module PactBroker
+  module DB
+    module DataMigrations
+      class SetCreatedAtForLatestPactPublications
+        def self.call connection
+          # pact ordering goes by creation date of the consumer version
+          connection[:latest_pact_publication_ids_for_consumer_versions]
+          query = "UPDATE latest_pact_publication_ids_for_consumer_versions
+                  SET created_at = (SELECT created_at
+                    FROM versions
+                    WHERE id = latest_pact_publication_ids_for_consumer_versions.consumer_version_id)
+                  WHERE created_at IS NULL"
+          connection.run(query)
+        end
+
+        def self.columns_exist?(connection)
+          column_exists?(connection, :latest_pact_publication_ids_for_consumer_versions, :created_at) &&
+            column_exists?(connection, :pact_publications, :created_at)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/data_migrations/set_created_at_for_latest_verifications.rb

@@ -0,0 +1,24 @@
+require 'pact_broker/db/data_migrations/helpers'
+
+module PactBroker
+  module DB
+    module DataMigrations
+      class SetCreatedAtForLatestVerifications
+        def self.call connection
+          connection[:latest_verification_id_for_pact_version_and_provider_version]
+          query = "UPDATE latest_verification_id_for_pact_version_and_provider_version
+                  SET created_at = (SELECT created_at
+                    FROM verifications
+                    WHERE id = latest_verification_id_for_pact_version_and_provider_version.verification_id)
+                  WHERE created_at is null"
+          connection.run(query)
+        end
+
+        def self.columns_exist?(connection)
+          column_exists?(connection, :latest_verification_id_for_pact_version_and_provider_version, :created_at) &&
+            column_exists?(connection, :verifications, :created_at)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/migrate_data.rb

@@ -19,6 +19,8 @@ module PactBroker
         DataMigrations::SetLatestVersionSequenceValue.call(database_connection)
         DataMigrations::SetWebhooksEnabled.call(database_connection)
         DataMigrations::DeleteDeprecatedWebhookExecutions.call(database_connection)
+        DataMigrations::SetCreatedAtForLatestPactPublications.call(database_connection)
+        DataMigrations::SetCreatedAtForLatestVerifications.call(database_connection)
       end
     end
   end

data/lib/pact_broker/matrix/every_row.rb

@@ -8,16 +8,22 @@ module PactBroker
       P_V_JOIN = { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }
 
       PACT_COLUMNS = [
+        Sequel[:p][:consumer_id],
+        Sequel[:p][:provider_id],
+        Sequel[:p][:consumer_version_id],
         Sequel[:p][:id].as(:pact_publication_id),
         Sequel[:p][:pact_version_id],
-        Sequel[:p][:revision_number].as(:pact_revision_number)
+        Sequel[:p][:revision_number].as(:pact_revision_number),
+        Sequel[:p][:created_at].as(:consumer_version_created_at),
+        Sequel[:p][:id].as(:pact_order)
       ]
       VERIFICATION_COLUMNS = [
-        Sequel[:v][:id].as(:verification_id)
+        Sequel[:v][:id].as(:verification_id),
+        Sequel[:v][:provider_version_id],
+        Sequel[:v][:created_at].as(:provider_version_created_at)
       ]
 
-      ALL_COLUMNS = [LAST_ACTION_DATE] + CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PACT_COLUMNS +
-                    PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS + VERIFICATION_COLUMNS
+      ALL_COLUMNS = PACT_COLUMNS + VERIFICATION_COLUMNS
 
       SELECT_ALL_COLUMN_ARGS = [:select_all_columns] + ALL_COLUMNS
       dataset_module do
@@ -29,7 +35,7 @@ module PactBroker
 
         def verifications_for(query_ids)
           db[:verifications]
-            .select(:id, :pact_version_id, :provider_id, :provider_version_id)
+            .select(:id, :pact_version_id, :provider_id, :provider_version_id, :created_at)
             .where {
               Sequel.&(
                 QueryBuilder.consumer_in_pacticipant_ids(query_ids),

data/lib/pact_broker/matrix/parse_query.rb

@@ -26,11 +26,17 @@ module PactBroker
         if params.key?('latestby') && params['latestby'] != ''
           options[:latestby] = params['latestby']
         end
+
+        if params.key?('days') && params['days'] != ''
+          options[:days] = params['days'].to_i
+        end
+
         if params.key?('limit') && params['limit'] != ''
           options[:limit] = params['limit']
         else
           options[:limit] = "100"
         end
+
         if params.key?('latest') && params['latest'] != ''
           options[:latest] = params['latest'] == 'true'
         end

data/lib/pact_broker/matrix/query_builder.rb

@@ -1,24 +1,36 @@
 module PactBroker
   module Matrix
     class QueryBuilder
-      def self.provider_or_provider_version_matches(query_ids, qualifier = nil)
-        Sequel.|(*provider_or_provider_version_criteria(query_ids, qualifier))
+      def self.provider_or_provider_version_matches(query_ids, provider_version_qualifier = nil, provider_qualifier = nil)
+        Sequel.|(*provider_or_provider_version_criteria(query_ids, provider_version_qualifier, provider_qualifier))
       end
 
-      def self.provider_or_provider_version_matches_or_pact_unverified(query_ids, qualifier = nil)
-        ors = provider_or_provider_version_criteria(query_ids, qualifier)
-
-        ors << {
-          qualify(:p, :provider_id) => query_ids.all_pacticipant_ids,
-          qualify(qualifier, :provider_version_id) => nil
+      def self.provider_matches(query_ids, qualifier)
+        {
+          qualify(qualifier, :provider_id) => query_ids.pacticipant_ids,
         }
+      end
+
+      def self.provider_or_provider_version_matches_or_pact_unverified(query_ids, provider_version_qualifier = nil, provider_qualifier = nil)
+        ors = provider_or_provider_version_criteria(query_ids, provider_version_qualifier, provider_qualifier)
+
+        # If we have specified any versions, then we need to add an
+        # "OR (provider matches these IDs and provider version is null)"
+        # so that we get a line with blank verification details.
+        if query_ids.pacticipant_version_ids.any?
+          ors << {
+            qualify(provider_qualifier, :provider_id) => query_ids.all_pacticipant_ids,
+            qualify(provider_version_qualifier, :provider_version_id) => nil
+          }
+        end
+
         Sequel.|(*ors)
       end
 
-      def self.provider_or_provider_version_criteria(query_ids, qualifier = nil)
+      def self.provider_or_provider_version_criteria(query_ids, provider_version_qualifier = nil, provider_qualifier = nil)
         ors = []
-        ors << { qualify(qualifier, :provider_version_id) => query_ids.pacticipant_version_ids } if query_ids.pacticipant_version_ids.any?
-        ors << { qualify(qualifier, :provider_id) => query_ids.pacticipant_ids } if query_ids.pacticipant_ids.any?
+        ors << { qualify(provider_version_qualifier, :provider_version_id) => query_ids.pacticipant_version_ids } if query_ids.pacticipant_version_ids.any?
+        ors << { qualify(provider_qualifier, :provider_id) => query_ids.pacticipant_ids } if query_ids.pacticipant_ids.any?
         ors
       end
 
@@ -50,16 +62,16 @@ module PactBroker
       end
 
       # QueryIds is built from a single selector, so there is only one pacticipant_id or pacticipant_version_id
-      def self.consumer_or_consumer_version_or_provider_or_provider_or_provider_version_match(query_ids)
+      def self.consumer_or_consumer_version_or_provider_or_provider_or_provider_version_match(query_ids, pacts_qualifier = :p, verifications_qualifier = :v)
         ors = if query_ids.pacticipant_version_id
           [
-            { Sequel[:p][:consumer_version_id] => query_ids.pacticipant_version_id },
-            { Sequel[:v][:provider_version_id] => query_ids.pacticipant_version_id }
+            { Sequel[pacts_qualifier][:consumer_version_id] => query_ids.pacticipant_version_id },
+            { Sequel[verifications_qualifier][:provider_version_id] => query_ids.pacticipant_version_id }
           ]
         else
           [
-            { Sequel[:p][:consumer_id] => query_ids.pacticipant_id },
-            { Sequel[:p][:provider_id] => query_ids.pacticipant_id }
+            { Sequel[pacts_qualifier][:consumer_id] => query_ids.pacticipant_id },
+            { Sequel[pacts_qualifier][:provider_id] => query_ids.pacticipant_id }
           ]
         end
 

data/lib/pact_broker/matrix/query_results_with_deployment_status_summary.rb

@@ -2,13 +2,24 @@ require 'pact_broker/matrix/query_results'
 
 module PactBroker
   module Matrix
-    class QueryResultsWithDeploymentStatusSummary < QueryResults
-      attr_reader :deployment_status_summary
+    class QueryResultsWithDeploymentStatusSummary
+      extend Forwardable
 
-      def initialize rows, selectors, options, resolved_selectors, integrations, deployment_status_summary
-        super(rows, selectors, options, resolved_selectors, integrations)
+      attr_reader :query_results, :deployment_status_summary
+
+      delegate [:selectors, :options, :resolved_selectors, :integrations] => :query_results
+      delegate (Array.instance_methods - Object.instance_methods) => :rows
+      delegate [:deployable?] => :deployment_status_summary
+
+
+      def initialize query_results, deployment_status_summary
+        @query_results = query_results
         @deployment_status_summary = deployment_status_summary
       end
+
+      def rows
+        query_results.rows
+      end
     end
   end
 end

data/lib/pact_broker/matrix/quick_row.rb

@@ -31,39 +31,23 @@ module PactBroker
       CONSUMER_VERSION_JOIN = { Sequel[:p][:consumer_version_id] => Sequel[:cv][:id] }
       PROVIDER_VERSION_JOIN = { Sequel[:v][:provider_version_id] => Sequel[:pv][:id] }
 
-      # Not sure why we're eager loading some things and including others in the base query :shrug:
-
-      # Columns
-      CONSUMER_COLUMNS = [
+      PACT_COLUMNS = [
         Sequel[:p][:consumer_id],
-        Sequel[:consumers][:name].as(:consumer_name)
-      ]
-      PROVIDER_COLUMNS = [
         Sequel[:p][:provider_id],
-        Sequel[:providers][:name].as(:provider_name)
-      ]
-      CONSUMER_VERSION_COLUMNS = [
         Sequel[:p][:consumer_version_id],
-        Sequel[:cv][:number].as(:consumer_version_number),
-        Sequel[:cv][:order].as(:consumer_version_order)
-      ]
-      PROVIDER_VERSION_COLUMNS = [
-        Sequel[:v][:provider_version_id],
-        Sequel[:pv][:number].as(:provider_version_number),
-        Sequel[:pv][:order].as(:provider_version_order)
-      ]
-      PACT_COLUMNS = [
         Sequel[:p][:pact_publication_id],
-        Sequel[:p][:pact_version_id]
+        Sequel[:p][:pact_version_id],
+        Sequel[:p][:created_at].as(:consumer_version_created_at),
+        Sequel[:p][:pact_publication_id].as(:pact_order)
       ]
       VERIFICATION_COLUMNS = [
-        Sequel[:v][:verification_id]
+        Sequel[:v][:provider_version_id],
+        Sequel[:v][:verification_id],
+        Sequel[:v][:created_at].as(:provider_version_created_at)
       ]
-      LAST_ACTION_DATE = Sequel.lit("CASE WHEN (pv.created_at IS NOT NULL AND pv.created_at > cv.created_at) THEN pv.created_at ELSE cv.created_at END").as(:last_action_date)
-
-      ALL_COLUMNS = [LAST_ACTION_DATE] + CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PACT_COLUMNS +
-                    PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS + VERIFICATION_COLUMNS
+      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)
 
+      ALL_COLUMNS = PACT_COLUMNS + VERIFICATION_COLUMNS
 
 
       # cachable select arguments
@@ -90,14 +74,15 @@ module PactBroker
           query = if selectors.size == 1
             pacticipant_ids_matching_one_selector_optimised(selectors)
           else
+            query = select_pacticipant_ids.distinct
             if infer_integrations
-              select_pacticipant_ids
-                .distinct
-                .matching_any_of_multiple_selectors(selectors)
+              query.matching_any_of_multiple_selectors(selectors)
             else
-              select_pacticipant_ids
-                .distinct
-                .matching_multiple_selectors(selectors)
+              if selectors.all?(&:only_pacticipant_name_specified?)
+                query.matching_multiple_selectors_without_joining_verifications(selectors)
+              else
+                query.matching_multiple_selectors_joining_verifications(selectors)
+              end
             end
           end
 
@@ -116,22 +101,16 @@ module PactBroker
           if selectors.size == 1
             matching_one_selector(selectors)
           else
-            matching_multiple_selectors(selectors)
+            matching_multiple_selectors_joining_verifications(selectors)
           end
         end
 
-        def order_by_names_ascending_most_recent_first
-          from_self.
-          order(
-            Sequel.asc(:consumer_name),
-            Sequel.desc(:consumer_version_order),
-            Sequel.asc(:provider_name),
-            Sequel.desc(:provider_version_order),
-            Sequel.desc(:verification_id))
+        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
 
-        def order_by_last_action_date
-          order(Sequel.desc(1), Sequel.desc(:consumer_version_order))
+        def order_by_pact_publication_created_at
+          order(Sequel.desc(:consumer_version_created_at), Sequel.desc(:pact_order))
         end
 
         def eager_all_the_things
@@ -147,7 +126,7 @@ module PactBroker
         end
 
         def default_scope
-          select_all_columns.join_verifications.join_pacticipants_and_pacticipant_versions.from_self
+          select_all_columns.join_verifications.from_self
         end
 
         # PRIVATE METHODS
@@ -156,9 +135,8 @@ module PactBroker
         # what integrations exist
         def matching_one_selector(selectors)
           join_verifications
-            .join_pacticipants_and_pacticipant_versions
             .where {
-              QueryBuilder.consumer_or_consumer_version_or_provider_or_provider_or_provider_version_match(QueryIds.from_selectors(selectors))
+              QueryBuilder.consumer_or_consumer_version_or_provider_or_provider_or_provider_version_match(QueryIds.from_selectors(selectors), :p, :v)
             }
         end
 
@@ -181,7 +159,7 @@ module PactBroker
             .distinct
             .inner_join_verifications
             .where {
-              QueryBuilder.provider_or_provider_version_matches(query_ids, :v)
+              QueryBuilder.provider_or_provider_version_matches(query_ids, :v, :v)
             }
         end
 
@@ -194,28 +172,41 @@ module PactBroker
         # 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.
-        def matching_multiple_selectors(selectors)
+
+        def matching_multiple_selectors_joining_verifications(selectors)
           query_ids = QueryIds.from_selectors(selectors)
           join_verifications_for(query_ids)
-            .join_pacticipants_and_pacticipant_versions
             .where {
               Sequel.&(
                 QueryBuilder.consumer_or_consumer_version_matches(query_ids, :p),
-                QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :v),
+                QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :v, :p),
                 QueryBuilder.either_consumer_or_provider_was_specified_in_query(query_ids, :p)
               )
             }
         end
 
+        def matching_multiple_selectors_without_joining_verifications(selectors)
+          # There are no versions specified in these selectors, so we can do the whole
+          # query based on the consumer/provider IDs, which we have in the pact_publication
+          # table without having to do a join.
+          query_ids = QueryIds.from_selectors(selectors)
+          where {
+            Sequel.&(
+              QueryBuilder.consumer_or_consumer_version_matches(query_ids, :p),
+              QueryBuilder.provider_matches(query_ids, :p),
+              QueryBuilder.either_consumer_or_provider_was_specified_in_query(query_ids, :p)
+            )
+          }
+        end
+
         def matching_any_of_multiple_selectors(selectors)
           query_ids = QueryIds.from_selectors(selectors)
           join_verifications_for(query_ids)
-            .join_pacticipants_and_pacticipant_versions
             .where {
               Sequel.&(
                 Sequel.|(
                   QueryBuilder.consumer_or_consumer_version_matches(query_ids, :p),
-                  QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :v),
+                  QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :v, :p),
                 ),
                 QueryBuilder.either_consumer_or_provider_was_specified_in_query(query_ids, :p)
               )
@@ -228,7 +219,7 @@ module PactBroker
 
         def verifications_for(query_ids)
           db[LV]
-            .select(:verification_id, :provider_version_id, :pact_version_id, :provider_id)
+            .select(:verification_id, :provider_version_id, :pact_version_id, :provider_id, :created_at)
             .where {
               Sequel.&(
                 QueryBuilder.consumer_in_pacticipant_ids(query_ids),
@@ -237,13 +228,6 @@ module PactBroker
             }
         end
 
-        def join_pacticipants_and_pacticipant_versions
-          join_consumers
-            .join_providers
-            .join_consumer_versions
-            .join_provider_versions
-        end
-
         def join_consumers qualifier = :p, table_alias = :consumers
           join(
             :pacticipants,
@@ -360,27 +344,27 @@ module PactBroker
       end
 
       def consumer_name
-        return_or_raise_if_not_set(:consumer_name)
+        consumer.name
       end
 
       def consumer_version_number
-        return_or_raise_if_not_set(:consumer_version_number)
+        consumer_version.number
       end
 
       def consumer_version_order
-        return_or_raise_if_not_set(:consumer_version_order)
+        consumer_version.order
       end
 
       def provider_name
-        return_or_raise_if_not_set(:provider_name)
+        provider.name
       end
 
       def provider_version_number
-        return_or_raise_if_not_set(:provider_version_number)
+        provider_version&.number
       end
 
       def provider_version_order
-        return_or_raise_if_not_set(:provider_version_order)
+        provider_version&.order
       end
 
       def last_action_date