pact_broker 2.96.0 → 2.99.0

data/lib/pact_broker/pacts/pact_publication.rb

@@ -20,12 +20,11 @@ module PactBroker
       delegate [:consumer_version_number, :name, :provider_name, :consumer_name] => :cached_domain_for_delegation
 
       set_primary_key :id
-      associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id, forbid_lazy_load: false)
-      associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id], forbid_lazy_load: false)
-
+      associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
+      associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
+      associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
+      associate(:many_to_one, :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], read_only: true, forbid_lazy_load: false)
       # TODO rename to consumer_version_tags
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :key => :version_id, :primary_key => :consumer_version_id)
 
@@ -57,6 +56,10 @@ module PactBroker
         include PactPublicationDatasetModule
         include PactPublicationCleanSelectorDatasetModule
         include PactPublicationWipDatasetModule
+
+        def eager_for_domain_with_content
+          eager(:tags, :consumer, :provider, :consumer_version, :pact_version)
+        end
       end
 
       def self.subtract(a, *b)

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -111,7 +111,32 @@ module PactBroker
           .limit(1)
       end
 
+      # Return the pacts (if they exist) for the branch heads.
+      # This uses the new logic of finding the branch head and returning any associated pacts,
+      # rather than the old logic of returning the pact for the latest version
+      # on the branch that had a pact.
+      def for_branch_heads(branch_name)
+        branch_head_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_heads][:version_id],
+        }
+
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:branch_heads][:branch_name].as(:branch_name))
+        end
+
+        base_query
+          .join(:branch_heads, branch_head_join) do
+            name_like(Sequel[:branch_heads][:branch_name], branch_name)
+          end
+          .remove_overridden_revisions_from_complete_query
+      end
+
       def latest_for_consumer_branch(branch_name)
+        for_branch_heads(branch_name)
+      end
+
+      def old_latest_for_consumer_branch(branch_name)
         branch_versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_versions][:version_id]
         }

data/lib/pact_broker/pacts/pact_publication_wip_dataset_module.rb

@@ -47,21 +47,6 @@ module PactBroker
       end
 
       def successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider_id, provider_tag)
-        return new_successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider_id, provider_tag) if PactBroker.feature_enabled?(:new_wip_calculation)
-
-        first_tag_with_name = PactBroker::Domain::Tag.where(pacticipant_id: provider_id, name: provider_tag).order(:created_at).first
-        from_self(alias: :pp)
-          .select(Sequel[:pp].*)
-          .where(Sequel[:pp][:provider_id] => provider_id)
-          .join_successful_non_wip_verifications_for_provider_id(provider_id)
-          .join_provider_version_tags do
-            Sequel.lit("provider_tags.name != ?", provider_tag)
-          end
-          .verified_before_creation_date_of(first_tag_with_name)
-          .distinct
-      end
-
-      def new_successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider_id, provider_tag)
         first_tag_with_name = PactBroker::Domain::Tag.where(pacticipant_id: provider_id, name: provider_tag).order(:created_at).first
 
         pact_version_provider_tag_verifications_join = {

data/lib/pact_broker/pacts/pact_version.rb

@@ -1,39 +1,32 @@
 require "sequel"
 require "pact_broker/repositories/helpers"
-require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
 require "pact_broker/pacts/content"
+require "pact_broker/pacts/pact_version_association_loaders"
 
 module PactBroker
   module Pacts
     class PactVersion < Sequel::Model(:pact_versions)
+      include PactVersionAssociationLoaders
+
       plugin :timestamps
       plugin :upsert, identifying_columns: [:consumer_id, :provider_id, :sha]
 
-      one_to_many :pact_publications, reciprocal: :pact_version
-      one_to_many :verifications, reciprocal: :verification, order: :id, class: "PactBroker::Domain::Verification"
-      associate(:many_to_one, :provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
-      associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
-      associate(:many_to_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_many(:pact_publications, reciprocal: :pact_version)
+      one_to_many(:verifications, reciprocal: :verification, order: :id, class: "PactBroker::Domain::Verification")
+      many_to_one(:provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
+      many_to_one(:consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
+      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_main_branch_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,
-        dataset: lambda {
-          providers_join = {
-            Sequel[:providers][:id] => Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_id]
-          }
-
-          branch_versions_join = {
-            Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_version_id] => Sequel[:branch_versions][:version_id],
-            Sequel[:providers][:main_branch] => Sequel[:branch_versions][:branch_name]
-          }
-          max_verification_id_for_pact_version =  PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion
-                                                    .join(:pacticipants, providers_join, { table_alias: :providers })
-                                                    .join(:branch_versions, branch_versions_join)
-                                                    .select(Sequel.function(:max, :verification_id))
-                                                    .where(pact_version_id: id)
-          PactBroker::Domain::Verification.where(id: max_verification_id_for_pact_version)
-        },
+        dataset: LATEST_MAIN_BRANCH_VERIFICATION,
         key: :pact_version_id,
         primary_key: :id,
         eager_block: lambda { | ds | ds.from_provider_main_branch.latest_by_pact_version }
@@ -42,15 +35,18 @@ module PactBroker
       one_to_one(:latest_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,
-        dataset: lambda { PactBroker::Domain::Verification.where(id: PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion.select(Sequel.function(:max, :verification_id)).where(pact_version_id: id)) },
+        dataset: LATEST_VERIFICATION_DATASET,
         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 |
-        ds.unlimited.order(Sequel.desc(:order)).limit(1)
-      end
+      one_through_one(:latest_consumer_version,
+        class: "PactBroker::Domain::Version",
+        join_table: :pact_publications,
+        left_key: :pact_version_id,
+        right_key: :consumer_version_id, &LATEST_CONSUMER_VERSION_LAZY_LOADER
+      )
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -89,11 +85,11 @@ module PactBroker
       end
 
       def provider_name
-        pact_publications.last.provider.name
+        provider.name
       end
 
       def consumer_name
-        pact_publications.last.consumer.name
+        consumer.name
       end
 
       def latest_pact_publication

data/lib/pact_broker/pacts/pact_version_association_loaders.rb

@@ -0,0 +1,36 @@
+require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
+
+module PactBroker
+  module Pacts
+    module PactVersionAssociationLoaders
+
+      LATEST_MAIN_BRANCH_VERIFICATION = lambda {
+        providers_join = {
+          Sequel[:providers][:id] => Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_id]
+        }
+
+        branch_versions_join = {
+          Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_version_id] => Sequel[:branch_versions][:version_id],
+          Sequel[:providers][:main_branch] => Sequel[:branch_versions][:branch_name]
+        }
+        max_verification_id_for_pact_version =  PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion
+                                                  .join(:pacticipants, providers_join, { table_alias: :providers })
+                                                  .join(:branch_versions, branch_versions_join)
+                                                  .select(Sequel.function(:max, :verification_id))
+                                                  .where(pact_version_id: id)
+        PactBroker::Domain::Verification.where(id: max_verification_id_for_pact_version)
+      }
+
+      LATEST_VERIFICATION_DATASET = lambda {
+        PactBroker::Domain::Verification
+          .where(
+            id: PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion.select(
+              Sequel.function(:max, :verification_id)
+            ).where(pact_version_id: id)
+          )
+      }
+
+      LATEST_CONSUMER_VERSION_LAZY_LOADER = lambda { | ds | ds.unlimited.order(Sequel.desc(:order)).limit(1) }
+    end
+  end
+end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -23,7 +23,7 @@ module PactBroker
         :provider,
         :consumer,
         :consumer_version,
-        pact_version: :latest_verification
+        :pact_version
       ]
 
       def find(provider_name, consumer_version_selectors)
@@ -162,16 +162,14 @@ module PactBroker
 
       def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
         selectors.collect do | selector |
-          query = scope_for(PactPublication).for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
+          query = scope_for(PactPublication).eager_for_domain_with_content.for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
           query = query.for_consumer_name(selector.consumer) if selector.consumer
-          query.all
-            .collect do | latest_tagged_pact_publication |
-              pact_publication = unscoped(PactPublication).find(id: latest_tagged_pact_publication.id)
-              SelectedPact.new(
-                pact_publication.to_domain,
-                Selectors.new(selector.resolve_for_fallback(pact_publication.consumer_version))
-              )
-            end
+          query.all.collect do | pact_publication |
+            SelectedPact.new(
+              pact_publication.to_domain,
+              Selectors.new(selector.resolve_for_fallback(pact_publication.consumer_version))
+            )
+          end
         end.flatten
       end
 
@@ -300,9 +298,7 @@ module PactBroker
 
       def collect_consumer_name_and_version_number(pact_publications_query)
         pact_publications = pact_publications_query
-                              .eager(:provider)
-                              .eager(:consumer)
-                              .eager(:consumer_version)
+                              .eager(:consumer, :consumer_version)
                               .order(:consumer_version_order)
                               .all_forbidding_lazy_load
                               .sort

data/lib/pact_broker/pacts/repository.rb

@@ -7,7 +7,6 @@ require "pact_broker/pacts/pact_version"
 require "pact/shared/json_differ"
 require "pact_broker/domain"
 require "pact_broker/pacts/parse"
-require "pact_broker/matrix/head_row"
 require "pact_broker/pacts/latest_pact_publication_id_for_consumer_version"
 require "pact_broker/pacts/verifiable_pact"
 require "pact_broker/repositories/helpers"
@@ -117,8 +116,8 @@ module PactBroker
 
       def find_all_pact_versions_between consumer_name, options
         find_all_database_versions_between(consumer_name, options)
-          .eager(:tags)
           .reverse_order(:consumer_version_order)
+          .all
           .collect(&:to_domain)
       end
 
@@ -143,7 +142,7 @@ module PactBroker
       def find_latest_pacts_for_provider provider_name, tag = nil
         query = scope_for(PactPublication)
                   .for_provider_name(provider_name)
-                  .eager(:consumer)
+                  .eager_for_domain_with_content
 
         if tag
           query = query.latest_for_consumer_tag(tag)
@@ -151,7 +150,7 @@ module PactBroker
           query = query.overall_latest
         end
 
-        query.sort_by{ | p| p.consumer_name.downcase }.collect(&:to_head_pact)
+        query.all.sort_by{ | p| p.consumer_name.downcase }.collect(&:to_head_pact)
       end
 
       def find_for_verification(provider_name, consumer_version_selectors)
@@ -165,41 +164,45 @@ module PactBroker
       def find_pact_versions_for_provider provider_name, tag = nil
         query = scope_for(PactPublication)
             .select_all_qualified
+            .eager_for_domain_with_content
             .for_provider_name(provider_name)
-            .eager(:consumer)
-            .eager(:provider)
         query = query.for_consumer_version_tag(tag) if tag
-        query.collect(&:to_domain).sort
+        query.all.collect(&:to_domain).sort
       end
 
       # Returns latest pact version for the consumer_version_number
       def find_by_consumer_version consumer_name, consumer_version_number
         scope_for(PactPublication)
+          .eager_for_domain_with_content
           .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
           .remove_overridden_revisions_from_complete_query
+          .all
           .collect(&:to_domain_with_content)
       end
 
       def find_by_version_and_provider version_id, provider_id
         scope_for(PactPublication)
-          .eager(:tags)
+          .eager_for_domain_with_content
           .where(consumer_version_id: version_id, provider_id: provider_id)
           .remove_overridden_revisions_from_complete_query
           .limit(1)
+          .all
           .collect(&:to_domain_with_content)[0]
       end
 
       def find_latest_pacts
         scope_for(PactPublication)
+          .eager_for_domain_with_content
           .overall_latest
-          .eager(:consumer)
           .eager(:provider)
+          .all
           .collect(&:to_domain)
           .sort
       end
 
       def find_latest_pact(consumer_name, provider_name, tag = nil)
         query = scope_for(PactPublication)
+          .eager_for_domain_with_content
           .select_all_qualified
           .for_consumer_name(consumer_name)
           .for_provider_name(provider_name)
@@ -214,7 +217,7 @@ module PactBroker
 
       # Allows optional consumer_name and provider_name
       def search_for_latest_pact(consumer_name, provider_name, tag = nil)
-        query = scope_for(PactPublication).select_all_qualified
+        query = scope_for(PactPublication).select_all_qualified.eager_for_domain_with_content
         query = query.for_consumer_name(consumer_name) if consumer_name
         query = query.for_provider_name(provider_name) if provider_name
 
@@ -233,6 +236,7 @@ module PactBroker
       # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def find_pact consumer_name, consumer_version_number, provider_name, pact_version_sha = nil
         pact_publication_by_consumer_version = scope_for(PactPublication)
+            .eager_for_domain_with_content
             .select_all_qualified
             .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
             .for_provider_name(provider_name)
@@ -240,6 +244,7 @@ module PactBroker
             .limit(1)
 
         latest_pact_publication_by_sha = scope_for(PactPublication)
+            .eager_for_domain_with_content
             .select_all_qualified
             .for_consumer_name(consumer_name)
             .for_provider_name(provider_name)
@@ -249,46 +254,39 @@ module PactBroker
 
         if consumer_version_number && !pact_version_sha
           pact_publication_by_consumer_version
-            .eager(:tags)
-            .all_allowing_lazy_load
-            .collect(&:to_domain_with_content).first
+            .first&.to_domain_with_content
         elsif pact_version_sha && !consumer_version_number
           latest_pact_publication_by_sha
-            .eager(:tags)
-            .collect(&:to_domain_with_content).first
+            .first&.to_domain_with_content
         elsif consumer_version_number && pact_version_sha
-          pact_publication = pact_publication_by_consumer_version.all_allowing_lazy_load.first
+          pact_publication = pact_publication_by_consumer_version.first
           if pact_publication && pact_publication.pact_version.sha == pact_version_sha
-            pact_publication.tags
             pact_publication.to_domain_with_content
           else
-            latest_pact_publication_by_sha
-              .eager(:tags)
-              .all_allowing_lazy_load
-              .collect(&:to_domain_with_content).first
+            latest_pact_publication_by_sha.first&.to_domain_with_content
           end
         else
           pact_publication_by_consumer_version
-            .eager(:tags)
             .reverse_order(:consumer_version_order, :revision_number)
-            .all_allowing_lazy_load
-            .collect(&:to_domain_with_content).first
+            .first&.to_domain_with_content
         end
       end
       # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       def find_all_revisions consumer_name, consumer_version_number, provider_name
         scope_for(PactPublication)
+          .eager_for_domain_with_content
           .for_provider_name(provider_name)
           .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
           .order_by_consumer_version_order
+          .all
           .collect(&:to_domain_with_content)
       end
 
       def find_previous_pact pact, tag = nil
         query = scope_for(PactPublication)
+            .eager_for_domain_with_content
             .remove_overridden_revisions
-            .eager(:tags)
             .for_consumer_name(pact.consumer.name)
             .for_provider_name(pact.provider.name)
 
@@ -301,17 +299,19 @@ module PactBroker
         query
           .consumer_version_order_before(pact.consumer_version.order)
           .latest_by_consumer_version_order
+          .all
           .collect(&:to_domain_with_content)[0]
       end
 
       def find_next_pact pact
         scope_for(PactPublication)
-          .eager(:tags)
+          .eager_for_domain_with_content
           .for_consumer_name(pact.consumer.name)
           .for_provider_name(pact.provider.name)
           .remove_overridden_revisions
           .consumer_version_order_after(pact.consumer_version.order)
           .earliest
+          .all_allowing_lazy_load
           .collect(&:to_domain_with_content)[0]
       end
 
@@ -343,12 +343,13 @@ module PactBroker
       def find_previous_distinct_pact_by_sha pact
         pact_version = PactVersion.for_pact_domain(pact)
         scope_for(PactPublication)
-          .eager(:tags)
+          .eager_for_domain_with_content
           .for_consumer_name(pact.consumer.name)
           .for_provider_name(pact.provider.name)
           .consumer_version_order_before(pact.consumer_version.order)
           .exclude(pact_version_id: pact_version.id)
           .latest_by_consumer_version_order
+          .all_allowing_lazy_load
           .collect(&:to_domain_with_content)[0]
       end
 
@@ -377,6 +378,7 @@ module PactBroker
         provider_name = options.fetch(:and)
 
         query = scope_for(PactPublication)
+          .eager_for_domain_with_content
           .for_consumer_name(consumer_name)
           .for_provider_name(provider_name)
           .remove_overridden_revisions

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -57,6 +57,8 @@ module PactBroker
 
       def create_version(pacticipant:, version:, branch: nil)
         if branch
+          puts "Adding #{pacticipant} version #{version} to branch #{branch}"
+          puts ""
           client.put("pacticipants/#{encode(pacticipant)}/branches/#{encode(branch)}/versions/#{encode(version)}", {}).tap { |response| check_for_error(response) }
         else
           client.put("pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}").tap { |response| check_for_error(response) }
@@ -74,8 +76,15 @@ module PactBroker
       def record_deployment(pacticipant:, version:, environment_name:)
         puts "Recording deployment of #{pacticipant} version #{version} to #{environment_name}"
         version_body = client.get("/pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}").tap { |response| check_for_error(response) }.body
+
         environment_relation = version_body["_links"]["pb:record-deployment"].find { |relation| relation["name"] == environment_name }
-        client.post(environment_relation["href"], { replacedPreviousDeployedVersion: true }).tap { |response| check_for_error(response) }
+        if environment_relation.nil?
+          available_environments = version_body["_links"]["pb:record-deployment"].collect{ | relation | relation["name"]}.join
+          puts "Environment with name #{environment_name} not found. Available environments: #{available_environments}"
+        else
+          client.post(environment_relation["href"]).tap { |response| check_for_error(response) }
+        end
+
         separate
         self
       end
@@ -84,7 +93,7 @@ module PactBroker
         puts "Recording release of #{pacticipant} version #{version} to #{environment_name}"
         version_body = client.get("/pacticipants/#{encode(pacticipant)}/versions/#{encode(version)}").tap { |response| check_for_error(response) }.body
         environment_relation = version_body["_links"]["pb:record-release"].find { |relation| relation["name"] == environment_name }
-        client.post(environment_relation["href"], { replacedPreviousDeployedVersion: true }).tap { |response| check_for_error(response) }
+        client.post(environment_relation["href"]).tap { |response| check_for_error(response) }
         separate
         self
       end

data/lib/pact_broker/test/test_data_builder.rb

@@ -25,7 +25,6 @@ require "pact_broker/verifications/service"
 require "pact_broker/tags/repository"
 require "pact_broker/webhooks/repository"
 require "pact_broker/certificates/certificate"
-require "pact_broker/matrix/row"
 require "pact_broker/deployments/environment_service"
 require "pact_broker/deployments/deployed_version_service"
 require "pact_broker/deployments/released_version_service"
@@ -260,6 +259,8 @@ module PactBroker
         set_created_at_if_set(params[:created_at], :pact_versions, sha: @pact.pact_version_sha) if pact_versions_count_after > pact_versions_count_before
         set_created_at_if_set(params[:created_at], :latest_pact_publication_ids_for_consumer_versions, consumer_version_id: @consumer_version.id)
         @pact = PactBroker::Pacts::PactPublication.find(id: @pact.id).to_domain
+        consumer_version.reload
+        consumer_version.pact_publications.each{ | pp | pp.allow_lazy_load if pp.respond_to?(:allow_lazy_load) }
         self
       end
 

data/lib/pact_broker/ui/controllers/matrix.rb

@@ -46,19 +46,22 @@ module PactBroker
         end
 
         get "/provider/:provider_name/consumer/:consumer_name" do
-          selectors = [ PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:consumer_name]), PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:provider_name]) ]
-          options = {latestby: "cvpv", limit: 100}
+          selectors = [
+                        PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:consumer_name]),
+                        PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:provider_name])
+                      ]
+          options = { latestby: "cvpv", limit: 100 }
           lines = matrix_service.find(selectors, options)
           lines = PactBroker::UI::ViewDomain::MatrixLines.new(lines, base_url: base_url)
-          locals = {
-            lines: lines,
-            consumer_name: params[:consumer_name],
-            provider_name: params[:provider_name],
-            selectors: create_selector_objects(selectors),
-            options: create_options_model(options),
-            badge_url: nil,
-            base_url: base_url
-          }
+          locals =  {
+                      lines: lines,
+                      consumer_name: params[:consumer_name],
+                      provider_name: params[:provider_name],
+                      selectors: create_selector_objects(selectors),
+                      options: create_options_model(options),
+                      badge_url: nil,
+                      base_url: base_url
+                    }
           haml :'matrix/show', { locals: locals, layout: :'layouts/main', escape_html: true }
         end
       end

data/lib/pact_broker/ui/views/groups/show.html.erb

@@ -6,7 +6,7 @@
 <html lang="en">
 <head>
 <meta charset="utf-8">
-<title><%= pacticipant_name %></title>
+<title><%= escape_html(pacticipant_name) %></title>
 <link rel='shortcut icon' href='<%= base_url %>/favicon.ico' type='image/x-icon'/>
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="description" content="">
@@ -69,7 +69,7 @@ svg{
         Main branch:
       </div>
       <div class="col col-md-6">
-        <%= pacticipant.main_branch %>
+        <%= escape_html(pacticipant.main_branch) %>
       </div>
     </div>
     <div class="row">

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.96.0"
+  VERSION = "2.99.0"
 end

data/pact_broker.gemspec

@@ -73,7 +73,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "dry-logic", "0.4.2" # Later version cases ArgumentError: wrong number of arguments
   gem.add_runtime_dependency "table_print", "~> 1.5"
   gem.add_runtime_dependency "semantic_logger", "~> 4.3"
-  gem.add_runtime_dependency "sanitize", ">= 5.2.1", "~> 5.2"
+  gem.add_runtime_dependency "sanitize", "6.0"
   gem.add_runtime_dependency "wisper", "~> 2.0"
   gem.add_runtime_dependency "anyway_config", "~> 2.1"
   gem.add_runtime_dependency "request_store", "~> 1.5"