pact_broker 2.42.0 → 2.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1beb82704006c0aa9708a9b4e9af93075bfc3bf9
-  data.tar.gz: 8cb7b7148ce8a3152d6ccbe35e49f3e646f5e628
+  metadata.gz: 452acf4f3b4042c53c9e91a793f558f39ad6677e
+  data.tar.gz: ffcc62ddc9991aed25c87cbdea9925e9471bc4f8
 SHA512:
-  metadata.gz: b289766c4bc421c975fefc7a109f97eb6bc5f31eac99d1dd6e7754d7f2c7cf7f7dca21652d55d28a1e64d5eacd5f26e16f30ac1af3e2111eefc9a38bb42128f4
-  data.tar.gz: d6ce416cd0133c2d8278e1addc4f99814a118d9a800a74d1937168ac132e9f7ff27c3a48d63866ffaac0ec0424bd433f468812695e133edbf7a6698edbc9ba09
+  metadata.gz: e843bb458d91149a64f50092fcc1d17e63ed8b57468c7c2293033947648233cc015a010d421f7386531e89e90eb7d9499bc8da177da81c5518ea1bb937305ef8
+  data.tar.gz: c4df7ee48ef81fdb78beb668267ad13fcf848916b047c6f848a65bcc4979e7fac851617e93fba857b2a63bd77545d08a614e46257ede2e39e821d937ac3e79ef

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+<a name="v2.43.0"></a>
+### v2.43.0 (2020-01-06)
+
+
+#### Features
+
+* support DELETE /integrations for deleting all integration related data at once (pacticipants, pacts, verifications and webhooks)	 ([d7e2ef27](/../../commit/d7e2ef27))
+* optimise query to automatically determine integrations	 ([147cbfb6](/../../commit/147cbfb6))
+* change badge timeout message from error to warning	 ([e34f5676](/../../commit/e34f5676))
+
+* **matrix**
+  * optimise the query that determines the integrations	 ([704944b6](/../../commit/704944b6))
+  * attempt to optimise the query that determines the integrations	 ([afde01e1](/../../commit/afde01e1))
+
+
+#### Bug Fixes
+
+* update rack for https://github.com/advisories/GHSA-hrqr-hxpp-chr3	 ([c9352fde](/../../commit/c9352fde))
+* correctly identify missing verification for bi-directional pacts	 ([3577968a](/../../commit/3577968a))
+
+
 <a name="v2.42.0"></a>
 ### v2.42.0 (2019-12-05)
 

data/lib/pact_broker/api/resources/integrations.rb

@@ -30,7 +30,7 @@ module PactBroker
         end
 
         def delete_resource
-          integration_service.delete(consumer_name, provider_name)
+          integration_service.delete_all
           true
         end
       end

data/lib/pact_broker/badges/service.rb

@@ -84,8 +84,11 @@ module PactBroker
         begin
           response = do_request(uri)
           response.code == '200' ? response.body : nil
+        rescue Net::OpenTimeout => e
+          logger.warn "Timeout retrieving badge from #{uri} #{e.class} - #{e.message}"
+          nil
         rescue StandardError => e
-          logger.error "Error retrieving badge from #{uri} due to #{e.class} - #{e.message}"
+          log_error e, "Error retrieving badge from #{uri}"
           nil
         end
       end

data/lib/pact_broker/db/models.rb

@@ -0,0 +1,37 @@
+require 'pact_broker/webhooks/execution'
+require 'pact_broker/webhooks/triggered_webhook'
+require 'pact_broker/webhooks/webhook'
+require 'pact_broker/pacts/latest_pact_publication_id_by_consumer_version'
+require 'pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version'
+require 'pact_broker/pacts/pact_publication'
+require 'pact_broker/pacts/pact_version'
+require 'pact_broker/domain/verification'
+require 'pact_broker/domain/tag'
+require 'pact_broker/domain/version'
+require 'pact_broker/domain/label'
+require 'pact_broker/domain/pacticipant'
+
+module PactBroker
+  INTEGRATIONS_TABLES = [
+    PactBroker::Webhooks::Execution,
+    PactBroker::Webhooks::TriggeredWebhook,
+    PactBroker::Webhooks::Webhook,
+    PactBroker::Pacts::LatestPactPublicationIdForConsumerVersion,
+    PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion,
+    PactBroker::Domain::Verification,
+    PactBroker::Pacts::PactPublication,
+    PactBroker::Pacts::PactVersion,
+    PactBroker::Domain::Tag,
+    PactBroker::Domain::Version,
+    PactBroker::Domain::Label,
+    PactBroker::Domain::Pacticipant
+  ]
+
+  module DB
+    def self.each_integration_model
+      INTEGRATIONS_TABLES.each do | model |
+        yield model
+      end
+    end
+  end
+end

data/lib/pact_broker/integrations/service.rb

@@ -2,6 +2,8 @@ require 'pact_broker/services'
 require 'pact_broker/repositories'
 require 'pact_broker/logging'
 require 'pact_broker/integrations/integration'
+require 'pact_broker/db/models'
+require 'pact_broker/repositories/helpers'
 
 module PactBroker
   module Integrations
@@ -41,6 +43,22 @@ module PactBroker
         pacticipant_service.delete_if_orphan(consumer)
         pacticipant_service.delete_if_orphan(provider) unless consumer == provider
       end
+
+      def self.delete_all
+        # TODO move all these into their own repositories
+        PactBroker::DB.each_integration_model do | model |
+          if PactBroker::Repositories::Helpers.postgres?
+            logger.info("Truncating ", model.table_name)
+            model.truncate(cascade: true)
+          else
+            logger.info("Deleting all from ", model.table_name)
+            # Mysql adapter needs to support cascade truncate
+            # https://travis-ci.org/pact-foundation/pact_broker/jobs/633050220#L841
+            # https://travis-ci.org/pact-foundation/pact_broker/jobs/633053228#L849
+            model.dataset.delete
+          end
+        end
+      end
     end
   end
 end

data/lib/pact_broker/matrix/query_builder.rb

@@ -0,0 +1,78 @@
+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))
+      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(:lp, :provider_id) => query_ids.all_pacticipant_ids,
+          qualify(qualifier, :provider_version_id) => nil
+        }
+        Sequel.|(*ors)
+      end
+
+      def self.provider_or_provider_version_criteria(query_ids, 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
+      end
+
+      def self.consumer_in_pacticipant_ids(query_ids)
+        { consumer_id: query_ids.all_pacticipant_ids }
+      end
+
+      def self.consumer_or_consumer_version_matches(query_ids, qualifier)
+        ors = []
+        ors << { qualify(qualifier, :consumer_version_id) => query_ids.pacticipant_version_ids } if query_ids.pacticipant_version_ids.any?
+        ors << { qualify(qualifier, :consumer_id) => query_ids.pacticipant_ids } if query_ids.pacticipant_ids.any?
+
+        Sequel.|(*ors)
+      end
+
+      # Some selecters are specified in the query, others are implied (when only one pacticipant is specified,
+      # the integrations are automatically worked out, and the selectors for these are of type :implied )
+      # When there are 3 pacticipants that each have dependencies on each other (A->B, A->C, B->C), the query
+      # to deploy C (implied A, implied B, specified C) was returning the A->B row because it matched the
+      # implied selectors as well.
+      # This extra filter makes sure that every row that is returned actually matches one of the specified
+      # selectors.
+      def self.either_consumer_or_provider_was_specified_in_query(query_ids, qualifier = nil)
+        Sequel.|({
+          qualify(qualifier, :consumer_id) => query_ids.specified_pacticipant_ids
+        } , {
+          qualify(qualifier, :provider_id) => query_ids.specified_pacticipant_ids
+        })
+      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)
+        ors = if query_ids.pacticipant_version_id
+          [
+            { Sequel[:lp][:consumer_version_id] => query_ids.pacticipant_version_id },
+            { Sequel[:lv][:provider_version_id] => query_ids.pacticipant_version_id }
+          ]
+        else
+          [
+            { Sequel[:lp][:consumer_id] => query_ids.pacticipant_id },
+            { Sequel[:lp][:provider_id] => query_ids.pacticipant_id }
+          ]
+        end
+
+        Sequel.|(*ors)
+      end
+
+      def self.qualify(qualifier, column)
+        if qualifier
+          Sequel[qualifier][column]
+        else
+          column
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/query_ids.rb

@@ -0,0 +1,40 @@
+module PactBroker
+  module Matrix
+    class QueryIds
+      attr_reader :all_pacticipant_ids, :specified_pacticipant_ids, :pacticipant_ids, :pacticipant_version_ids
+
+      # pacticipant_version_ids - the pacticipant version ids from the selectors where the pacticipant version id is the most specific criterion
+      # pacticipant_ids - the pacticipant ids from the selectors where the pacticipant id is the most specific criterion
+      # all_pacticipant_ids - the pacticipant ids from all the selectors, regardless of whether or not a pacticipant version has also been specified
+      # specified_pacticipant_ids the IDs of the pacticipants that were specified in the can-i-deploy query
+      def initialize(all_pacticipant_ids, specified_pacticipant_ids, pacticipant_ids, pacticipant_version_ids)
+        @all_pacticipant_ids = all_pacticipant_ids
+        @specified_pacticipant_ids = specified_pacticipant_ids
+        @pacticipant_ids = pacticipant_ids
+        @pacticipant_version_ids = pacticipant_version_ids
+        @all_pacticipant_ids = all_pacticipant_ids
+      end
+
+      def self.from_selectors(selectors)
+        most_specific_criteria = selectors.collect(&:most_specific_criterion)
+        all_pacticipant_ids = selectors.collect(&:pacticipant_id)
+        specified_pacticipant_ids = selectors.select(&:specified?).collect(&:pacticipant_id)
+        pacticipant_version_ids = collect_ids(most_specific_criteria, :pacticipant_version_id)
+        pacticipant_ids = collect_ids(most_specific_criteria, :pacticipant_id)
+        QueryIds.new(all_pacticipant_ids, specified_pacticipant_ids, pacticipant_ids, pacticipant_version_ids)
+      end
+
+      def self.collect_ids(hashes, key)
+        hashes.collect{ |s| s[key] }.flatten.compact
+      end
+
+      def pacticipant_id
+        pacticipant_ids.first
+      end
+
+      def pacticipant_version_id
+        pacticipant_version_ids.first
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/quick_row.rb

@@ -1,11 +1,6 @@
-=begin
-The Matrix::Row is based on the matrix view which does a join of every pact/verification
-and then selects the relevant ones.
-
-The Matrix::QuickRow starts with the relevant rows, and builds the matrix query from that,
-making it much quicker.
-
-=end
+require 'pact_broker/pacts/all_pact_publications'
+require 'pact_broker/repositories/helpers'
+require 'pact_broker/matrix/query_builder'
 require 'sequel'
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/logging'
@@ -15,41 +10,64 @@ require 'pact_broker/domain/version'
 require 'pact_broker/domain/verification'
 require 'pact_broker/pacts/pact_publication'
 require 'pact_broker/tags/tag_with_latest_flag'
+require 'pact_broker/matrix/query_ids'
+
+# The difference between `join_verifications_for` and `join_verifications` is that
+# the left outer join is done on a pre-filtered dataset in `join_verifications_for`,
+# so that we get a row with null verification fields for a pact that has been verified
+# by a *different* version of the provider we're interested in,
+# rather than being excluded from the dataset altogether.
 
 module PactBroker
   module Matrix
-    LV = :latest_verification_id_for_pact_version_and_provider_version
-    LP = :latest_pact_publication_ids_for_consumer_versions
-
-    CONSUMER_COLUMNS = [Sequel[:lp][:consumer_id], Sequel[:consumers][:name].as(:consumer_name), Sequel[:lp][:pact_publication_id], Sequel[:lp][:pact_version_id]]
-    PROVIDER_COLUMNS = [Sequel[:lp][:provider_id], Sequel[:providers][:name].as(:provider_name), Sequel[:lv][:verification_id]]
-    CONSUMER_VERSION_COLUMNS = [Sequel[:lp][:consumer_version_id], Sequel[:cv][:number].as(:consumer_version_number), Sequel[:cv][:order].as(:consumer_version_order)]
-    PROVIDER_VERSION_COLUMNS = [Sequel[:lv][:provider_version_id], Sequel[:pv][:number].as(:provider_version_number), Sequel[:pv][:order].as(:provider_version_order)]
-    ALL_COLUMNS = CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS
-
-    LP_LV_JOIN = { Sequel[:lp][:pact_version_id] => Sequel[:lv][:pact_version_id] }
-    CONSUMER_JOIN = { Sequel[:lp][:consumer_id] => Sequel[:consumers][:id] }
-    PROVIDER_JOIN = { Sequel[:lp][:provider_id] => Sequel[:providers][:id] }
-    CONSUMER_VERSION_JOIN = { Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id] }
-    PROVIDER_VERSION_JOIN = { Sequel[:lv][:provider_version_id] => Sequel[:pv][:id] }
-
-    RAW_QUERY = Sequel::Model.db[Sequel.as(LP, :lp)]
-      .select(*ALL_COLUMNS)
-      .left_outer_join(LV, LP_LV_JOIN, { table_alias: :lv } )
-      .join(:pacticipants, CONSUMER_JOIN, { table_alias: :consumers })
-      .join(:pacticipants, PROVIDER_JOIN, { table_alias: :providers })
-      .join(:versions, CONSUMER_VERSION_JOIN, { table_alias: :cv })
-      .left_outer_join(:versions, PROVIDER_VERSION_JOIN, { table_alias: :pv } )
-
-    ALIASED_QUERY = Sequel.as(RAW_QUERY, :quick_rows)
-
-    class QuickRow < Sequel::Model(ALIASED_QUERY)
-      CONSUMER_ID = Sequel[:quick_rows][:consumer_id]
-      PROVIDER_ID = Sequel[:quick_rows][:provider_id]
-      CONSUMER_VERSION_ID = Sequel[:quick_rows][:consumer_version_id]
-      PROVIDER_VERSION_ID = Sequel[:quick_rows][:provider_version_id]
-      PACT_PUBLICATION_ID = Sequel[:quick_rows][:pact_publication_id]
-      VERIFICATION_ID = Sequel[:quick_rows][:verification_id]
+    class QuickRow < Sequel::Model(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :lp))
+
+      # Tables
+      LV = :latest_verification_id_for_pact_version_and_provider_version
+      LP = :latest_pact_publication_ids_for_consumer_versions
+
+      # Joins
+      LP_LV_JOIN = { Sequel[:lp][:pact_version_id] => Sequel[:lv][:pact_version_id] }
+      CONSUMER_JOIN = { Sequel[:lp][:consumer_id] => Sequel[:consumers][:id] }
+      PROVIDER_JOIN = { Sequel[:lp][:provider_id] => Sequel[:providers][:id] }
+      CONSUMER_VERSION_JOIN = { Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id] }
+      PROVIDER_VERSION_JOIN = { Sequel[:lv][:provider_version_id] => Sequel[:pv][:id] }
+
+      # Not sure why we're eager loading some things and including others in the base query :shrug:
+
+      # Columns
+      CONSUMER_COLUMNS = [
+        Sequel[:lp][:consumer_id],
+        Sequel[:consumers][:name].as(:consumer_name)
+      ]
+      PROVIDER_COLUMNS = [
+        Sequel[:lp][:provider_id],
+        Sequel[:providers][:name].as(:provider_name)
+      ]
+      CONSUMER_VERSION_COLUMNS = [
+        Sequel[:lp][:consumer_version_id],
+        Sequel[:cv][:number].as(:consumer_version_number),
+        Sequel[:cv][:order].as(:consumer_version_order)
+      ]
+      PROVIDER_VERSION_COLUMNS = [
+        Sequel[:lv][:provider_version_id],
+        Sequel[:pv][:number].as(:provider_version_number),
+        Sequel[:pv][:order].as(:provider_version_order)
+      ]
+      PACT_COLUMNS = [
+        Sequel[:lp][:pact_publication_id],
+        Sequel[:lp][:pact_version_id]
+      ]
+      VERIFICATION_COLUMNS = [
+        Sequel[:lv][:verification_id]
+      ]
+      ALL_COLUMNS = CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PACT_COLUMNS +
+                    PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS + VERIFICATION_COLUMNS
+      PACTICIPANT_NAMES_AND_IDS = CONSUMER_COLUMNS + PROVIDER_COLUMNS
+
+      # cachable select arguments
+      SELECT_ALL_COLUMN_ARGS = [:select_all_columns] + ALL_COLUMNS
+      SELECT_PACTICIPANT_NAMES_AND_IDS_ARGS = [:select_pacticipant_names_and_ids] + PACTICIPANT_NAMES_AND_IDS
 
       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)
@@ -63,102 +81,26 @@ module PactBroker
 
       dataset_module do
         include PactBroker::Repositories::Helpers
-        include PactBroker::Logging
 
-        def consumer_id consumer_id
-          where(CONSUMER_ID => consumer_id)
+        select *SELECT_ALL_COLUMN_ARGS
+        select *SELECT_PACTICIPANT_NAMES_AND_IDS_ARGS
+
+        def distinct_integrations selectors
+          select_pacticipant_names_and_ids
+            .distinct
+            .matching_selectors(selectors)
         end
 
         def matching_selectors selectors
           if selectors.size == 1
-            where_consumer_or_provider_is(selectors.first)
+            matching_one_selector(selectors)
           else
-            where_consumer_and_provider_in(selectors)
-          end
-        end
-
-        # find rows where (the consumer (and optional version) matches any of the selectors)
-        # AND
-        # the (provider (and optional version) matches any of the selectors OR the provider matches
-        #      and the verification is missing (and hence the provider version is null))
-        def where_consumer_and_provider_in selectors
-          where{
-            Sequel.&(
-              Sequel.|(
-                *QueryHelper.consumer_and_maybe_consumer_version_match_any_selector(selectors)
-              ),
-              Sequel.|(
-                *QueryHelper.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
-              ),
-              QueryHelper.either_consumer_or_provider_was_specified_in_query(selectors)
-            )
-          }
-        end
-
-        # Can't access other dataset_module methods from inside the Sequel `where{ ... }` block, so make a private class
-        # with some helper methods
-        class QueryHelper
-          def self.consumer_and_maybe_consumer_version_match_any_selector(selectors)
-            selectors.collect { |s| consumer_and_maybe_consumer_version_match_selector(s) }
-          end
-
-          def self.consumer_and_maybe_consumer_version_match_selector(s)
-            if s[:pact_publication_ids]
-              Sequel.&(PACT_PUBLICATION_ID => s[:pact_publication_ids])
-            elsif s[:pacticipant_version_id]
-              Sequel.&(CONSUMER_ID => s[:pacticipant_id], CONSUMER_VERSION_ID => s[:pacticipant_version_id])
-            else
-              Sequel.&(CONSUMER_ID => s[:pacticipant_id])
-            end
-          end
-
-          def self.provider_and_maybe_provider_version_match_selector(s)
-            if s[:verification_ids]
-              Sequel.&(VERIFICATION_ID => s[:verification_ids])
-            elsif s[:pacticipant_version_id]
-              Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => s[:pacticipant_version_id])
-            else
-              Sequel.&(PROVIDER_ID => s[:pacticipant_id])
-            end
-          end
-
-          # if the pact for a consumer version has never been verified, it exists in the matrix as a row
-          # with a blank provider version id
-          def self.provider_verification_is_missing_for_matching_selector(s)
-            Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => nil)
-          end
-
-          def self.provider_and_maybe_provider_version_match_any_selector_or_verification_is_missing(selectors)
-            selectors.collect { |s|
-              provider_and_maybe_provider_version_match_selector(s)
-            } + selectors.collect { |s|
-              provider_verification_is_missing_for_matching_selector(s)
-            }
-          end
-
-          # Some selecters are specified in the query, others are implied (when only one pacticipant is specified,
-          # the integrations are automatically worked out, and the selectors for these are of type :implied )
-          # When there are 3 pacticipants that each have dependencies on each other (A->B, A->C, B->C), the query
-          # to deploy C (implied A, implied B, specified C) was returning the A->B row because it matched the
-          # implied selectors as well.
-          # This extra filter makes sure that every row that is returned actually matches one of the specified
-          # selectors.
-          def self.either_consumer_or_provider_was_specified_in_query(selectors)
-            specified_pacticipant_ids = selectors.select{ |s| s[:type] == :specified }.collect{ |s| s[:pacticipant_id] }
-            Sequel.|({ CONSUMER_ID => specified_pacticipant_ids } , { PROVIDER_ID => specified_pacticipant_ids })
+            matching_multiple_selectors(selectors)
           end
         end
 
-        def where_consumer_or_provider_is s
-          where{
-            Sequel.|(
-              s[:pacticipant_version_id] ? Sequel.&(CONSUMER_ID => s[:pacticipant_id], CONSUMER_VERSION_ID => s[:pacticipant_version_id]) :  Sequel.&(CONSUMER_ID => s[:pacticipant_id]),
-              s[:pacticipant_version_id] ? Sequel.&(PROVIDER_ID => s[:pacticipant_id], PROVIDER_VERSION_ID => s[:pacticipant_version_id]) :  Sequel.&(PROVIDER_ID => s[:pacticipant_id])
-            )
-          }
-        end
-
         def order_by_names_ascending_most_recent_first
+          from_self.
           order(
             Sequel.asc(:consumer_name),
             Sequel.desc(:consumer_version_order),
@@ -177,7 +119,86 @@ module PactBroker
           .eager(:pact_version)
         end
 
-      end
+        def default_scope
+          select_all_columns.join_verifications.join_pacticipants_and_pacticipant_versions.from_self
+        end
+
+        # PRIVATE METHODS
+
+        # When we have one selector, we need to join ALL the verifications to find out
+        # 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))
+            }
+        end
+
+        # 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.
+        def matching_multiple_selectors(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, :lp),
+                QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :lv),
+                QueryBuilder.either_consumer_or_provider_was_specified_in_query(query_ids, :lp)
+              )
+            }
+        end
+
+        def join_verifications_for(query_ids)
+          left_outer_join(verifications_for(query_ids), LP_LV_JOIN, { table_alias: :lv } )
+        end
+
+        def verifications_for(query_ids)
+          db[LV]
+            .select(:verification_id, :provider_version_id, :pact_version_id, :provider_id)
+            .where {
+              Sequel.&(
+                QueryBuilder.consumer_in_pacticipant_ids(query_ids),
+                QueryBuilder.provider_or_provider_version_matches(query_ids)
+              )
+            }
+        end
+
+        def join_pacticipants_and_pacticipant_versions
+          join_consumers
+            .join_providers
+            .join_consumer_versions
+            .join_provider_versions
+        end
+
+        def join_consumers
+          join(:pacticipants, CONSUMER_JOIN, { table_alias: :consumers })
+        end
+
+        def join_providers
+          join(:pacticipants, PROVIDER_JOIN, { table_alias: :providers })
+        end
+
+        def join_consumer_versions
+          join(:versions, CONSUMER_VERSION_JOIN, { table_alias: :cv })
+        end
+
+        def join_provider_versions
+          left_outer_join(:versions, PROVIDER_VERSION_JOIN, { table_alias: :pv } )
+        end
+
+        def join_verifications
+          left_outer_join(LV, LP_LV_JOIN, { table_alias: :lv } )
+        end
+      end # end dataset_module
 
       def success
         verification&.success
@@ -250,6 +271,50 @@ module PactBroker
       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
+        return_or_raise_if_not_set(:consumer_name)
+      end
+
+      def consumer_version_number
+        return_or_raise_if_not_set(:consumer_version_number)
+      end
+
+      def consumer_version_order
+        return_or_raise_if_not_set(:consumer_version_order)
+      end
+
+      def provider_name
+        return_or_raise_if_not_set(:provider_name)
+      end
+
+      def provider_version_number
+        return_or_raise_if_not_set(:provider_version_number)
+      end
+
+      def provider_version_order
+        return_or_raise_if_not_set(:provider_version_order)
+      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