pact_broker 2.76.2 → 2.79.1

data/lib/pact_broker/domain/verification.rb

@@ -16,7 +16,7 @@ module PactBroker
       associate(:many_to_one, :provider_version, class: "PactBroker::Domain::Version", key: :provider_version_id, primary_key: :id)
       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(:one_to_many, :provider_version_tags, :class => "PactBroker::Tags::TagWithLatestFlag", primary_key: :provider_version_id, key: :version_id)
+      associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Domain::Tag", primary_key: :provider_version_id, key: :version_id)
       plugin :serialization, :json, :test_results
 
       def before_create
@@ -197,7 +197,7 @@ end
 
 # Table: verifications
 # Columns:
-#  id                  | integer                     | PRIMARY KEY DEFAULT nextval('verifications_id_seq'::regclass)
+#  id                  | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
 #  number              | integer                     |
 #  success             | boolean                     | NOT NULL
 #  provider_version    | text                        |
@@ -209,6 +209,7 @@ end
 #  test_results        | text                        |
 #  consumer_id         | integer                     |
 #  provider_id         | integer                     |
+#  wip                 | boolean                     | NOT NULL DEFAULT false
 # Indexes:
 #  verifications_pkey                          | PRIMARY KEY btree (id)
 #  verifications_pact_version_id_number_index  | UNIQUE btree (pact_version_id, number)

data/lib/pact_broker/domain/version.rb

@@ -2,6 +2,8 @@ require 'pact_broker/db'
 require 'pact_broker/domain/order_versions'
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/tags/tag_with_latest_flag'
+require 'pact_broker/versions/eager_loaders'
+require 'pact_broker/versions/lazy_loaders'
 
 module PactBroker
   module Domain
@@ -22,37 +24,51 @@ module PactBroker
 
     class Version < Sequel::Model
       plugin :timestamps, update_on_create: true
-      plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
+      plugin :upsert, { identifying_columns: [:pacticipant_id, :number], ignore_columns_on_update: [:id, :created_at, :order] }
 
       set_primary_key :id
       one_to_many :pact_publications, order: :revision_number, class: "PactBroker::Pacts::PactPublication", key: :consumer_version_id
       associate(:many_to_one, :pacticipant, :class => "PactBroker::Domain::Pacticipant", :key => :pacticipant_id, :primary_key => :id)
       one_to_many :tags, :reciprocal => :version, order: :created_at
 
-      one_to_many :tags_with_latest_flag, :class => "PactBroker::Tags::TagWithLatestFlag", primary_keys: [:id], key: [:version_id], :eager_loader=>(proc do |eo_opts|
-        tags_for_versions = PactBroker::Domain::Tag.where(version_id: eo_opts[:key_hash][:id].keys)
-        latest_tag_for_pacticipants = PactBroker::Domain::Tag.latest_tags_for_pacticipant_ids(eo_opts[:rows].collect(&:pacticipant_id)).all
-
-        eo_opts[:rows].each{|row| row.associations[:tags_with_latest_flag] = [] }
-
-        tags_for_versions.each do | tag |
-          latest = latest_tag_for_pacticipants.any? { |latest_tag| latest_tag.name == tag.name && latest_tag.version_id == tag.version_id }
-          eo_opts[:id_map][tag.version_id].each do | version |
-            version.associations[:tags_with_latest_flag] << EagerTagWithLatestFlag.new(tag, latest)
-          end
-        end
-      end)
+      many_to_one :latest_version_for_pacticipant, read_only: true, key: :id,
+        class: Version,
+        dataset: lambda { Version.latest_version_for_pacticipant(pacticipant) },
+        eager_loader: PactBroker::Versions::EagerLoaders::LatestVersionForPacticipant
 
+      many_to_one :latest_version_for_branch, read_only: true, key: :id,
+        class: Version,
+        dataset: PactBroker::Versions::LazyLoaders::LATEST_VERSION_FOR_BRANCH,
+        eager_loader: PactBroker::Versions::EagerLoaders::LatestVersionForBranch
 
       dataset_module do
         include PactBroker::Repositories::Helpers
 
+        def latest_version_for_pacticipant(pacticipant)
+          where(pacticipant: pacticipant)
+          .order(Sequel.desc(:order))
+          .limit(1)
+        end
+
         def for(pacticipant_name, version_number)
           where_pacticipant_name(pacticipant_name).where_number(version_number).single_record
         end
 
+        def latest_versions_for_pacticipant_branches(pacticipant_id, branches)
+          query = Version.where(Sequel[:versions][:pacticipant_id] => pacticipant_id, Sequel[:versions][:branch] => branches)
+
+          self_join = {
+            Sequel[:versions][:pacticipant_id] => Sequel[:versions_2][:pacticipant_id],
+            Sequel[:versions][:branch] => Sequel[:versions_2][:branch]
+          }
+          query.select_all_qualified.left_join(query, self_join, table_alias: :versions_2) do
+            Sequel[:versions_2][:order] > Sequel[:versions][:order]
+          end
+          .where(Sequel[:versions_2][:order] => nil)
+        end
+
         def where_pacticipant_name(pacticipant_name)
-          where(pacticipant_id: db[:pacticipants].select(:id).where(name_like(:name, pacticipant_name)))
+          where(Sequel[:versions][:pacticipant_id] => db[:pacticipants].select(:id).where(name_like(:name, pacticipant_name)))
           # If we do a join, we get the extra columns from the pacticipant table that then
           # make == not work
           # join(:pacticipants) do | p |
@@ -118,7 +134,7 @@ module PactBroker
             Sequel[:versions][:order]          => Sequel[:latest][:latest_version_order]
           }
 
-          group_by_cols = selector.tag == true ? [:pacticipant_id, Sequel[:tags][:name]] : [:pacticipant_id]
+          group_by_cols = selector.tag == true ? [Sequel[:versions][:pacticipant_id], Sequel[:tags][:name]] : [Sequel[:versions][:pacticipant_id]]
 
           max_order_for_each_pacticipant = query
               .select_group(*group_by_cols)
@@ -128,9 +144,12 @@ module PactBroker
         end
       end
 
+      # Isn't called on upsert when the record is updated with Sqlite
+      # Is called with Postgres/MySQL
+      # Haven't had time to dig into why
       def after_create
         super
-        OrderVersions.(self)
+        OrderVersions.(self) unless self.order
         refresh
       end
 
@@ -147,29 +166,45 @@ module PactBroker
         "Version #{number} - #{updated_at.to_time.localtime.strftime("%d/%m/%Y")}"
       end
 
+      def head_tags
+        tags.select(&:latest_for_pacticipant?)
+      end
+
       # What about provider??? This makes no sense
       def latest_pact_publication
         pact_publications.last
       end
+
+      def latest_for_branch?
+        branch ? latest_version_for_branch.order == order : nil
+      end
+
+      def latest_for_pacticipant?
+        latest_version_for_pacticipant == self
+      end
     end
   end
 end
 
 # Table: versions
 # Columns:
-#  id             | integer                     | PRIMARY KEY DEFAULT nextval('versions_id_seq'::regclass)
+#  id             | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
 #  number         | text                        |
 #  repository_ref | text                        |
 #  pacticipant_id | integer                     | NOT NULL
 #  order          | integer                     |
 #  created_at     | timestamp without time zone | NOT NULL
 #  updated_at     | timestamp without time zone | NOT NULL
+#  branch         | text                        |
+#  build_url      | text                        |
 # Indexes:
-#  versions_pkey                        | PRIMARY KEY btree (id)
-#  uq_ver_ppt_ord                       | UNIQUE btree (pacticipant_id, "order")
-#  versions_pacticipant_id_number_index | UNIQUE btree (pacticipant_id, number)
-#  ndx_ver_num                          | btree (number)
-#  ndx_ver_ord                          | btree ("order")
+#  versions_pkey                              | PRIMARY KEY btree (id)
+#  uq_ver_ppt_ord                             | UNIQUE btree (pacticipant_id, "order")
+#  versions_pacticipant_id_number_index       | UNIQUE btree (pacticipant_id, number)
+#  ndx_ver_num                                | btree (number)
+#  ndx_ver_ord                                | btree ("order")
+#  versions_pacticipant_id_branch_order_index | btree (pacticipant_id, branch, "order")
+#  versions_pacticipant_id_order_desc_index   | btree (pacticipant_id, "order" DESC)
 # Foreign key constraints:
 #  versions_pacticipant_id_fkey | (pacticipant_id) REFERENCES pacticipants(id)
 # Referenced By:

data/lib/pact_broker/domain/webhook.rb

@@ -54,13 +54,16 @@ module PactBroker
 
       def execute pact, verification, event_context, options
         logger.info "Executing #{self} event_context=#{event_context}"
-        webhook_request = request.build(template_parameters(pact, verification, event_context, options))
+        template_params = template_parameters(pact, verification, event_context, options)
+        webhook_request = request.build(template_params)
         http_response, error = execute_request(webhook_request)
 
+        logs = generate_logs(webhook_request, http_response, error, event_context, options.fetch(:logging_options))
+        http_request = webhook_request.http_request
         PactBroker::Webhooks::WebhookExecutionResult.new(
-          webhook_request.http_request,
+          http_request,
           http_response,
-          generate_logs(webhook_request, http_response, error, event_context, options.fetch(:logging_options)),
+          logs,
           error
         )
       end

data/lib/pact_broker/index/service.rb

@@ -13,14 +13,6 @@ module PactBroker
       extend PactBroker::Services
       extend PactBroker::Logging
 
-      COLS = [:id, :consumer_name, :provider_name, :consumer_version_order]
-      LATEST_PPS = Sequel::Model.db[:latest_pact_publications].select(*COLS)
-      LATEST_TAGGED_PPS = Sequel::Model.db[:latest_tagged_pact_publications].select(*COLS)
-      HEAD_PP_ORDER_COLUMNS = [
-          Sequel.asc(Sequel.function(:lower, :consumer_name)),
-          Sequel.desc(:consumer_version_order),
-          Sequel.asc(Sequel.function(:lower, :provider_name))
-        ].freeze
       DEFAULT_PAGE_SIZE = 30
       DEFAULT_PAGE_NUMBER = 1
 
@@ -40,27 +32,26 @@ module PactBroker
 
       def self.find_index_items options = {}
         latest_verifications_for_cv_tags = latest_verifications_for_consumer_version_tags(options)
-        latest_pact_publication_ids = latest_pact_publications.select(:id).all.collect{ |h| h[:id] }
+        latest_pp_ids = latest_pact_publication_ids
 
         # We only need to know if a webhook exists for an integration, not what its properties are
         webhooks = PactBroker::Webhooks::Webhook.select(:consumer_id, :provider_id).distinct.all
 
-        pact_publication_ids = head_pact_publication_ids(options)
-        pagination_record_count = pact_publication_ids.pagination_record_count
+        pact_publication_query = head_pact_publications(options)
+        pagination_record_count = pact_publication_query.pagination_record_count
 
-        pact_publications = pact_publication_scope
-          .where(id: pact_publication_ids)
-          .select_all_qualified
+        pact_publications = pact_publication_query
           .eager(:consumer)
           .eager(:provider)
           .eager(:pact_version)
           .eager(integration: [{latest_verification: :provider_version}, :latest_triggered_webhooks])
-          .eager(:consumer_version)
-          .eager(latest_verification: { provider_version: :tags_with_latest_flag })
-          .eager(:head_pact_tags)
+          .eager(consumer_version: [:latest_version_for_branch, { tags: :head_tag }])
+          .eager(latest_verification: { provider_version: [:latest_version_for_branch, { tags: :head_tag } ] })
+          .eager(:head_pact_publications_for_tags)
 
         index_items = pact_publications.all.collect do | pact_publication |
-          is_overall_latest_for_integration = latest_pact_publication_ids.include?(pact_publication.id)
+          is_overall_latest_for_integration = latest_pp_ids.include?(pact_publication.id)
+
           latest_verification = latest_verification_for_pseudo_branch(pact_publication, is_overall_latest_for_integration, latest_verifications_for_cv_tags, options[:tags])
           webhook = webhooks.find{ |webhook| webhook.is_for?(pact_publication.integration) }
 
@@ -72,8 +63,9 @@ module PactBroker
             latest_verification,
             webhook ? [webhook]: [],
             pact_publication.integration.latest_triggered_webhooks,
-            consumer_version_tags(pact_publication, options[:tags]),
-            options[:tags] && latest_verification ? latest_verification.provider_version.tags_with_latest_flag.select(&:latest?) : []
+            consumer_version_tags(pact_publication, options[:tags]).sort_by(&:created_at).collect(&:name),
+            options[:tags] && latest_verification ? latest_verification.provider_version.tags.select(&:latest_for_pacticipant?).sort_by(&:created_at) : [],
+            pact_publication.latest_for_branch?
           )
         end.sort
 
@@ -98,32 +90,26 @@ module PactBroker
 
       def self.consumer_version_tags(pact_publication, tags_option)
         if tags_option == true
-          pact_publication.head_pact_tags.collect(&:name)
+          pact_publication.head_pact_tags
         elsif tags_option.is_a?(Array)
-          pact_publication.head_pact_tags.collect(&:name) & tags_option
+          pact_publication.head_pact_tags.select{ |tag| tags_option.include?(tag.name)}
         else
           []
         end
       end
 
       def self.find_index_items_for_api(consumer_name: nil, provider_name: nil, **ignored)
-        latest_pact_publication_ids = latest_pact_publications.select(:id).all.collect{ |h| h[:id] }
-        pact_publication_ids = head_pact_publication_ids(consumer_name: consumer_name, provider_name: provider_name, tags: true)
-
-        pact_publications = pact_publication_scope
-          .where(id: pact_publication_ids)
-          .select_all_qualified
+        latest_pp_ids = latest_pact_publication_ids
+        pact_publications = head_pact_publications(consumer_name: consumer_name, provider_name: provider_name, tags: true)
           .eager(:consumer)
           .eager(:provider)
           .eager(:pact_version)
-          .eager(:consumer_version)
-          .eager(latest_verification: { provider_version: :tags_with_latest_flag })
-          .eager(:head_pact_tags)
-
+          .eager(consumer_version: [:latest_version_for_branch, { tags: :head_tag }])
+          .eager(latest_verification: { provider_version: [:latest_version_for_branch, { tags: :head_tag }]})
+          .eager(:head_pact_publications_for_tags)
 
         pact_publications.all.collect do | pact_publication |
-
-          is_overall_latest_for_integration = latest_pact_publication_ids.include?(pact_publication.id)
+          is_overall_latest_for_integration = latest_pp_ids.include?(pact_publication.id)
 
           PactBroker::Domain::IndexItem.create(
             pact_publication.consumer,
@@ -133,42 +119,62 @@ module PactBroker
             pact_publication.latest_verification,
             [],
             [],
-            pact_publication.head_pact_tags.collect(&:name),
-            pact_publication.latest_verification ? pact_publication.latest_verification.provider_version.tags_with_latest_flag.select(&:latest?) : []
+            pact_publication.head_pact_tags.sort_by(&:created_at).collect(&:name),
+            pact_publication.latest_verification ? pact_publication.latest_verification.provider_version.tags.select(&:latest_for_pacticipant?).sort_by(&:created_at) : []
           )
         end.sort
       end
 
       def self.latest_pact_publications
-        db[:latest_pact_publications]
+        PactBroker::Pacts::PactPublication.overall_latest
+      end
+
+      def self.latest_pact_publication_ids
+        PactBroker::Pacts::PactPublication.select(Sequel[:pact_publications][:id]).overall_latest.collect(&:id)
       end
 
       def self.db
         PactBroker::Pacts::PactPublication.db
       end
 
-      def self.head_pact_publication_ids(options = {})
-        query = if options[:tags].is_a?(Array)
-          LATEST_PPS.union(LATEST_TAGGED_PPS.where(tag_name: options[:tags]))
-        elsif options[:tags]
-          LATEST_PPS.union(LATEST_TAGGED_PPS)
-        else
-          LATEST_PPS
-        end
+      def self.head_pact_publications(options = {})
+        base = PactBroker::Pacts::PactPublication.select(Sequel[:pact_publications][:id])
 
         if options[:consumer_name]
-          query = query.where(PactBroker::Repositories::Helpers.name_like(:consumer_name, options[:consumer_name]))
+          consumer = pacticipant_repository.find_by_name!(options[:consumer_name])
+          base = base.for_consumer(consumer)
         end
 
         if options[:provider_name]
-          query = query.where(PactBroker::Repositories::Helpers.name_like(:provider_name, options[:provider_name]))
+          provider = pacticipant_repository.find_by_name!(options[:provider_name])
+          base = base.for_provider(provider)
         end
 
-        query.order(*HEAD_PP_ORDER_COLUMNS)
+        latest = base.overall_latest
+        ids_query = if options[:tags].is_a?(Array)
+          latest.union(base.latest_for_consumer_tag(options[:tags]))
+        elsif options[:tags]
+          latest.union(base.latest_by_consumer_tag)
+        else
+          latest
+        end
+
+        query = PactBroker::Pacts::PactPublication.select_all_qualified.where(Sequel[:pact_publications][:id] => ids_query)
+          .join_consumers(:consumers)
+          .join_providers(:providers)
+          .join(:versions, { Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id] }, { table_alias: :cv } )
+
+        order_columns = [
+          Sequel.asc(Sequel.function(:lower, Sequel[:consumers][:name])),
+          Sequel.desc(Sequel[:cv][:order]),
+          Sequel.asc(Sequel.function(:lower, Sequel[:providers][:name]))
+        ]
+
+        query.order(*order_columns)
           .paginate(options[:page_number] || DEFAULT_PAGE_NUMBER, options[:page_size] || DEFAULT_PAGE_SIZE)
-          .select(:id)
       end
 
+      # eager loading the tag stuff doesn't seem to make it quicker
       def self.latest_verifications_for_consumer_version_tags(options)
         # server side rendered index page with tags[]=a&tags=[]b
         if options[:tags].is_a?(Array)

data/lib/pact_broker/locale/en.yml

@@ -9,7 +9,8 @@ en:
     valid_consumer_version_number?: "Consumer version number '%{value}' cannot be parsed to a version number. The expected format (unless this configuration has been overridden) is a semantic version. eg. 1.3.0 or 2.0.4.rc1"
     non_templated_host?: "cannot have a template parameter in the host"
     pacticipant_exists?: "does not match an existing pacticipant"
-
+    single_line?: "cannot contain multiple lines"
+    no_spaces?: "cannot contain spaces"
 
   pact_broker:
     messages:
@@ -46,6 +47,7 @@ en:
         connection_encoding_not_utf8: "The Sequel connection encoding (%{encoding}) is strongly recommended to be \"utf8\". If you need to set it to %{encoding} for some particular reason, then disable this check by setting config.validate_database_connection_config = false"
         invalid_webhook_uuid: The UUID can only contain the characters A-Z, a-z, 0-9, _ and -, and must be 16 or more characters.
         pacticipant_not_found: No pacticipant with name '%{name}' found
+        environment_name_must_be_unique: Another environment with name '%{name}' already exists.
       duplicate_pacticipant: |
         This is the first time a pact has been published for "%{new_name}".
         The name "%{new_name}" is very similar to the following existing consumers/providers:

data/lib/pact_broker/matrix/quick_row.rb

@@ -351,6 +351,10 @@ module PactBroker
         consumer_version.number
       end
 
+      def consumer_version_branch
+        consumer_version.branch
+      end
+
       def consumer_version_order
         consumer_version.order
       end
@@ -363,6 +367,10 @@ module PactBroker
         provider_version&.number
       end
 
+      def provider_version_branch
+        provider_version&.branch
+      end
+
       def provider_version_order
         provider_version&.order
       end

data/lib/pact_broker/metrics/service.rb

@@ -58,7 +58,7 @@ module PactBroker
           tags: {
             count: PactBroker::Domain::Tag.count,
             distinctCount: PactBroker::Domain::Tag.select(:name).distinct.count,
-            distinctWithPacticipantCount: PactBroker::Domain::Tag.join(:versions, { id: :version_id }).select_group(:name, :pacticipant_id).count
+            distinctWithPacticipantCount: PactBroker::Domain::Tag.join(:versions, { id: :version_id }).select_group(:name, Sequel[:versions][:pacticipant_id]).count
           },
           triggeredWebhooks: {
             count: PactBroker::Webhooks::TriggeredWebhook.count

data/lib/pact_broker/pacts/eager_loaders.rb

@@ -0,0 +1,52 @@
+module PactBroker
+  module Pacts
+    module EagerLoaders
+      class HeadPactPublicationsForTags
+        def self.call(eo)
+          pact_publications = eo[:rows]
+          initialize_association(pact_publications)
+          populate_associations(group_by_consumer_and_provider_ids(pact_publications))
+        end
+
+        def self.initialize_association(pact_publications)
+          pact_publications.each { |pp| pp.associations[:head_pact_publications_for_tags] = [] }
+        end
+
+        def self.group_by_consumer_and_provider_ids(pact_publications)
+          pact_publications.group_by{ |pact_publication| [pact_publication.consumer_id, pact_publication.provider_id] }
+        end
+
+        def self.populate_associations(grouped_pact_publications)
+          grouped_pact_publications.each do | key, pact_publications |
+            populate_associations_for_consumer_and_provider(key, pact_publications)
+          end
+        end
+
+        def self.populate_associations_for_consumer_and_provider(key, pact_publications)
+          head_pact_publications_by_tag = hash_of_head_pact_publications(
+            pact_publications.first.class,
+            pact_publications.first.consumer,
+            pact_publications.first.provider,
+            pact_publications.flat_map{ |pp| pp.consumer_version_tags.collect(&:name) }
+          )
+
+          pact_publications.each do | pact_publication |
+            pact_publication.consumer_version_tags.collect(&:name).sort.each do | tag_name |
+              pact_publication.associations[:head_pact_publications_for_tags] << head_pact_publications_by_tag[tag_name]
+            end
+          end
+        end
+
+        def self.hash_of_head_pact_publications pact_publication_class, consumer, provider, tag_names
+          pact_publication_class
+            .for_consumer(consumer)
+            .for_provider(provider)
+            .latest_for_consumer_tag(tag_names)
+            .each_with_object({}) do | head_pact_publication, hash |
+              hash[head_pact_publication.values.fetch(:tag_name)] = head_pact_publication
+            end
+        end
+      end
+    end
+  end
+end