pact_broker 2.81.0 → 2.82.0

data/lib/pact_broker/matrix/repository.rb

@@ -1,3 +1,4 @@
+require "pact_broker/logging"
 require "pact_broker/repositories/helpers"
 require "pact_broker/matrix/row"
 require "pact_broker/matrix/quick_row"
@@ -20,6 +21,7 @@ module PactBroker
     class Repository
       include PactBroker::Repositories::Helpers
       include PactBroker::Repositories
+      include PactBroker::Logging
 
       # TODO move latest verification logic in to database
 
@@ -59,7 +61,7 @@ module PactBroker
       def find specified_selectors, options = {}
         resolved_ignore_selectors = resolve_ignore_selectors(options)
         resolved_specified_selectors = resolve_versions_and_add_ids(specified_selectors, :specified, resolved_ignore_selectors)
-        integrations = find_integrations_for_specified_selectors(resolved_specified_selectors, infer_selectors_for_integrations?(options))
+        integrations = find_integrations_for_specified_selectors(resolved_specified_selectors, options)
         resolved_selectors = add_any_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
         considered_rows, ignored_rows = find_considered_and_ignored_rows(resolved_selectors, resolved_ignore_selectors, options)
         QueryResults.new(considered_rows.sort, ignored_rows.sort, specified_selectors, options, resolved_selectors, resolved_ignore_selectors, integrations)
@@ -81,10 +83,18 @@ module PactBroker
         return considered_rows, ignored_rows
       end
 
-      def find_integrations_for_specified_selectors(resolved_specified_selectors, infer_integrations)
+      def find_integrations_for_specified_selectors(resolved_specified_selectors, options)
+        if infer_selectors_for_integrations?(options)
+          find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors, options)
+        else
+          find_integrations_for_specified_selectors_only(resolved_specified_selectors)
+        end
+      end
+
+      def find_integrations_for_specified_selectors_only(resolved_specified_selectors)
         specified_pacticipant_names = resolved_specified_selectors.collect(&:pacticipant_name)
         base_model_for_integrations
-          .distinct_integrations(resolved_specified_selectors, infer_integrations)
+          .distinct_integrations(resolved_specified_selectors, false)
           .collect(&:to_hash)
           .collect do | integration_hash |
             required = is_a_row_for_this_integration_required?(specified_pacticipant_names, integration_hash[:consumer_name])
@@ -92,6 +102,57 @@ module PactBroker
           end
       end
 
+      def find_integrations_for_specified_selectors_with_inferred_integrations(resolved_specified_selectors, options)
+        integrations = integrations_where_specified_selector_is_consumer(resolved_specified_selectors) +
+                        integrations_where_specified_selector_is_provider(resolved_specified_selectors, options)
+        deduplicate_integrations(integrations)
+      end
+
+      def integrations_where_specified_selector_is_consumer(resolved_specified_selectors)
+        resolved_specified_selectors.flat_map do | selector |
+          base_model_for_integrations
+            .distinct_integrations_for_selector_as_consumer(selector)
+            .all
+            .collect do | integration |
+              Integration.from_hash(
+                consumer_id: integration[:consumer_id],
+                consumer_name: integration[:consumer_name],
+                provider_id: integration[:provider_id],
+                provider_name: integration[:provider_name],
+                required: true
+              )
+            end
+        end
+      end
+
+      def integrations_where_specified_selector_is_provider(resolved_specified_selectors, options)
+        integrations_involving_specified_providers = PactBroker::Integrations::Integration
+                                                      .where(provider_id: resolved_specified_selectors.collect(&:pacticipant_id))
+                                                      .eager(:consumer)
+                                                      .all
+
+        destination_selector = PactBroker::Matrix::UnresolvedSelector.new(options.slice(:latest, :tag, :branch, :environment_name).compact)
+
+        integrations_involving_specified_providers.collect do | integration |
+          required = PactBroker::Domain::Version.where(pacticipant: integration.consumer).for_selector(destination_selector).any?
+
+          Integration.from_hash(
+            consumer_id: integration.consumer.id,
+            consumer_name: integration.consumer.name,
+            provider_id: integration.provider.id,
+            provider_name: integration.provider.name,
+            required: required
+          )
+        end
+      end
+
+      def deduplicate_integrations(integrations)
+        integrations
+          .group_by{ | integration| [integration.consumer_id, integration.provider_id] }
+          .values
+          .collect { | duplicate_integrations | duplicate_integrations.find(&:required?) || duplicate_integrations.first }
+      end
+
       def add_any_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
         if infer_selectors_for_integrations?(options)
           resolved_specified_selectors + inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)

data/lib/pact_broker/metrics/service.rb

@@ -1,16 +1,6 @@
 require "pact_broker/configuration"
-require "pact_broker/pacts/pact_publication"
-require "pact_broker/pacts/pact_version"
-require "pact_broker/domain/pacticipant"
-require "pact_broker/integrations/integration"
-require "pact_broker/domain/verification"
-require "pact_broker/domain/version"
+require "pact_broker/db/models"
 require "pact_broker/api/decorators/format_date_time"
-require "pact_broker/webhooks/webhook"
-require "pact_broker/webhooks/triggered_webhook"
-require "pact_broker/webhooks/execution"
-require "pact_broker/matrix/row"
-require "pact_broker/matrix/head_row"
 
 module PactBroker
   module Metrics
@@ -24,7 +14,8 @@ module PactBroker
         {
           interactions: interactions_counts,
           pacticipants: {
-            count: PactBroker::Domain::Pacticipant.count
+            count: PactBroker::Domain::Pacticipant.count,
+            withMainBranchSetCount: PactBroker::Domain::Pacticipant.with_main_branch_set.count
           },
           integrations: {
             count: PactBroker::Integrations::Integration.count
@@ -52,7 +43,8 @@ module PactBroker
             distribution: verification_distribution
           },
           pacticipantVersions: {
-            count: PactBroker::Domain::Version.count
+            count: PactBroker::Domain::Version.count,
+            withBranchSetCount: PactBroker::Domain::Version.with_branch_set.count
           },
           webhooks: {
             count: PactBroker::Webhooks::Webhook.count
@@ -70,6 +62,17 @@ module PactBroker
           },
           matrix: {
             count: matrix_count
+          },
+          environments: {
+            count: PactBroker::Deployments::Environment.count
+          },
+          deployedVersions: {
+            count: PactBroker::Deployments::DeployedVersion.count,
+            currentlyDeployedCount: PactBroker::Deployments::DeployedVersion.currently_deployed.count
+          },
+          releasedVersions: {
+            count: PactBroker::Deployments::ReleasedVersion.count,
+            currentlySupportedCount: PactBroker::Deployments::ReleasedVersion.currently_supported.count
           }
         }
       end

data/lib/pact_broker/pacticipants/repository.rb

@@ -99,6 +99,10 @@ module PactBroker
         string_match_query = Sequel.|( *terms.map { |term| Sequel.ilike(Sequel[:pacticipants][:name], "%#{term}%") })
         PactBroker::Domain::Pacticipant.where(string_match_query)
       end
+
+      def set_main_branch(pacticipant, main_branch)
+        pacticipant.update(main_branch: main_branch)
+      end
     end
   end
 end

data/lib/pact_broker/pacticipants/service.rb

@@ -4,7 +4,6 @@ require "pact_broker/messages"
 require "pact_broker/pacticipants/find_potential_duplicate_pacticipant_names"
 
 module PactBroker
-
   module Pacticipants
     class Service
 
@@ -90,6 +89,15 @@ module PactBroker
       def self.pacticipant_names
         pacticipant_repository.pacticipant_names
       end
+
+      def self.maybe_set_main_branch(pacticipant, potential_main_branch)
+        if pacticipant.main_branch.nil? && PactBroker.configuration.auto_detect_main_branch && PactBroker.configuration.main_branch_candidates.include?(potential_main_branch)
+          logger.info "Setting #{pacticipant.name} main_branch to '#{potential_main_branch}' (because the #{pacticipant.name} main_branch was nil and auto_detect_main_branch=true)"
+          pacticipant_repository.set_main_branch(pacticipant, potential_main_branch)
+        else
+          pacticipant
+        end
+      end
     end
   end
 end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -24,10 +24,6 @@ module PactBroker
       associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
       associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
 
-      one_to_one(:latest_verification, class: "PactBroker::Domain::Verification", key: :pact_version_id, primary_key: :pact_version_id) do | ds |
-        ds.unlimited.latest_by_pact_version
-      end
-
       # TODO rename to consumer_version_tags
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :key => :version_id, :primary_key => :consumer_version_id)
 
@@ -173,13 +169,14 @@ end
 
 # Table: pact_publications
 # Columns:
-#  id                  | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
-#  consumer_version_id | integer                     | NOT NULL
-#  provider_id         | integer                     | NOT NULL
-#  revision_number     | integer                     | NOT NULL
-#  pact_version_id     | integer                     | NOT NULL
-#  created_at          | timestamp without time zone | NOT NULL
-#  consumer_id         | integer                     |
+#  id                     | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  consumer_version_id    | integer                     | NOT NULL
+#  provider_id            | integer                     | NOT NULL
+#  revision_number        | integer                     | NOT NULL
+#  pact_version_id        | integer                     | NOT NULL
+#  created_at             | timestamp without time zone | NOT NULL
+#  consumer_id            | integer                     |
+#  consumer_version_order | integer                     |
 # Indexes:
 #  pact_publications_pkey              | PRIMARY KEY btree (id)
 #  cv_prov_revision_unq                | UNIQUE btree (consumer_version_id, provider_id, revision_number)
@@ -191,6 +188,6 @@ end
 #  pact_publications_pact_version_id_fkey     | (pact_version_id) REFERENCES pact_versions(id)
 #  pact_publications_provider_id_fkey         | (provider_id) REFERENCES pacticipants(id)
 # Referenced By:
-#  webhook_executions                                | webhook_executions_pact_publication_id_fkey                     | (pact_publication_id) REFERENCES pact_publications(id)
-#  triggered_webhooks                                | triggered_webhooks_pact_publication_id_fkey                     | (pact_publication_id) REFERENCES pact_publications(id)
 #  latest_pact_publication_ids_for_consumer_versions | latest_pact_publication_ids_for_consum_pact_publication_id_fkey | (pact_publication_id) REFERENCES pact_publications(id) ON DELETE CASCADE
+#  triggered_webhooks                                | triggered_webhooks_pact_publication_id_fkey                     | (pact_publication_id) REFERENCES pact_publications(id)
+#  webhook_executions                                | webhook_executions_pact_publication_id_fkey                     | (pact_publication_id) REFERENCES pact_publications(id)

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -26,7 +26,12 @@ module PactBroker
       end
 
       def for_consumer_version_tag tag_name
-        join(:tags, { version_id: :consumer_version_id, Sequel[:tags][:name] => tag_name })
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+        end
+
+        base_query.join(:tags, { version_id: :consumer_version_id, Sequel[:tags][:name] => tag_name })
       end
 
       def for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)

data/lib/pact_broker/pacts/pact_publication_selector_dataset_module.rb

@@ -3,17 +3,16 @@ module PactBroker
     module PactPublicationSelectorDatasetModule
       # rubocop: disable Metrics/CyclomaticComplexity
       def for_provider_and_consumer_version_selector provider, selector
-        # Does not yet support "all pacts for specified tag" - that code is still in the Pact::Repository
         query = for_provider(provider)
         query = query.for_consumer(PactBroker::Domain::Pacticipant.find_by_name(selector.consumer)) if selector.consumer
         query = query.for_currently_deployed_versions(selector.environment_name) if selector.currently_deployed?
         query = query.for_currently_supported_versions(selector.environment_name) if selector.currently_supported?
+        query = query.for_consumer_version_tag(selector.tag) if selector.all_for_tag?
 
         if selector.environment_name && !selector.currently_deployed? && !selector.currently_supported?
           query = query.for_environment(selector.environment_name)
         end
 
-
         # Do the "latest" logic last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
         query = query.latest_for_main_branches if selector.latest_for_main_branch?
         query = query.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?

data/lib/pact_broker/pacts/pact_version.rb

@@ -14,9 +14,13 @@ module PactBroker
       associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
       associate(:many_to_many, :consumer_versions, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id, order: :order)
 
-      one_to_one(:latest_verification, class: "PactBroker::Domain::Verification", key: :pact_version_id, primary_key: :id) do | ds |
-        ds.unlimited.latest_by_pact_version
-      end
+      one_to_one(:latest_verification,
+        class: "PactBroker::Domain::Verification",
+        read_only: true,
+        dataset: lambda { PactBroker::Domain::Verification.where(id: PactBroker::Domain::Verification.select(Sequel.function(:max, :id)).where(pact_version_id: id)) },
+        key: :pact_version_id, primary_key: :id,
+        eager_block: lambda { | ds | ds.latest_by_pact_version }
+      )
 
       # do not eager load this - it won't work because of the limit(1)
       one_through_one(:latest_consumer_version, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id) do | ds |
@@ -26,6 +30,14 @@ module PactBroker
       dataset_module do
         include PactBroker::Repositories::Helpers
 
+        def for_pact_domain(pact_domain)
+          where(
+            sha: pact_domain.pact_version_sha,
+            consumer_id: pact_domain.consumer.id,
+            provider_id: pact_domain.provider.id
+          ).single_record
+        end
+
         def join_successful_verifications
           verifications_join = {
             Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id],
@@ -118,12 +130,14 @@ end
 
 # Table: pact_versions
 # Columns:
-#  id          | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
-#  consumer_id | integer                     | NOT NULL
-#  provider_id | integer                     | NOT NULL
-#  sha         | text                        | NOT NULL
-#  content     | text                        |
-#  created_at  | timestamp without time zone | NOT NULL
+#  id                 | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  consumer_id        | integer                     | NOT NULL
+#  provider_id        | integer                     | NOT NULL
+#  sha                | text                        | NOT NULL
+#  content            | text                        |
+#  created_at         | timestamp without time zone | NOT NULL
+#  messages_count     | integer                     |
+#  interactions_count | integer                     |
 # Indexes:
 #  pact_versions_pkey   | PRIMARY KEY btree (id)
 #  unq_pvc_con_prov_sha | UNIQUE btree (consumer_id, provider_id, sha)
@@ -131,7 +145,7 @@ end
 #  pact_versions_consumer_id_fkey | (consumer_id) REFERENCES pacticipants(id)
 #  pact_versions_provider_id_fkey | (provider_id) REFERENCES pacticipants(id)
 # Referenced By:
-#  pact_publications                                            | pact_publications_pact_version_id_fkey                          | (pact_version_id) REFERENCES pact_versions(id)
-#  verifications                                                | verifications_pact_version_id_fkey                              | (pact_version_id) REFERENCES pact_versions(id)
 #  latest_pact_publication_ids_for_consumer_versions            | latest_pact_publication_ids_for_consumer_v_pact_version_id_fkey | (pact_version_id) REFERENCES pact_versions(id) ON DELETE CASCADE
 #  latest_verification_id_for_pact_version_and_provider_version | latest_v_id_for_pv_and_pv_pact_version_id_fk                    | (pact_version_id) REFERENCES pact_versions(id) ON DELETE CASCADE
+#  pact_publications                                            | pact_publications_pact_version_id_fkey                          | (pact_version_id) REFERENCES pact_versions(id)
+#  verifications                                                | verifications_pact_version_id_fkey                              | (pact_version_id) REFERENCES pact_versions(id)

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -20,8 +20,7 @@ module PactBroker
       include PactBroker::Repositories::Scopes
 
       def find(provider_name, consumer_version_selectors)
-        selected_pacts = find_pacts_by_selector(provider_name, consumer_version_selectors) +
-          find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
+        selected_pacts = find_pacts_by_selector(provider_name, consumer_version_selectors)
         selected_pacts = selected_pacts + find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
         merge_selected_pacts(selected_pacts)
       end
@@ -100,38 +99,58 @@ module PactBroker
         end
       end
 
-      # rubocop: disable Metrics/CyclomaticComplexity
       def find_pacts_by_selector(provider_name, consumer_version_selectors)
         provider = pacticipant_repository.find_by_name(provider_name)
 
-        selectors = if consumer_version_selectors.empty?
-                      Selectors.create_for_overall_latest
-                    else
-                      consumer_version_selectors.select(&:latest_for_tag?) +
-                        consumer_version_selectors.select(&:latest_for_branch?) +
-                        consumer_version_selectors.select(&:latest_for_main_branch?) +
-                        consumer_version_selectors.select(&:overall_latest?) +
-                        consumer_version_selectors.select(&:currently_deployed?) +
-                        consumer_version_selectors.select(&:currently_supported?)
-                    end
-
-        selectors.flat_map do | selector |
+        specified_selectors_or_defaults(consumer_version_selectors, provider).flat_map do | selector |
           query = scope_for(PactPublication).for_provider_and_consumer_version_selector(provider, selector)
           query.all.collect do | pact_publication |
-            resolved_selector = if selector.currently_deployed? || selector.currently_supported?
-                                  environment = environment_service.find_by_name(pact_publication.values.fetch(:environment_name))
-                                  selector.resolve_for_environment(pact_publication.consumer_version, environment, pact_publication.values[:target])
-                                else
-                                  selector.resolve(pact_publication.consumer_version)
-                                end
-            SelectedPact.new(
-              pact_publication.to_domain,
-              Selectors.new(resolved_selector)
-            )
+            create_selected_pact(pact_publication, selector)
+          end
+        end
+      end
+
+      def create_selected_pact(pact_publication, selector)
+        resolved_selector = if selector.currently_deployed? || selector.currently_supported?
+                              environment = environment_service.find_by_name(pact_publication.values.fetch(:environment_name))
+                              selector.resolve_for_environment(pact_publication.consumer_version, environment, pact_publication.values[:target])
+                            else
+                              selector.resolve(pact_publication.consumer_version)
+                            end
+        SelectedPact.new(pact_publication.to_domain, Selectors.new(resolved_selector))
+      end
+
+      def specified_selectors_or_defaults(consumer_version_selectors, provider)
+        if consumer_version_selectors.empty?
+          default_selectors(provider)
+        else
+          consumer_version_selectors
+        end
+      end
+
+      def default_selectors(provider)
+        selectors = selector_for_latest_main_version_or_overall_latest(provider)
+        selectors << Selector.for_currently_deployed
+        selectors << Selector.for_currently_supported
+        selectors
+      end
+
+      def selector_for_latest_main_version_or_overall_latest(provider)
+        selectors = Selectors.new
+        consumers = integration_service.find_for_provider(provider).collect(&:consumer)
+
+        consumers.collect do | consumer |
+          if consumer.main_branch && PactBroker::Domain::Version.for_selector(PactBroker::Matrix::UnresolvedSelector.new(branch: consumer.main_branch, latest: true)).any?
+            selectors << Selector.for_main_branch.for_consumer(consumer.name)
+          elsif consumer.main_branch && PactBroker::Domain::Version.for_selector(PactBroker::Matrix::UnresolvedSelector.new(tag: consumer.main_branch, latest: true)).any?
+            selectors << Selector.latest_for_tag(consumer.main_branch).for_consumer(consumer.name)
+          else
+            selectors << Selector.overall_latest.for_consumer(consumer.name)
           end
         end
+
+        selectors
       end
-      # rubocop: enable Metrics/CyclomaticComplexity
 
       def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
         selectors.collect do | selector |
@@ -148,17 +167,6 @@ module PactBroker
         end.flatten
       end
 
-
-      def find_pacts_for_which_all_versions_for_the_tag_are_required(provider_name, consumer_version_selectors)
-        # The tags for which all versions are specified
-        # Need to move support for this into PactPublication.for_provider_and_consumer_version_selector
-        selectors = consumer_version_selectors.select(&:all_for_tag?)
-
-        selectors.flat_map do | selector |
-          find_all_pact_versions_for_provider_with_consumer_version_tags(provider_name, selector)
-        end
-      end
-
       def find_provider_tags_for_which_pact_publication_id_is_pending(pact_publication, successfully_verified_head_pact_publication_ids_for_each_provider_tag)
         successfully_verified_head_pact_publication_ids_for_each_provider_tag
           .select do | _, pact_publication_ids |
@@ -184,17 +192,6 @@ module PactBroker
           .sort
       end
 
-      # Tag object with created_at date for the first time that tag was created
-      def provider_tag_objects_for(provider, provider_tags_names)
-        PactBroker::Domain::Tag
-          .select_group(Sequel[:tags][:name], Sequel[:pacticipant_id])
-          .select_append(Sequel.function(:min, Sequel[:tags][:created_at]).as(:created_at))
-          .distinct
-          .where(pacticipant_id: provider.id)
-          .where(name: provider_tags_names)
-          .all
-      end
-
       # TODO ? find the WIP pacts by consumer branch
       def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, wip_start_date, specified_pact_version_shas, pact_publication_scope)
         potential_wip_pacts_by_consumer_tag_query = PactPublication.for_provider(provider).created_after(wip_start_date).send(pact_publication_scope)
@@ -262,33 +259,6 @@ module PactBroker
         deduplicate_verifiable_pacts(verifiable_pacts).sort
       end
 
-      def find_all_pact_versions_for_provider_with_consumer_version_tags provider_name, selector
-        provider = pacticipant_repository.find_by_name(provider_name)
-        consumer = selector.consumer ? pacticipant_repository.find_by_name(selector.consumer) : nil
-
-        scope_for(PactPublication)
-          .select_all_qualified
-          .select_append(Sequel[:cv][:order].as(:consumer_version_order))
-          .select_append(Sequel[:ct][:name].as(:consumer_version_tag_name))
-          .remove_overridden_revisions
-          .join_consumer_versions(:cv)
-          .join_consumer_version_tags_with_names(selector.tag)
-          .where(provider: provider)
-          .where_consumer_if_set(consumer)
-          .eager(:consumer)
-          .eager(:consumer_version)
-          .eager(:provider)
-          .eager(:pact_version)
-          .all
-          .group_by(&:pact_version_id)
-          .values
-          .collect do | pact_publications |
-            latest_pact_publication = pact_publications.sort_by{ |p| p.values.fetch(:consumer_version_order) }.last
-            SelectedPact.new(latest_pact_publication.to_domain, Selectors.new(selector).resolve(latest_pact_publication.consumer_version))
-          end
-      end
-
-
       def remove_non_wip_for_branch(pact_publications_query, provider, provider_version_branch, specified_pact_version_shas)
         specified_explicitly = pact_publications_query.for_pact_version_sha(specified_pact_version_shas)
         verified_by_this_branch = pact_publications_query.successfully_verified_by_provider_branch_when_not_wip(provider.id, provider_version_branch)
@@ -319,8 +289,15 @@ module PactBroker
 
       def collect_consumer_name_and_version_number(pact_publications_query)
         pact_publications_query.eager(:provider).eager(:consumer).eager(:consumer_version).order(:consumer_version_order).all.sort.collect do |p|
-          tag_suffix = p.values[:tag_name] ? " (tag #{p.values[:tag_name]})" : ""
-          "#{p.consumer_name} #{p.consumer_version_number}" + tag_suffix
+          suffix =  if p.values[:tag_name]
+                      " (tag #{p.values[:tag_name]})"
+                    elsif p.values[:branch]
+                      " (branch #{p.values[:branch]})"
+                    else
+                      ""
+                    end
+
+          "#{p.consumer_name} #{p.consumer_version_number}" + suffix
         end
       end