pact_broker 2.80.0 → 2.81.0

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

@@ -0,0 +1,41 @@
+require "pact_broker/pacts/content"
+
+module PactBroker
+  module DB
+    module DataMigrations
+      class SetInteractionsCounts
+        def self.call(connection)
+          self_join = {
+            Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+            Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id]
+          }
+
+          pact_versions_join = {
+            Sequel[:pact_versions][:id] => Sequel[:pact_publications][:pact_version_id],
+            Sequel[:pact_versions][:interactions_count] => nil,
+            Sequel[:pact_versions][:messages_count] => nil
+          }
+
+          base_query = connection[:pact_publications]
+          base_query = base_query.select(Sequel[:pact_versions][:id], Sequel[:pact_versions][:content])
+
+          latest_pact_publications_query = base_query.left_join(base_query.select(:consumer_id, :provider_id, :consumer_version_order), self_join, { table_alias: :pp2 } ) do
+            Sequel[:pp2][:consumer_version_order] > Sequel[:pact_publications][:consumer_version_order]
+          end
+          .join(:pact_versions, pact_versions_join)
+          .where(Sequel[:pp2][:consumer_version_order] => nil)
+
+          latest_pact_publications_query.each do | row |
+            content = PactBroker::Pacts::Content.from_json(row[:content])
+            connection.from(:pact_versions)
+              .where(id: row[:id])
+              .update(
+                messages_count: content.messages&.count || 0,
+                interactions_count: content.interactions&.count || 0
+              )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/migrate_data.rb

@@ -25,6 +25,8 @@ module PactBroker
         DataMigrations::SetPacticipantDisplayName.call(database_connection)
         DataMigrations::SetPacticipantMainBranch.call(database_connection)
         DataMigrations::SetWebhookUuid.call(database_connection)
+        DataMigrations::SetConsumerVersionOrderForPactPublications.call(database_connection)
+        DataMigrations::SetExtraColumnsForTags.call(database_connection)
       end
     end
   end

data/lib/pact_broker/db/seed_example_data.rb

@@ -11,6 +11,7 @@ module PactBroker
         new.call
       end
 
+      # rubocop: disable Metrics/MethodLength
       def call(consumer_name: CONSUMER_NAME, provider_name: PROVIDER_NAME)
         return unless database_empty?
         PactBroker::Test::TestDataBuilder.new
@@ -31,6 +32,9 @@ module PactBroker
           .create_consumer_version("725c6ccb7cf7efc51b4394f9828585eea9c379d9", branch: "feat/new-thing", created_at: days_ago(7))
           .create_consumer_version_tag("feat-new-thing", created_at: days_ago(7))
           .create_pact(json_content: pact_2, created_at: days_ago(7))
+          .create_consumer_version("6c992f831da299364cf31be6008ee4752189f6d4", branch: "feat/new-thing", created_at: days_ago(6))
+          .create_consumer_version_tag("feat-new-thing", created_at: days_ago(6))
+          .create_pact(json_content: pact_2, created_at: days_ago(7))
           .create_consumer_version("7bd4d9173522826dc3e8704fd62dde0424f4c827", branch: "main", created_at: days_ago(1))
           .create_consumer_version_tag("main", created_at: days_ago(1))
           .create_pact(json_content: pact_3, created_at: days_ago(1))
@@ -42,6 +46,7 @@ module PactBroker
           .create_deployed_version_for_consumer_version(environment_name: "test", created_at: days_ago(0.5))
           .republish_same_pact(created_at: days_ago(0.5))
       end
+      # rubocop: enable Metrics/MethodLength
 
       def database_empty?
         PactBroker::Pacticipants::Service.find_all_pacticipants.empty?

data/lib/pact_broker/deployments/deployed_version_service.rb

@@ -13,15 +13,19 @@ module PactBroker
         DeployedVersion.where(uuid: uuid).single_record
       end
 
-      def self.create(uuid, version, environment, target)
-        record_previous_version_undeployed(version.pacticipant, environment, target)
-        DeployedVersion.create(
-          uuid: uuid,
-          version: version,
-          pacticipant_id: version.pacticipant_id,
-          environment: environment,
-          target: target
-        )
+      def self.find_or_create(uuid, version, environment, target)
+        if (deployed_version = find_currently_deployed_version_for_version_and_environment_and_target(version, environment, target))
+          deployed_version
+        else
+          record_previous_version_undeployed(version.pacticipant, environment, target)
+          DeployedVersion.create(
+            uuid: uuid,
+            version: version,
+            pacticipant_id: version.pacticipant_id,
+            environment: environment,
+            target: target
+          )
+        end
       end
 
       def self.find_deployed_versions_for_version_and_environment(version, environment)

data/lib/pact_broker/domain/verification.rb

@@ -27,6 +27,30 @@ module PactBroker
       dataset_module do
         include PactBroker::Repositories::Helpers
 
+        def for_provider_name(provider_name)
+          where(provider: PactBroker::Domain::Pacticipant.find_by_name(provider_name))
+        end
+
+        def for_consumer_name(consumer_name)
+          where(consumer: PactBroker::Domain::Pacticipant.find_by_name(consumer_name))
+        end
+
+        def latest_by_pact_version
+          base_query = self
+          base_join = {
+            Sequel[:verifications][:pact_version_id] => Sequel[:v2][:pact_version_id]
+          }
+
+          if no_columns_selected?
+            base_query = base_query.select_all_qualified
+          end
+
+          base_query.left_join(base_query.select(Sequel[:verifications][:id], Sequel[:verifications][:pact_version_id]), base_join, { table_alias: :v2 }) do
+            Sequel[:v2][:id] > Sequel[:verifications][:id]
+          end
+          .where(Sequel[:v2][:id] => nil)
+        end
+
         def latest_verification_ids_for_all_consumer_version_tags
           verif_pact_join = { Sequel[:verifications][:pact_version_id] => Sequel[:lpp][:pact_version_id] }
           tag_join = { Sequel[:lpp][:consumer_version_id] => Sequel[:cvt][:version_id] }
@@ -103,6 +127,10 @@ module PactBroker
             .join(latest_ids_for_cv_tags, join_cols, { table_alias: :t2 })
         end
 
+        def remove_verifications_for_overridden_consumer_versions
+          join(:latest_pact_publication_ids_for_consumer_versions, { pact_version_id: :pact_version_id } )
+        end
+
         # Expects to be joined with AllPactPublications or subclass
         # Beware that when columns with the same name exist in both datasets
         # you may get the wrong column back in your model.
@@ -143,6 +171,18 @@ module PactBroker
             .left_outer_join(:tags, {version_id: :consumer_version_id})
             .where(Sequel.qualify(:tags, :name) => nil)
         end
+
+        def join_pact_publications
+          join(:pact_publications, { Sequel[:pact_publications][:pact_version_id] => Sequel[:verifications][:pact_version_id] })
+        end
+
+        def for_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
+          consumer_versions = PactBroker::Domain::Version.select(:id).where_pacticipant_name_and_version_number(consumer_name, consumer_version_number)
+          join(:pact_publications, {
+            Sequel[:pact_publications][:pact_version_id] => Sequel[:verifications][:pact_version_id],
+            Sequel[:pact_publications][:consumer_version_id] => consumer_versions
+          })
+        end
       end
 
       def pact_version_sha

data/lib/pact_broker/domain/version.rb

@@ -62,6 +62,10 @@ module PactBroker
           where_pacticipant_name(pacticipant_name).where_number(version_number).single_record
         end
 
+        def where_pacticipant_name_and_version_number(pacticipant_name, version_number)
+          where_pacticipant_name(pacticipant_name).where_number(version_number)
+        end
+
         def first_for_pacticipant_id_and_branch(pacticipant_id, branch)
           where(pacticipant_id: pacticipant_id, branch: branch).order(:created_at).first
         end

data/lib/pact_broker/index/service.rb

@@ -102,9 +102,9 @@ module PactBroker
         end
       end
 
-      def self.find_index_items_for_api(consumer_name: nil, provider_name: nil, **_ignored)
+      def self.find_index_items_for_api(consumer_name: nil, provider_name: nil, page_number: nil, page_size: nil, **_ignored)
         latest_pp_ids = latest_pact_publication_ids
-        pact_publications = head_pact_publications(consumer_name: consumer_name, provider_name: provider_name, tags: true)
+        pact_publications = head_pact_publications(consumer_name: consumer_name, provider_name: provider_name, tags: true, page_number: page_number, page_size: page_size)
           .eager(:consumer)
           .eager(:provider)
           .eager(:pact_version)
@@ -173,7 +173,7 @@ module PactBroker
         ]
 
         query.order(*order_columns)
-             .paginate(options[:page_number] || DEFAULT_PAGE_NUMBER, options[:page_size] || DEFAULT_PAGE_SIZE)
+          .paginate(options[:page_number] || DEFAULT_PAGE_NUMBER, options[:page_size] || DEFAULT_PAGE_SIZE)
       end
 
       # eager loading the tag stuff doesn't seem to make it quicker
@@ -196,8 +196,7 @@ module PactBroker
       def self.query_pact_publication_ids_by_tags(base, tags)
         latest = base.overall_latest
         return latest.union(base.latest_for_consumer_tag(tags)) if tags.is_a?(Array)
-        return latest.union(base.latest_by_consumer_tag) if tags
-
+        return latest.union(base.latest_by_consumer_tag).union(base.for_environment(nil)) if tags
         latest
       end
 

data/lib/pact_broker/integrations/integration.rb

@@ -7,26 +7,47 @@ require "pact_broker/webhooks/webhook"
 module PactBroker
   module Integrations
     class Integration < Sequel::Model
+      set_primary_key [:consumer_id, :provider_id]
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
       associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
-      associate(:one_to_one, :latest_pact, :class => "PactBroker::Pacts::LatestPactPublications", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
       associate(:one_to_one, :latest_verification, :class => "PactBroker::Verifications::LatestVerificationForConsumerAndProvider", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
       associate(:one_to_many, :latest_triggered_webhooks, :class => "PactBroker::Webhooks::LatestTriggeredWebhook", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
 
+      # When viewing the index, every latest_pact in the database will match at least one of the rows, so
+      # it makes sense to load the entire table and match each pact to the appropriate row.
+      # Update: now we have pagination, we should probably filter the pacts by consumer/provider id.
+      LATEST_PACT_EAGER_LOADER = proc do |eo_opts|
+        eo_opts[:rows].each do |integration|
+          integration.associations[:latest_pact] = []
+        end
+
+        PactBroker::Pacts::PactPublication.overall_latest.each do | pact |
+          eo_opts[:rows].each do | integration |
+            if integration.consumer_id == pact.consumer_id && integration.provider_id == pact.provider_id
+              integration.associations[:latest_pact] = pact
+            end
+          end
+        end
+      end
+
+      one_to_one(:latest_pact, class: "PactBroker::Pacts::PactPublication", :key => [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id], :eager_loader=> LATEST_PACT_EAGER_LOADER) do | _ds |
+        PactBroker::Pacts::PactPublication.overall_latest_for_consumer_id_and_provider_id(consumer_id, provider_id)
+      end
+
       # When viewing the index, every webhook in the database will match at least one of the rows, so
       # it makes sense to load the entire table and match each webhook to the appropriate row.
       # This will only work when using eager loading. The keys are just blanked out to avoid errors.
       # I don't understand how they work at all.
       # It would be nice to do this declaratively.
       many_to_many :webhooks, class: "PactBroker::Webhooks::Webhook", :left_key => [], left_primary_key: [], :eager_loader=>(proc do |eo_opts|
-        eo_opts[:rows].each do |row|
-          row.associations[:webhooks] = []
+        eo_opts[:rows].each do |integration|
+          integration.associations[:webhooks] = []
         end
 
         PactBroker::Webhooks::Webhook.each do | webhook |
-          eo_opts[:rows].each do | row |
-            if webhook.is_for?(row)
-              row.associations[:webhooks] << webhook
+          eo_opts[:rows].each do | integration |
+            if webhook.is_for?(integration)
+              integration.associations[:webhooks] << webhook
             end
           end
         end

data/lib/pact_broker/logging.rb

@@ -31,6 +31,16 @@ module PactBroker
       end
     end
 
+    def log_with_tag(tag)
+      if logger.respond_to?(:tagged)
+        logger.tagged(tag) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
     def log_error e, description = nil
       if logger.instance_of?(SemanticLogger::Logger)
         if description

data/lib/pact_broker/matrix/unresolved_selector.rb

@@ -78,7 +78,7 @@ module PactBroker
       end
 
       def all_for_pacticipant?
-        !!pacticipant_name && !pacticipant_version_number && !tag && !latest && !environment_name && !max_age
+        !!pacticipant_name && !pacticipant_version_number && !tag && !branch && !latest && !environment_name && !max_age
       end
 
       def latest_for_pacticipant_and_tag?

data/lib/pact_broker/metrics/service.rb

@@ -22,6 +22,7 @@ module PactBroker
       # rubocop: disable Metrics/MethodLength
       def metrics
         {
+          interactions: interactions_counts,
           pacticipants: {
             count: PactBroker::Domain::Pacticipant.count
           },
@@ -74,6 +75,22 @@ module PactBroker
       end
       # rubocop: enable Metrics/MethodLength
 
+      def interactions_counts
+        latest_pact_versions = PactBroker::Pacts::PactVersion.where(
+          id: PactBroker::Pacts::PactPublication.overall_latest.from_self.select(:pact_version_id)
+        )
+        counts = latest_pact_versions
+          .select(
+            Sequel.function(:sum, :interactions_count).as(:interactions_count),
+            Sequel.function(:sum, :messages_count).as(:messages_count)
+        ).first
+        {
+          latestInteractionsCount: counts[:interactions_count] || 0,
+          latestMessagesCount: counts[:messages_count] || 0,
+          latestInteractionsAndMessagesCount: (counts[:interactions_count] || 0) + (counts[:messages_count] || 0)
+        }
+      end
+
       def pact_revision_counts
         query = "select revision_count as number_of_revisions, count(consumer_version_id) as consumer_version_count
           from (select consumer_version_id, count(*) as revision_count from pact_publications group by consumer_version_id) foo

data/lib/pact_broker/pacts/all_pact_publications.rb

@@ -17,6 +17,7 @@ module PactBroker
       associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :reciprocal => :version, :key => :version_id, :primary_key => :consumer_version_id)
       associate(:many_to_one, :pact_version, :key => :pact_version_id, :primary_key => :id)
       associate(:many_to_one, :latest_verification, :class => "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_id)
+      associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -98,7 +99,8 @@ module PactBroker
         consumer.id = consumer_id
         provider = Domain::Pacticipant.new(name: provider_name)
         provider.id = provider_id
-        consumer_version = OpenStruct.new(
+        consumer_version_struct = OpenStruct.new(
+          id: consumer_version_id,
           number: consumer_version_number,
           order: consumer_version_order,
           pacticipant: consumer,
@@ -107,7 +109,7 @@ module PactBroker
         Domain::Pact.new(
           id: id,
           consumer: consumer,
-          consumer_version: consumer_version,
+          consumer_version: consumer_version_struct,
           provider: provider,
           consumer_version_number: consumer_version_number,
           revision_number: revision_number,

data/lib/pact_broker/pacts/content.rb

@@ -95,11 +95,11 @@ module PactBroker
       end
 
       def messages
-        pact_hash.is_a?(Hash) ? pact_hash["messages"] : nil
+        pact_hash.is_a?(Hash) && pact_hash["messages"].is_a?(Array) ? pact_hash["messages"] : nil
       end
 
       def interactions
-        pact_hash.is_a?(Hash) ? pact_hash["interactions"] : nil
+        pact_hash.is_a?(Hash) && pact_hash["interactions"].is_a?(Array) ? pact_hash["interactions"] : nil
       end
 
       def messages_or_interactions

data/lib/pact_broker/pacts/metadata.rb

@@ -5,7 +5,8 @@ module PactBroker
 
       MAPPINGS = [
         [:consumer_version_tags, "cvt"],
-        [:consumer_version_number, "cvn"],
+        [:consumer_version_number, "cvn"], # for old urls
+        [:consumer_version_id, "cv"],
         [:wip, "w"],
         [:consumer_version_selectors, "s"],
         [:tag, "t"],
@@ -21,11 +22,11 @@ module PactBroker
         if selection_parameters[:tag]
           {
             "cvt" => [selection_parameters[:tag]],
-            "cvn" => pact.consumer_version_number
+            "cv" => pact.consumer_version.id
           }
         else
           {
-            "cvn" => pact.consumer_version_number
+            "cv" => pact.consumer_version.id
           }
         end
       end
@@ -56,7 +57,7 @@ module PactBroker
               {
                 "t" => selector.tag,
                 "l" => selector.latest,
-                "cvn" => selector.consumer_version.number
+                "cv" => selector.consumer_version.id
               }.compact
             end
           }
@@ -76,9 +77,14 @@ module PactBroker
       end
 
       def parse_hash(hash)
+        require "pact_broker/domain/version" # can't load this before the db models
         hash.each_with_object({}) do | (key, value), new_hash |
           long_key = MAPPINGS.find{ |mapping| mapping.last == key }&.first
-          new_hash[long_key || key] = parse_object(value)
+          if long_key == :consumer_version_id
+            new_hash[:consumer_version_number] = PactBroker::Domain::Version.find(id: value.to_i)&.number
+          else
+            new_hash[long_key || key] = parse_object(value)
+          end
         end
       end
     end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -23,7 +23,13 @@ module PactBroker
       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])
-      one_to_one(:latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_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)
 
       one_to_many(:head_pact_publications_for_tags,
         class: PactPublication,
@@ -41,8 +47,8 @@ module PactBroker
         include PactPublicationWipDatasetModule
       end
 
-      def self.subtract(a, b)
-        b_ids = b.collect(&:id)
+      def self.subtract(a, *b)
+        b_ids = b.flat_map{ |pact_publications| pact_publications.collect(&:id) }
         a.reject{ |pact_publication| b_ids.include?(pact_publication.id) }
       end
 
@@ -64,7 +70,7 @@ module PactBroker
       end
 
       def consumer_version_tags
-        consumer_version.tags
+        tags
       end
 
       def latest_verification
@@ -95,7 +101,7 @@ module PactBroker
           created_at: created_at,
           head_tag_names: [],
           db_model: self
-          )
+        )
       end
 
       def to_domain_lightweight
@@ -112,12 +118,23 @@ module PactBroker
           )
       end
 
+      # Think we really could just use the version here.
       def to_version_domain
-        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, tags: consumer_version.tags, order: consumer_version.order, branch: consumer_version.branch)
+        OpenStruct.new(
+          id: consumer_version.id,
+          number: consumer_version.number,
+          pacticipant: consumer,
+          tags: consumer_version.tags,
+          order: consumer_version.order,
+          branch: consumer_version.branch,
+          current_deployed_versions: consumer_version.current_deployed_versions,
+          current_supported_released_versions: consumer_version.current_supported_released_versions
+        )
       end
 
       def to_version_domain_lightweight
         OpenStruct.new(
+          id: consumer_version.id,
           number: consumer_version.number,
           pacticipant: consumer,
           order: consumer_version.order,
@@ -127,6 +144,24 @@ module PactBroker
         )
       end
 
+      def to_domain_with_content
+        to_domain
+      end
+
+      def to_head_pact
+        HeadPact.new(to_domain, consumer_version.number, values[:tag_name])
+      end
+
+      def pact_version_sha
+        pact_version.sha
+      end
+
+      def <=> other
+        self_fields = [consumer.name.downcase, provider.name.downcase, consumer_version_order || 0]
+        other_fields = [other.consumer.name.downcase, other.provider.name.downcase, other.consumer_version_order || 0]
+        self_fields <=> other_fields
+      end
+
       private
 
       def cached_domain_for_delegation