pact_broker 2.43.0 → 2.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 452acf4f3b4042c53c9e91a793f558f39ad6677e
-  data.tar.gz: ffcc62ddc9991aed25c87cbdea9925e9471bc4f8
+  metadata.gz: 90700346c7cb45045249cf0006851d517a154879
+  data.tar.gz: 492ebdd3a03cf7d6f617cc820a1bbf0316031d66
 SHA512:
-  metadata.gz: e843bb458d91149a64f50092fcc1d17e63ed8b57468c7c2293033947648233cc015a010d421f7386531e89e90eb7d9499bc8da177da81c5518ea1bb937305ef8
-  data.tar.gz: c4df7ee48ef81fdb78beb668267ad13fcf848916b047c6f848a65bcc4979e7fac851617e93fba857b2a63bd77545d08a614e46257ede2e39e821d937ac3e79ef
+  metadata.gz: f8236c0d6c9ba4a6f81e776599047e24cea2ea6433454ba3072565e02eb1aca73bb72184fd9b01913a869bdb3ffbed12f06d791af3f853038f16dc981005512c
+  data.tar.gz: 29bdec1d5c5ed4be6d8751faa517012337f7e04f587d83f2d83455656104764f001bb8425706a590ae42ce32ac66c87fcc5112bad2083748e08e27af82d7f81b

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+<a name="v2.44.0"></a>
+### v2.44.0 (2020-01-22)
+
+
+#### Features
+
+* **matrix**
+  * optimise query to determine integrations, again	 ([44e78ad2](/../../commit/44e78ad2))
+  * add indexes to optimise queries	 ([cdc9aad7](/../../commit/cdc9aad7))
+  * optimise query to determine integrations	 ([9e874f3b](/../../commit/9e874f3b))
+
+* add hal relation for creating a tag on the pacticipant version resource	 ([dca0ad4f](/../../commit/dca0ad4f))
+
+
+#### Bug Fixes
+
+* update pact-support to fix bug caused by missing require	 ([416ecdf5](/../../commit/416ecdf5))
+* correct logic for finding pacticipants by name when the name contains an underscore	 ([6d975ebe](/../../commit/6d975ebe))
+* correct logic for finding pacticipants by name when the name contains an underscore	 ([2db59797](/../../commit/2db59797))
+
+* **matrix**
+  * correctly infer selectors when multiple selectors have been specified	 ([4288c282](/../../commit/4288c282))
+
+
 <a name="v2.43.0"></a>
 ### v2.43.0 (2020-01-06)
 
@@ -10,7 +34,6 @@
 
 * **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

data/DEVELOPER_DOCUMENTATION.md

@@ -7,7 +7,7 @@
   * API - [lib/pact_broker/api](lib/pact_broker/api)
     * Routes - [lib/pact_broker/api.rb](lib/pact_broker/api.rb)
     * HTTP Resources - [lib/pact_broker/api/resources](lib/pact_broker/api/resources) These handle the HTTP requests.
-    * Decorators - [lib/pact_broker/api/decorators](lib/pact_broker/api/decorators) These render the response bodies.
+    * Decorators - [lib/pact_broker/api/decorators](lib/pact_broker/api/decorators) These parse the request bodies and render the response bodies.
     * Contracts - [lib/pact_broker/api/contracts](lib/pact_broker/api/contracts) These validate incoming API requests.
   * UI - [lib/pact_broker/ui](lib/pact_broker/ui)
     * Routes - [lib/pact_broker/ui/app.rb](lib/pact_broker/ui/app.rb)
@@ -35,10 +35,13 @@ Domain classes are found in `lib/pact_broker/domain`. Many of these classes are
 
 * `pacticipant` - an application that participates in a pact. A very bad pun which I deeply regret.
 * `pact` - this term is confusing and overloaded. It generally means a `pact publication` in the code.
-* `pact publication` - the resource that gets created when a PUT request is sent to the Pact Broker to /pacts/provider/PROVIDER/consumer/CONSUMER/version/VERSION.
+* `pact publication` - the resource that gets created when a PUT request is sent to the Pact Broker to `/pacts/provider/PROVIDER/consumer/CONSUMER/version/VERSION`.
 * `pact version` - the JSON contents of the pact publication. One pact version may belong to many pact publications. That is, if a pact publication with exactly the same contents is published twice, then a new
-pact publication resource will be created, but it will reuse the existing pact version.
+pact publication resource will be created with an incremented revision number, but it will reuse the existing pact version.
+* `pacticipant version` - a resource that represents a version of the application
+* `integration` - the relationship between a consumer and a provider
 * `pseudo branch` - A time ordered list of pacts that are related to a particular tag. The most recent pact for each pseudo branch is a "head" pact.
+* `matrix` - the table that shows the cartesian join of pact versions/verifications, and hence shows which consumer versions and provider versions have been tested together.
 
 ### Tables
 * `pact_versions` - the JSON content of each UNIQUE pact document is stored in this table. The same content is likely to be published over and over again by the CI builds, so deduplicating the content saves us a lot of disk space. Once created, a row is never modified. Uniqueness is just done on string equality - no special pact logic. This means that pacts with randomly generated values or orders (most of pact-jvm pacts!) will get a new version record every time they publish.
@@ -80,11 +83,11 @@ pact publication resource will be created, but it will reuse the existing pact v
     * `consumer version number` and `consumer version order`
     * `revision_number`
 
-* `latest_pact_publications_by_consumer_versions` - This view has the same columns as `all_pact_publications`, but it only contains the latest revision of the pact for each provider/consumer/version. It maps to what a user would consider the "pact" resource ie. `/pacts/provider/Provider/consumer/Consumer/version/1.2.3`. Previous revisions are not currently exposed via the API.
+* `latest_pact_publications_by_consumer_versions` - This view has the same columns as `all_pact_publications`, but it only contains the latest revision of the pact for each provider/consumer/version. It maps to what a user would consider the "pact" resource ie. `/pacts/provider/PROVIDER/consumer/CONSUMER/version/VERSION`. Previous revisions are not currently exposed via the API.
 
  The `AllPactPublications` Sequel model in the code is what is used when querying data for displaying in a response, rather than the normalised separate PactPublication and PactVersion models.
 
-* `latest_pact_publications` - This view has the same columns as `all_pact_publications`, but it only contains the latest revision of the pact for the latest consumer version for each consumer/provider pair. It is what a user would consider the "latest pact", and maps to the resource at `/pacts/provider/Provider/consumer/Consumer/latest`
+* `latest_pact_publications` - This view has the same columns as `all_pact_publications`, but it only contains the latest revision of the pact for the latest consumer version for each consumer/provider pair. It is what a user would consider the "latest pact", and maps to the resource at `/pacts/provider/PROVIDER/consumer/CONSUMER/latest`
 
 * `latest_tagged_pact_publications` - This view has the same columns as `all_pact_publications`, plus a `tag_name` column. It is used to return the pact for the latest tagged version of a consumer.
 
@@ -116,8 +119,9 @@ pact publication resource will be created, but it will reuse the existing pact v
 
 ```
 
+### Database modeling approach
 
-
+In the beginning, I made a lot of Sequel models based on views that pulled in the different tables of data together (eg denormalising consumer, provider, pact publication and pact version in to `all_pact_publications`). This made the Ruby code quite simple, but it was not very performant. As time has progressed, I have moved more and more of the "data joining" code into the Ruby to optimise the queries. That's why there are a lot of "aggregated data" views that are not being used by the code any more.
 
 ### Useful to know stuff
 

data/README.md

@@ -166,7 +166,7 @@ Please read the [UPGRADING.md](UPGRADING.md) documentation before upgrading your
 [pact]: https://github.com/pact-foundation/pact-ruby
 [nerf]: https://github.com/pact-foundation/pact_broker/wiki/pact-broker-ci-nerf-gun
 [different-teams]: https://github.com/pact-foundation/pact-ruby/wiki/Using-pact-where-the-consumer-team-is-different-from-the-provider-team
-[docker]: https://hub.docker.com/r/dius/pact-broker
+[docker]: https://github.com/pact-foundation/pact-broker-docker
 [terraform]: https://github.com/nadnerb/terraform-pact-broker
 [pactflow]: https:/pactflow.io/?utm_source=github&utm_campaign=pact_broker_usage
 [wiki]: https://github.com/pact-foundation/pact_broker/wiki

data/lib/pact_broker/api.rb

@@ -53,7 +53,7 @@ module PactBroker
         add ['pacts', 'provider', :provider_name, 'for-verification'], Api::Resources::ProviderPactsForVerification, {resource_name: "pacts_for_verification"}
 
         # Deprecated pact
-        add ['pact', 'provider', :provider_name, 'consumer', :consumer_name, 'version', :consumer_version_number], Api::Resources::Pact, {resource_name: "pact_publications", deprecated: "true"} # Deprecate, singular /pact
+        add ['pact', 'provider', :provider_name, 'consumer', :consumer_name, 'version', :consumer_version_number], Api::Resources::Pact, {resource_name: "pact_publication", deprecated: "true"} # Deprecate, singular /pact
         add ['pact', 'provider', :provider_name, 'consumer', :consumer_name, 'latest'], Api::Resources::LatestPact, {resource_name: "latest_pact_publications", deprecated: "true"}
 
         # Pacticipants
@@ -88,7 +88,7 @@ module PactBroker
         add ['matrix', 'provider', :provider_name, 'consumer', :consumer_name], Api::Resources::MatrixForConsumerAndProvider, {resource_name: "matrix_consumer_provider"}
         add ['matrix', 'provider', :provider_name, 'latest', :provider_tag, 'consumer', :consumer_name, 'latest', :tag, 'badge'], Api::Resources::MatrixBadge, {resource_name: "matrix_tag_badge"}
         add ['matrix'], Api::Resources::Matrix, {resource_name: "matrix"}
-        add ['can-i-deploy'], Api::Resources::CanIDeploy, {resource_name: "can-i-deploy"}
+        add ['can-i-deploy'], Api::Resources::CanIDeploy, {resource_name: "can_i_deploy"}
 
         add ['dashboard'], Api::Resources::Dashboard, {resource_name: "dashboard"}
         add ['dashboard', 'provider', :provider_name, 'consumer', :consumer_name ], Api::Resources::Dashboard, {resource_name: "integration_dashboard"}

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

@@ -26,6 +26,14 @@ module PactBroker
           }
         end
 
+        link :'pb:tag' do | options |
+          {
+            href: pacticipant_url(options.fetch(:base_url), represented.pacticipant) + '/tags/{tag}',
+            title: "Get, create or delete a tag for this pacticipant version",
+            templated: true
+          }
+        end
+
         link :'pb:latest-verification-results-where-pacticipant-is-consumer' do | options |
           {
             title: "Latest verification results for consumer version",

data/lib/pact_broker/db/models.rb

@@ -1,7 +1,7 @@
 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/pacts/latest_pact_publication_id_for_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'

data/lib/pact_broker/doc/views/matrix.markdown

@@ -2,6 +2,96 @@
 
 Allowed methods: `GET`
 
-This resource returns the "cartesian join" of every pact publication and every verification results publication, and is used to determine whether or not an application is safe to deploy.
+This resource returns the "cartesian join" of every pact publication and every verification results publication, and is used to determine whether or not a set of integrated application versions are safe to deploy together.
 
-If you need to use this API, consider calling the `/can-i-deploy` resource instead.
+If you need to use this API, consider calling the `/can-i-deploy` resource instead, as it provides an interface that is easier to understand.
+
+
+## Matrix selectors and options
+
+Selectors are the way we specify which pacticipants and versions we want to view the matrix for. The best way to understand them is to imagine that we start with a Matrix table that contains the pacts/verification results for every consumer and provider in the Pact Broker.
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1                | Oink     | 6                | true    |
+| Foo      | 1                | Bar      | 2                | true    |
+| Foo      | 1                | Bar      | 3                | false   |
+
+To specify that we wanted to see all the rows between Foo and Bar, our selectors would be:
+
+`{"pacticipant": "Foo"}` and `{"pacticipant": "Bar"}`.
+
+This would return:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1                | Bar      | 2                | true    |
+| Foo      | 1                | Bar      | 3                | false   |
+
+To specify that we wanted to see the results for Foo v1 and Bar v3, our selectors would be:
+
+`{"pacticipant": "Foo", "version": "1"}` and `{"pacticipant": "Bar", "version": "3"}`.
+
+This would return:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1                | Bar      | 3                | false   |
+
+
+Best "Pact Broker" practice specifies that once a pact is published for a particular consumer version, it should not be overwritten, however, there is nothing built in to the broker to stop multiple pacts being published with the same consumer version. If the provider verifies each revision, we would end up with a table that looks like this:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1 (revision 1)   | Bar      | 3                | false   |
+| Foo      | 1 (revision 2)   | Bar      | 3                | true    |
+| Foo      | 1 (revision 3)   | Bar      | 3                | false   |
+
+The overwritten revisions are not useful for determining whether or not we are safe to deploy, so to remove these lines from the dataset, we can specify the option `{latestby: "cvpv"}` to return the latest row when grouped and ordered by "consumer version and provider version".
+
+Putting the selectors and the options together, to specify that we wanted to see the *latest* results for Foo v1 and Bar v3, our selectors would be:
+
+`{"pacticipant": "Foo", "version": "1"}` and `{"pacticipant": "Bar", "version": "3"}` and our options would be `{"latestby": "cvpv"}`.
+
+This would return:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1 (revision 3)   | Bar      | 3                | false   |
+
+
+Instead of specifying the version using the version number, you can also specify it by indicating the tag name.
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1 (prod)         | Bar      | 2                | true    |
+| Foo      | 1 (prod)         | Bar      | 3 (prod)         | true    |
+| Foo      | 2                | Bar      | 4 (prod)         | true    |
+| Foo      | 2                | Bar      | 5                | true    |
+
+Version 1 of Foo has been tagged prod, while versions 3 and 4 of Bar have been tagged prod.
+
+To determine if Foo v2 can be deployed with the latest prod version of Bar, our selectors would be:
+
+`{"pacticipant": "Foo", "version": "2"}` and `{"pacticipant": "Bar", tag: "prod", latest: true}` and our options would be `{"latestby": "cvpv"}`.
+
+Using the dataset above, this query would return:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 2                | Bar      | 4 (prod)         | true    |
+
+
+Imagine that Foo added another provider (and may add more in the future). It would be brittle to specify each of its integration partners by name. The Pact Broker already knows which applications Foo integrates with, so let's allow it to work out the dependencies by itself.
+
+To determine if Foo v2 can be deployed with the latest prod versions of all its integration partners, our selectors would be:
+
+`{"pacticipant": "Foo", "version": "2"}` and our options would be `{ "tag": "prod", latest: true, latestby: "cvp"}`. (Note the change in `latestby` from "cvpv" to "cvp". The reasons why this is the case are beyond the scope of this document.)
+
+
+If Foo was a mobile client, and Bar was its provider, we might want to know if a particular version of Bar was compatible with _all_ the production versions of Foo. To do this, we drop the `"latest": true` from Foo's selector, like so: `{"pacticipant": "Foo", "tag": "prod"}` and `{"pacticipant": "Bar", version: "3"}`. Using the dataset from above, this query would return the following rows:
+
+| Consumer | Consumer version | Provider | Provider version | Success |
+|----------|------------------|----------|------------------|---------|
+| Foo      | 1 (prod)         | Bar      | 2                | true    |
+| Foo      | 1 (prod)         | Bar      | 3 (prod)         | true    |

data/lib/pact_broker/matrix/deployment_status_summary.rb

@@ -99,12 +99,21 @@ module PactBroker
       # the Foo -> Bar integration, and therefore cannot deploy Foo.
       # However, if we were to try and deploy the provider, Bar, that would be ok
       # as Bar does not rely on Foo, so this method would not return that integration.
+      # UPDATE:
+      # The matrix query now returns a row with blank provider version/verification fields
+      # so the above comment is now redundant.
+      # I'm not sure if this piece of code can ever return a list with anything in it any more.
+      # Will log it for a while and see.
       def required_integrations_without_a_row
         @required_integrations_without_a_row ||= begin
           integrations.select(&:required?).select do | integration |
             !row_exists_for_integration(integration)
           end
-        end
+        end.tap { |it| log_required_integrations_without_a_row_occurred(it) if it.any? }
+      end
+
+      def log_required_integrations_without_a_row_occurred integrations
+        logger.info("required_integrations_without_a_row returned non empty", payload: { integrations: integrations, rows: rows })
       end
 
       def row_exists_for_integration(integration)
@@ -148,7 +157,7 @@ module PactBroker
         [selector_for(row.consumer_name), selector_for(row.provider_name)]
       end
 
-      # When the user has not specified a version of the provider (eg no 'latest' and/or 'tag')
+      # When the user has not specified a version of the provider (eg no 'latest' and/or 'tag', which means 'all versions')
       # so the "add inferred selectors" code in the Matrix::Repository has not run,
       # we may end up with rows for which we do not have a selector.
       # To solve this, create dummy selectors from the row and integration data.

data/lib/pact_broker/matrix/every_row.rb

@@ -0,0 +1,43 @@
+require 'pact_broker/matrix/quick_row'
+
+module PactBroker
+  module Matrix
+    class EveryRow < PactBroker::Matrix::QuickRow
+      set_dataset(Sequel.as(:pact_publications, :p))
+
+      P_V_JOIN = { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }
+
+      PACT_COLUMNS = [
+        Sequel[:p][:id].as(:pact_publication_id),
+        Sequel[:p][:pact_version_id],
+        Sequel[:p][:revision_number].as(:pact_revision_number)
+      ]
+      VERIFICATION_COLUMNS = [
+        Sequel[:v][:id].as(:verification_id)
+      ]
+
+      ALL_COLUMNS = CONSUMER_COLUMNS + CONSUMER_VERSION_COLUMNS + PACT_COLUMNS +
+                    PROVIDER_COLUMNS + PROVIDER_VERSION_COLUMNS + VERIFICATION_COLUMNS
+
+      SELECT_ALL_COLUMN_ARGS = [:select_all_columns] + ALL_COLUMNS
+      dataset_module do
+        select *SELECT_ALL_COLUMN_ARGS
+
+        def join_verifications
+          left_outer_join(:verifications, P_V_JOIN, { table_alias: :v } )
+        end
+
+        def verifications_for(query_ids)
+          db[:verifications]
+            .select(:id, :pact_version_id, :provider_id, :provider_version_id)
+            .where {
+              Sequel.&(
+                QueryBuilder.consumer_in_pacticipant_ids(query_ids),
+                QueryBuilder.provider_or_provider_version_matches(query_ids)
+              )
+            }
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/query_builder.rb

@@ -9,7 +9,7 @@ module PactBroker
         ors = provider_or_provider_version_criteria(query_ids, qualifier)
 
         ors << {
-          qualify(:lp, :provider_id) => query_ids.all_pacticipant_ids,
+          qualify(:p, :provider_id) => query_ids.all_pacticipant_ids,
           qualify(qualifier, :provider_version_id) => nil
         }
         Sequel.|(*ors)
@@ -53,13 +53,13 @@ module PactBroker
       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 }
+            { Sequel[:p][:consumer_version_id] => query_ids.pacticipant_version_id },
+            { Sequel[:v][: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 }
+            { Sequel[:p][:consumer_id] => query_ids.pacticipant_id },
+            { Sequel[:p][:provider_id] => query_ids.pacticipant_id }
           ]
         end
 

data/lib/pact_broker/matrix/quick_row.rb

@@ -20,54 +20,52 @@ require 'pact_broker/matrix/query_ids'
 
 module PactBroker
   module Matrix
-    class QuickRow < Sequel::Model(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :lp))
+    class QuickRow < Sequel::Model(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :p))
 
       # 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] }
+      LP_LV_JOIN = { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }
+      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 = [
-        Sequel[:lp][:consumer_id],
+        Sequel[:p][:consumer_id],
         Sequel[:consumers][:name].as(:consumer_name)
       ]
       PROVIDER_COLUMNS = [
-        Sequel[:lp][:provider_id],
+        Sequel[:p][:provider_id],
         Sequel[:providers][:name].as(:provider_name)
       ]
       CONSUMER_VERSION_COLUMNS = [
-        Sequel[:lp][:consumer_version_id],
+        Sequel[:p][: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[:v][: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]
+        Sequel[:p][:pact_publication_id],
+        Sequel[:p][:pact_version_id]
       ]
       VERIFICATION_COLUMNS = [
-        Sequel[:lv][:verification_id]
+        Sequel[:v][: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
+      SELECT_PACTICIPANT_IDS_ARGS = [:select_pacticipant_ids, Sequel[:p][:consumer_id], Sequel[:p][:provider_id]]
 
       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)
@@ -83,12 +81,26 @@ module PactBroker
         include PactBroker::Repositories::Helpers
 
         select *SELECT_ALL_COLUMN_ARGS
-        select *SELECT_PACTICIPANT_NAMES_AND_IDS_ARGS
+        select *SELECT_PACTICIPANT_IDS_ARGS
 
         def distinct_integrations selectors
-          select_pacticipant_names_and_ids
-            .distinct
-            .matching_selectors(selectors)
+          query = if selectors.size == 1
+            pacticipant_ids_matching_one_selector_optimised(selectors)
+          else
+            select_pacticipant_ids
+              .distinct
+              .matching_any_of_multiple_selectors(selectors)
+          end
+
+          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
 
         def matching_selectors selectors
@@ -117,6 +129,8 @@ module PactBroker
           .eager(:verification)
           .eager(:pact_publication)
           .eager(:pact_version)
+          .eager(:consumer_version_tags)
+          .eager(:provider_version_tags)
         end
 
         def default_scope
@@ -135,6 +149,29 @@ module PactBroker
             }
         end
 
+        def pacticipant_ids_matching_one_selector_optimised(selectors)
+          query_ids = QueryIds.from_selectors(selectors)
+          distinct_pacticipant_ids_where_consumer_or_consumer_version_matches(query_ids)
+            .union(distinct_pacticipant_ids_where_provider_or_provider_version_matches(query_ids), all: true)
+        end
+
+        def distinct_pacticipant_ids_where_consumer_or_consumer_version_matches(query_ids)
+          select_pacticipant_ids
+            .distinct
+            .where {
+              QueryBuilder.consumer_or_consumer_version_matches(query_ids, :p)
+            }
+        end
+
+        def distinct_pacticipant_ids_where_provider_or_provider_version_matches(query_ids)
+          select_pacticipant_ids
+            .distinct
+            .inner_join_verifications
+            .where {
+              QueryBuilder.provider_or_provider_version_matches(query_ids, :v)
+            }
+        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.
@@ -150,15 +187,30 @@ module PactBroker
             .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)
+                QueryBuilder.consumer_or_consumer_version_matches(query_ids, :p),
+                QueryBuilder.provider_or_provider_version_matches_or_pact_unverified(query_ids, :v),
+                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.either_consumer_or_provider_was_specified_in_query(query_ids, :p)
               )
             }
         end
 
         def join_verifications_for(query_ids)
-          left_outer_join(verifications_for(query_ids), LP_LV_JOIN, { table_alias: :lv } )
+          left_outer_join(verifications_for(query_ids), LP_LV_JOIN, { table_alias: :v } )
         end
 
         def verifications_for(query_ids)
@@ -179,12 +231,20 @@ module PactBroker
             .join_provider_versions
         end
 
-        def join_consumers
-          join(:pacticipants, CONSUMER_JOIN, { table_alias: :consumers })
+        def join_consumers qualifier = :p, table_alias = :consumers
+          join(
+            :pacticipants,
+            { Sequel[qualifier][:consumer_id] => Sequel[table_alias][:id] },
+            { table_alias: table_alias }
+          )
         end
 
-        def join_providers
-          join(:pacticipants, PROVIDER_JOIN, { table_alias: :providers })
+        def join_providers qualifier = :p, table_alias = :providers
+          join(
+            :pacticipants,
+            { Sequel[qualifier][:provider_id] => Sequel[table_alias][:id] },
+            { table_alias: table_alias }
+          )
         end
 
         def join_consumer_versions
@@ -196,7 +256,11 @@ module PactBroker
         end
 
         def join_verifications
-          left_outer_join(LV, LP_LV_JOIN, { table_alias: :lv } )
+          left_outer_join(LV, LP_LV_JOIN, { table_alias: :v } )
+        end
+
+        def inner_join_verifications
+          join(LV, LP_LV_JOIN, { table_alias: :v } )
         end
       end # end dataset_module
 
@@ -306,6 +370,10 @@ module PactBroker
         return_or_raise_if_not_set(:provider_version_order)
       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)