pact_broker 2.91.0 → 2.93.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1634d0a3519aae8c805e0c8f13e2e132e86b623c92e019d37285b98ecd7574d
-  data.tar.gz: 2652bd80a29b04e222bad6ffb0513c95618f16185feb98cffc9c7bd283858b79
+  metadata.gz: 6014e4f21b22b1055f87d7f937b7d7942cb62f1ab7e6501299c8787e83986e22
+  data.tar.gz: 58b9668d0f34631533a507bce423d80fd0a1a8e2f98c04838a69ac83dc290f18
 SHA512:
-  metadata.gz: 8e3bc701ea3fe67d6ffe24330faf61b5def23d7293e2c59bfa1d4c5b8874dd3ef8b622f8adbef202bdfd784804f67a5c9efd39c79c1bba54bb52a8fe2abc7661
-  data.tar.gz: ab7a4c68f71251bbf36e3f58bb18267b28cc1bd72df5f3959caedd8fe1b776439b6ba25fd972f2a819ba5f0872d9861d22284da501a5d921f255aea368bedfab
+  metadata.gz: f26bd4ebafd8e30a3b8d96c2eb7c2ed5f594ef8cdfb477b89260169db34b77a32f01605b74f0a75e7f118eea1f8364e0c4f3e8d93df76617b041b526a3ff99e5
+  data.tar.gz: 807f0c5055108dfd8b8057a64580943dc6b1aeedb669156c1dcdad09cd4926ca8d6616646af62721f12ec2ab285a9cd9556d2821fc35177c7d04768a85c66347

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+<a name="v2.93.2"></a>
+### v2.93.2 (2021-12-23)
+
+#### Bug Fixes
+
+* Improve SortContent performance on large contracts (#538)	 ([1914c01f](/../../commit/1914c01f))
+
+<a name="v2.93.1"></a>
+### v2.93.1 (2021-12-21)
+
+#### Bug Fixes
+
+* optimise query for calculating the latest overall pacts	 ([f44aaa70](/../../commit/f44aaa70))
+
+<a name="v2.93.0"></a>
+### v2.93.0 (2021-12-07)
+
+#### Features
+
+* remove feature flag for new_wip_calculations	 ([972ceadd](/../../commit/972ceadd))
+* call the database clean within a transaction	 ([408c84ef](/../../commit/408c84ef))
+
+#### Bug Fixes
+
+* fix clean performance fix (#530)	 ([6c71e57b](/../../commit/6c71e57b))
+* fix performance issue loading latest version for pacticipant	 ([c575d132](/../../commit/c575d132))
+
+<a name="v2.92.0"></a>
+### v2.92.0 (2021-11-27)
+
+#### Features
+
+* allow SQL caller logging to be enabled	 ([861d8f21](/../../commit/861d8f21))
+* use a separate table to track the successful verifications of pact versions for each provider version tag (feature toggled with "new_wip_calculation")	 ([df0acfa3](/../../commit/df0acfa3))
+
+#### Bug Fixes
+
+* **cleanup**
+  * Improve delete orphans SQL query (#527)	 ([853354ea](/../../commit/853354ea))
+
+* cast PACT_BROKER_DATABASE_CONNECTION_VALIDATION_TIMEOUT to an integer	 ([8816c61f](/../../commit/8816c61f))
+
 <a name="v2.91.0"></a>
 ### v2.91.0 (2021-11-15)
 

data/db/migrations/20210608_add_uuid_to_webhook.rb

@@ -8,6 +8,7 @@ Sequel.migration do
 
   down do
     alter_table(:triggered_webhooks) do
+      drop_index([:uuid], name: "triggered_webhooks_uuid", unique: true)
       drop_column(:uuid)
     end
   end

data/db/migrations/20211120_create_pact_version_provider_tag_successful_verifications.rb

@@ -0,0 +1,23 @@
+Sequel.migration do
+  up do
+    create_table(:pact_version_provider_tag_successful_verifications, charset: "utf8") do
+      primary_key :id
+      foreign_key :pact_version_id, :pact_versions, null: false, on_delete: :cascade, foreign_key_constraint_name: "pact_version_provider_tag_successful_verifications_pv_id_fk"
+      String :provider_version_tag_name, null: false
+      Boolean :wip, null: false
+      Integer :verification_id
+      DateTime :execution_date, null: false
+      index([:pact_version_id, :provider_version_tag_name, :wip], unique: true, name: "pact_version_provider_tag_verifications_pv_pvtn_wip_unique")
+      # The implication of the on_delete: :set_null for verification_id is
+      # that even if the verification result is deleted from the broker,
+      # the wip/pending status stays the same.
+      # We may or may not want this. Will have to wait and see.
+      # Have made the foreign key a separate declaration so it can more easily be remade.
+      foreign_key([:verification_id], :verifications, on_delete: :set_null, name: "pact_version_provider_tag_successful_verifications_v_id_fk")
+    end
+  end
+
+  down do
+    drop_table(:pact_version_provider_tag_successful_verifications)
+  end
+end

data/db/migrations/20211121_migrate_pact_version_provider_tag_successful_verifications_data.rb

@@ -0,0 +1,11 @@
+require "pact_broker/db/data_migrations/migrate_pact_version_provider_tag_successful_verifications"
+
+Sequel.migration do
+  up do
+    PactBroker::DB::DataMigrations::MigratePactVersionProviderTagSuccessfulVerifications.call(self)
+  end
+
+  down do
+
+  end
+end

data/lib/pact_broker/api/resources/deployed_versions_for_version_and_environment.rb

@@ -40,11 +40,11 @@ module PactBroker
         end
 
         def policy_name
-          :'versions::version'
+          :'versions::deployed_version'
         end
 
         def policy_record
-          version
+          environment
         end
 
         private

data/lib/pact_broker/api/resources/released_versions_for_version_and_environment.rb

@@ -45,7 +45,11 @@ module PactBroker
         end
 
         def policy_name
-          :'versions::versions'
+          :'versions::released_version'
+        end
+
+        def policy_record
+          environment
         end
 
         def finish_request

data/lib/pact_broker/api/resources/verifications.rb

@@ -50,7 +50,7 @@ module PactBroker
         end
 
         def from_json
-          handle_webhook_events do
+          handle_webhook_events(build_url: verification_params["buildUrl"]) do
             verified_pacts = pact_service.find_for_verification_publication(pact_params, event_context[:consumer_version_selectors])
             verification = verification_service.create(next_verification_number, verification_params, verified_pacts, event_context)
             response.body = decorator_for(verification).to_json(decorator_options)

data/lib/pact_broker/config/runtime_configuration_database_methods.rb

@@ -18,6 +18,7 @@ module PactBroker
             database_sslmode: nil,
             sql_log_level: :debug,
             sql_log_warn_duration: 5,
+            sql_enable_caller_logging: false,
             database_max_connections: nil,
             database_pool_timeout: 5,
             database_connect_max_retries: 0,
@@ -36,6 +37,7 @@ module PactBroker
                 encoding: "utf8",
                 sslmode: database_sslmode,
                 sql_log_level: sql_log_level,
+                enable_caller_logging: sql_enable_caller_logging,
                 log_warn_duration: sql_log_warn_duration,
                 max_connections: database_max_connections,
                 pool_timeout: database_pool_timeout,
@@ -65,6 +67,10 @@ module PactBroker
             super(metrics_sql_statement_timeout&.to_i)
           end
 
+          def database_connection_validation_timeout= database_connection_validation_timeout
+            super(database_connection_validation_timeout&.to_i)
+          end
+
           def postgres?
             database_credentials[:adapter] == "postgres"
           end

data/lib/pact_broker/db/clean_incremental.rb

@@ -66,13 +66,15 @@ module PactBroker
         if dry_run?
           dry_run_results
         else
-          before_counts = current_counts
-          PactBroker::Domain::Version.where(id: resolve_ids(version_ids_to_delete)).delete
-          delete_orphan_pact_versions
-          after_counts = current_counts
-
-          TABLES.each_with_object({}) do | table_name, comparison_counts |
-            comparison_counts[table_name.to_s] = { "deleted" => before_counts[table_name] - after_counts[table_name], "kept" => after_counts[table_name] }
+          db.transaction do
+            before_counts = current_counts
+            PactBroker::Domain::Version.where(id: resolve_ids(version_ids_to_delete)).delete
+            delete_orphan_pact_versions
+            after_counts = current_counts
+
+            TABLES.each_with_object({}) do | table_name, comparison_counts |
+              comparison_counts[table_name.to_s] = { "deleted" => before_counts[table_name] - after_counts[table_name], "kept" => after_counts[table_name] }
+            end
           end
         end
       end
@@ -92,8 +94,23 @@ module PactBroker
       end
 
       def delete_orphan_pact_versions
-        referenced_pact_version_ids = db[:pact_publications].select(:pact_version_id).union(db[:verifications].select(:pact_version_id))
-        db[:pact_versions].where(id: referenced_pact_version_ids).invert.delete
+        db[:pact_versions].where(id: orphan_pact_versions).delete
+      rescue Sequel::DatabaseError => e
+        raise unless e.cause.class.name == "Mysql2::Error"
+
+        ids = orphan_pact_versions.map { |row| row[:id] }
+        db[:pact_versions].where(id: ids).delete
+      end
+
+      def orphan_pact_versions
+        db[:pact_versions]
+          .left_join(:pact_publications, Sequel[:pact_publications][:pact_version_id]=> Sequel[:pact_versions][:id])
+          .left_join(:verifications, Sequel[:verifications][:pact_version_id]=> Sequel[:pact_versions][:id])
+          .select(Sequel[:pact_versions][:id])
+          .where(
+            Sequel[:pact_publications][:id] => nil,
+            Sequel[:verifications][:id] => nil
+          )
       end
 
       def version_info(version)

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

@@ -0,0 +1,38 @@
+require "pact_broker/db/data_migrations/helpers"
+
+module PactBroker
+  module DB
+    module DataMigrations
+      class MigratePactVersionProviderTagSuccessfulVerifications
+        extend Helpers
+
+        def self.call(connection)
+          successful_verifications_join = {
+            Sequel[:sv][:pact_version_id] => Sequel[:verifications][:pact_version_id],
+            Sequel[:sv][:provider_version_tag_name] => Sequel[:tags][:name],
+            Sequel[:sv][:wip] => Sequel[:verifications][:wip]
+          }
+
+          missing_verifications = connection
+                                    .select(
+                                      Sequel[:verifications][:pact_version_id],
+                                      Sequel[:tags][:name],
+                                      Sequel[:verifications][:wip],
+                                      Sequel[:verifications][:id],
+                                      Sequel[:verifications][:execution_date]
+                                    )
+                                    .order(Sequel[:verifications][:execution_date], Sequel[:verifications][:id])
+                                    .from(:verifications)
+                                    .join(:tags, { Sequel[:verifications][:provider_version_id] => Sequel[:tags][:version_id] })
+                                    .left_outer_join(:pact_version_provider_tag_successful_verifications, successful_verifications_join, { table_alias: :sv })
+                                    .where(Sequel[:sv][:pact_version_id] => nil)
+                                    .where(Sequel[:verifications][:success] => true)
+
+          connection[:pact_version_provider_tag_successful_verifications]
+            .insert_ignore
+            .insert([:pact_version_id, :provider_version_tag_name, :wip, :verification_id, :execution_date], missing_verifications)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/migrate_data.rb

@@ -28,6 +28,7 @@ module PactBroker
         DataMigrations::SetExtraColumnsForTags.call(database_connection)
         DataMigrations::CreateBranches.call(database_connection)
         DataMigrations::MigrateIntegrations.call(database_connection)
+        DataMigrations::MigratePactVersionProviderTagSuccessfulVerifications.call(database_connection)
       end
     end
   end

data/lib/pact_broker/deployments/deployed_version.rb

@@ -88,6 +88,15 @@ module PactBroker
         !!currently_deployed_version_id
       end
 
+      # target has been renamed to applicationInstance in the API.
+      def application_instance
+        target
+      end
+
+      def application_instance= application_instance
+        self.target = application_instance
+      end
+
       def version_number
         version.number
       end
@@ -100,7 +109,6 @@ module PactBroker
         self.class.where(id: id).record_undeployed
         self.refresh
       end
-
     end
   end
 end

data/lib/pact_broker/domain/pacticipant.rb

@@ -1,14 +1,44 @@
 require "pact_broker/db"
 require "pact_broker/messages"
 require "pact_broker/repositories/helpers"
-require "pact_broker/versions/latest_version"
 require "pact_broker/domain/label"
 require "pact_broker/string_refinements"
 require "pact_broker/pacticipants/generate_display_name"
 
 module PactBroker
   module Domain
+    class LatestVersionForPacticipantEagerLoader
+      def self.call(eo, **_other)
+        populate_associations(eo[:rows])
+      end
+
+      def self.populate_associations(pacticipants)
+        pacticipants.each { | pacticipant | pacticipant.associations[:latest_version] = nil }
+        pacticipant_ids = pacticipants.collect(&:id)
+
+        max_orders = PactBroker::Domain::Version
+                      .where(pacticipant_id: pacticipant_ids)
+                      .select_group(:pacticipant_id)
+                      .select_append { max(order).as(latest_order) }
+
+        max_orders_join = {
+          Sequel[:max_orders][:latest_order] => Sequel[:versions][:order],
+          Sequel[:max_orders][:pacticipant_id] => Sequel[:versions][:pacticipant_id]
+        }
+
+        latest_versions = PactBroker::Domain::Version
+                            .select_all_qualified
+                            .join(max_orders, max_orders_join, { table_alias: :max_orders})
+
+        latest_versions.each do | version |
+          pacticipant = pacticipants.find{ | p | p.id == version.pacticipant_id }
+          pacticipant.associations[:latest_version] = version
+        end
+      end
+    end
+
     class Pacticipant < Sequel::Model
+
       include Messages
       include PactBroker::Pacticipants::GenerateDisplayName
       using PactBroker::StringRefinements
@@ -21,7 +51,11 @@ module PactBroker
       one_to_many :versions, :order => :order, :reciprocal => :pacticipant
       one_to_many :labels, :order => :name, :reciprocal => :pacticipant
       one_to_many :pacts
-      one_to_one :latest_version, :class => "PactBroker::Versions::LatestVersion", primary_key: :id, key: :pacticipant_id
+      one_to_one :latest_version, :class => "PactBroker::Domain::Version",
+        primary_key: :id, key: :pacticipant_id,
+        dataset: lambda { PactBroker::Domain::Version.where(pacticipant_id: id).order(Sequel.desc(:order)).limit(1) },
+        eager_loader: LatestVersionForPacticipantEagerLoader
+
       one_to_many :branch_heads, class: "PactBroker::Versions::BranchHead", primary_key: :id, key: :pacticipant_id
       one_to_many :branches, class: "PactBroker::Versions::Branch", primary_key: :id, key: :pacticipant_id
 
@@ -61,10 +95,6 @@ module PactBroker
         self.main_branch = nil if main_branch.blank?
       end
 
-      def latest_version
-        versions.last
-      end
-
       def to_s
         "Pacticipant: id=#{id}, name=#{name}"
       end

data/lib/pact_broker/initializers/database_connection.rb

@@ -9,7 +9,8 @@ module PactBroker
     sequel_config = config.dup
     max_retries = sequel_config.delete(:connect_max_retries) || 0
     connection_validation_timeout = config.delete(:connection_validation_timeout)
-    configure_logger(sequel_config)
+    enable_caller_logging = config.delete(:enable_caller_logging)
+    configure_logger(sequel_config, logger)
     create_sqlite_database_dir(config)
 
     connection = with_retries(max_retries, logger) do
@@ -18,7 +19,7 @@ module PactBroker
 
     logger&.info "Connected to database #{sequel_config[:database]}"
 
-    configure_connection(connection, connection_validation_timeout)
+    configure_connection(connection, connection_validation_timeout, enable_caller_logging)
   end
 
   private_class_method def self.with_retries(max_retries, logger)
@@ -46,7 +47,7 @@ module PactBroker
     end
   end
 
-  private_class_method def self.configure_logger(sequel_config)
+  private_class_method def self.configure_logger(sequel_config, logger)
     if sequel_config[:sql_log_level] == :none
       sequel_config.delete(:sql_log_level)
     elsif logger
@@ -72,8 +73,9 @@ module PactBroker
   # when databases are restarted and connections are killed.  This has a performance
   # penalty, so consider increasing this timeout if building a frequently accessed service.
 
-  private_class_method def self.configure_connection(connection, connection_validation_timeout)
+  private_class_method def self.configure_connection(connection, connection_validation_timeout, enable_caller_logging)
     connection.extension(:connection_validator)
+    connection.extension(:caller_logging) if enable_caller_logging
     connection.pool.connection_validation_timeout = connection_validation_timeout if connection_validation_timeout
     connection
   end

data/lib/pact_broker/metrics/service.rb

@@ -18,7 +18,7 @@ module PactBroker
             withMainBranchSetCount: PactBroker::Domain::Pacticipant.with_main_branch_set.count
           },
           integrations: {
-            count: PactBroker::Integrations::Integration.count
+            count: PactBroker::Pacts::PactPublication.select(:consumer_id, :provider_id).distinct.count
           },
           pactPublications: {
             count: PactBroker::Pacts::PactPublication.count,

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -90,16 +90,18 @@ module PactBroker
       def overall_latest
         self_join = {
           Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
-          Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id]
+          Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id],
+          Sequel[:pact_publications][:consumer_version_order] => Sequel[:pp2][:max_consumer_version_order]
         }
 
         base_query = self
         base_query = base_query.select_all_qualified if no_columns_selected?
 
-        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
-        .where(Sequel[:pp2][:consumer_version_order] => nil)
+        base_query.join(
+          base_query.select_group(:consumer_id, :provider_id).select_append{ max(:consumer_version_order).as(:max_consumer_version_order) },
+          self_join,
+          table_alias: :pp2
+        )
         .remove_overridden_revisions_from_complete_query
       end
 
@@ -140,65 +142,62 @@ module PactBroker
       end
 
       # The latest pact publication for each tag
+      # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
+      # rather than "the pact for the latest version with a tag"
+      # Need to see about updating this.
       def latest_by_consumer_tag
         tags_join = {
-          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id]
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
         }
 
-        base_query = join(:tags, tags_join)
+        max_orders = join(:tags, tags_join)
+                      .select_group(:consumer_id, :provider_id, Sequel[:tags][:name].as(:tag_name))
+                      .select_append{ max(consumer_version_order).as(latest_consumer_version_order) }
 
+        max_join = {
+          Sequel[:max_orders][:consumer_id] => Sequel[:pact_publications][:consumer_id],
+          Sequel[:max_orders][:provider_id] => Sequel[:pact_publications][:provider_id],
+          Sequel[:max_orders][:latest_consumer_version_order] => Sequel[:pact_publications][:consumer_version_order]
+        }
+
+        base_query = self
         if no_columns_selected?
-          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+          base_query = base_query.select_all_qualified.select_append(Sequel[:max_orders][:tag_name])
         end
 
-        joined_query = base_query.select(
-          Sequel[:pact_publications][:consumer_id],
-          Sequel[:tags][:version_order],
-          Sequel[:tags][:name].as(:tag_name)
-        )
-
-        self_join = {
-          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
-          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
-        }
-        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
-          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
-        end
-        .where(Sequel[:pp2][:version_order] => nil)
-        .remove_overridden_revisions_from_complete_query
+        base_query
+          .join(max_orders, max_join, { table_alias: :max_orders })
+          .remove_overridden_revisions_from_complete_query
       end
 
+      # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
+      # rather than "the pact for the latest version with a tag"
+      # Need to see about updating this.
       def latest_for_consumer_tag(tag_name)
         tags_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][: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 = base_query
-          .join(:tags, tags_join)
-          .where(Sequel[:tags][:name] => tag_name)
+        max_orders = join(:tags, tags_join)
+                      .select_group(:consumer_id, :provider_id, Sequel[:tags][:name].as(:tag_name))
+                      .select_append{ max(consumer_version_order).as(latest_consumer_version_order) }
 
-        joined_query = base_query.select(
-          Sequel[:pact_publications][:consumer_id],
-          Sequel[:tags][:name].as(:tag_name),
-          Sequel[:tags][:version_order]
-        )
 
-        self_join = {
-          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
-          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
+        max_join = {
+          Sequel[:max_orders][:consumer_id] => Sequel[:pact_publications][:consumer_id],
+          Sequel[:max_orders][:provider_id] => Sequel[:pact_publications][:provider_id],
+          Sequel[:max_orders][:latest_consumer_version_order] => Sequel[:pact_publications][:consumer_version_order]
         }
 
-        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
-          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:max_orders][:tag_name])
         end
-        .where(Sequel[:pp2][:version_order] => nil)
-        .remove_overridden_revisions_from_complete_query
+
+        base_query
+          .join(max_orders, max_join, { table_alias: :max_orders })
+          .remove_overridden_revisions_from_complete_query
       end
 
       # The pacts for the latest versions with the specified tag (new logic)

data/lib/pact_broker/pacts/pact_publication_wip_dataset_module.rb

@@ -32,16 +32,23 @@ module PactBroker
         end
       end
 
-      def successfully_verified_by_provider_tag_when_not_wip(provider_id, provider_tag)
+      def successfully_verified_by_provider_tag_when_not_wip(provider_tag)
+        pact_version_provider_tag_verifications_join = {
+          Sequel[:sv][:pact_version_id] => Sequel[:pp][:pact_version_id],
+          Sequel[:sv][:provider_version_tag_name] => provider_tag,
+          Sequel[:sv][:wip] => false
+        }
+
         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_for_tag(provider_tag)
+          .join(:pact_version_provider_tag_successful_verifications, pact_version_provider_tag_verifications_join, { table_alias: :sv })
           .distinct
+
       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].*)
@@ -54,6 +61,32 @@ module PactBroker
           .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 = {
+          Sequel[:sv][:pact_version_id] => Sequel[:pp][:pact_version_id],
+          Sequel[:sv][:wip] => false
+        }
+
+        created_at_criteria = if first_tag_with_name
+                                Sequel.lit("sv.execution_date < ?", first_tag_with_name.created_at)
+                              else
+                                Sequel.lit("1 = 1")
+                              end
+
+        from_self(alias: :pp)
+          .select(Sequel[:pp].*)
+          .where(Sequel[:pp][:provider_id] => provider_id)
+          .join(:pact_version_provider_tag_successful_verifications, pact_version_provider_tag_verifications_join, { table_alias: :sv }) do
+            Sequel.&(
+              Sequel.lit("sv.provider_version_tag_name NOT IN (?)", provider_tag),
+              created_at_criteria
+            )
+          end
+          .distinct
+      end
+
       protected
 
       def verified_before_date(date)

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -270,7 +270,7 @@ module PactBroker
 
       def remove_non_wip_for_tag(pact_publications_query, provider, tag, specified_pact_version_shas)
         specified_explicitly = pact_publications_query.for_pact_version_sha(specified_pact_version_shas)
-        verified_by_this_tag = pact_publications_query.successfully_verified_by_provider_tag_when_not_wip(provider.id, tag)
+        verified_by_this_tag = pact_publications_query.successfully_verified_by_provider_tag_when_not_wip(tag)
         verified_by_another_tag = pact_publications_query.successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider.id, tag)
 
         log_debug_for_wip do

data/lib/pact_broker/pacts/service.rb

@@ -43,7 +43,7 @@ module PactBroker
       end
 
       def delete params
-        logger.info "Deleting pact version with params #{params}"
+        logger.info "Deleting pact version", payload: params
         pacts = pact_repository.find_all_revisions(params[:consumer_name], params[:consumer_version_number], params[:provider_name])
         webhook_service.delete_all_webhook_related_objects_by_pact_publication_ids(pacts.collect(&:id))
         pact_repository.delete(params)
@@ -156,7 +156,7 @@ module PactBroker
 
       # Overwriting an existing pact with the same consumer/provider/consumer version number
       def create_pact_revision params, existing_pact
-        logger.info "Updating existing pact publication", payload: params.reject{ |k, _v| k == :json_content }
+        logger.info "Updating existing pact publication", payload: params.without(:json_content)
         logger.debug "Content #{params[:json_content]}"
         pact_version_sha = generate_sha(params[:json_content])
         json_content = add_interaction_ids(params[:json_content])
@@ -185,7 +185,7 @@ module PactBroker
 
       # When no publication for the given consumer/provider/consumer version number exists
       def create_pact params, version, provider
-        logger.info "Creating new pact publication with params #{params.reject{ |k, _v| k == :json_content}}"
+        logger.info "Creating new pact publication", payload: params.without(:json_content)
         logger.debug "Content #{params[:json_content]}"
         pact_version_sha = generate_sha(params[:json_content])
         json_content = add_interaction_ids(params[:json_content])

data/lib/pact_broker/pacts/sort_content.rb

@@ -34,7 +34,7 @@ module PactBroker
         # You never can tell what people will do...
         if probably_array.is_a?(Array)
           array_with_ordered_hashes = order_hash_keys(probably_array)
-          array_with_ordered_hashes.sort{ |a, b| a.to_json <=> b.to_json }
+          array_with_ordered_hashes.sort_by(&:to_json)
         else
           probably_array
         end

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -273,6 +273,7 @@ module PactBroker
               "eventName" => "${pactbroker.eventName}",
               "consumerVersionNumber" => "${pactbroker.consumerVersionNumber}",
               "consumerVersionTags" => "${pactbroker.consumerVersionTags}",
+              "consumerVersionBranch" => "${pactbroker.consumerVersionBranch}",
               "githubVerificationStatus" => "${pactbroker.githubVerificationStatus}",
               "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
               "providerVersionTags" => "${pactbroker.providerVersionTags}",

data/lib/pact_broker/test/test_data_builder.rb

@@ -31,6 +31,8 @@ require "pact_broker/deployments/deployed_version_service"
 require "pact_broker/deployments/released_version_service"
 require "pact_broker/versions/branch_version_repository"
 require "pact_broker/integrations/repository"
+require "pact_broker/contracts/service"
+
 require "ostruct"
 
 module PactBroker
@@ -219,6 +221,27 @@ module PactBroker
         self
       end
 
+      def publish_pact(consumer_name:, provider_name:, consumer_version_number: , tags: nil, branch: nil, build_url: nil, json_content: nil)
+        json_content = json_content || random_json_content(consumer_name, provider_name)
+        contracts = [
+          PactBroker::Contracts::ContractToPublish.from_hash(consumer_name: consumer_name, provider_name: provider_name, decoded_content: json_content, content_type: "application/json", specification: "pact")
+        ]
+        contracts_to_publish = PactBroker::Contracts::ContractsToPublish.from_hash(
+          pacticipant_name: consumer_name,
+          pacticipant_version_number: consumer_version_number,
+          tags: tags,
+          branch: branch,
+          build_url: build_url,
+          contracts: contracts
+        )
+        PactBroker::Contracts::Service.publish(contracts_to_publish, base_url: "http://example.org")
+        @consumer = find_pacticipant(consumer_name)
+        @consumer_version = find_version(consumer_name, consumer_version_number)
+        @provider = find_pacticipant(provider_name)
+        @pact = PactBroker::Pacts::PactPublication.last.to_domain
+        self
+      end
+
       def create_pact params = {}
         params.delete(:comment)
         json_content = params[:json_content] || default_json_content
@@ -363,6 +386,7 @@ module PactBroker
       end
 
       def create_verification parameters = {}
+        # This should use the verification service. what a mess
         parameters.delete(:comment)
         branch = parameters.delete(:branch)
         tag_names = [parameters.delete(:tag_names), parameters.delete(:tag_name)].flatten.compact
@@ -373,20 +397,23 @@ module PactBroker
         parameters.delete(:provider_version)
         verification = PactBroker::Domain::Verification.new(parameters)
         pact_version = PactBroker::Pacts::Repository.new.find_pact_version(@consumer, @provider, pact.pact_version_sha)
-        @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, pact_version)
-        @provider_version = PactBroker::Domain::Version.where(pacticipant_id: @provider.id, number: provider_version_number).single_record
+        @provider_version = version_repository.find_by_pacticipant_id_and_number_or_create(provider.id, provider_version_number)
         PactBroker::Versions::BranchVersionRepository.new.add_branch(@provider_version, branch) if branch
 
-        set_created_at_if_set(parameters[:created_at], :verifications, id: @verification.id)
-        set_created_at_if_set(parameters[:created_at], :versions, id: @provider_version.id)
-        set_created_at_if_set(parameters[:created_at], :latest_verification_id_for_pact_version_and_provider_version, pact_version_id: pact_version_id, provider_version_id: @provider_version.id)
-
         if tag_names.any?
           tag_names.each do | tag_name |
-            PactBroker::Domain::Tag.new(name: tag_name, version: @provider_version).insert_ignore
+            PactBroker::Domain::Tag.new(name: tag_name, version: @provider_version, version_order: @provider_version.order).insert_ignore
             set_created_at_if_set(parameters[:created_at], :tags, version_id: @provider_version.id, name: tag_name)
           end
         end
+
+        @verification = PactBroker::Verifications::Repository.new.create(verification, provider_version_number, pact_version)
+
+        set_created_at_if_set(parameters[:created_at], :verifications, id: @verification.id)
+        set_created_at_if_set(parameters[:created_at], :versions, id: @provider_version.id)
+        set_created_at_if_set(parameters[:created_at], :latest_verification_id_for_pact_version_and_provider_version, pact_version_id: pact_version_id, provider_version_id: @provider_version.id)
+        set_created_at_if_set(parameters[:created_at], :pact_version_provider_tag_successful_verifications, { verification_id: @verification.id }, :execution_date)
+
         self
       end
 
@@ -594,10 +621,10 @@ module PactBroker
         PactBroker::Pacts::Content.from_json(json_content).with_ids(false).to_json
       end
 
-      def set_created_at_if_set created_at, table_name, selector
+      def set_created_at_if_set created_at, table_name, selector, date_column_name = :created_at
         date_to_set = created_at || @now
         if date_to_set
-          Sequel::Model.db[table_name].where(selector).update(created_at: date_to_set)
+          Sequel::Model.db[table_name].where(selector).update(date_column_name => date_to_set)
           if Sequel::Model.db.schema(table_name).any?{ |col| col.first == :updated_at }
             Sequel::Model.db[table_name].where(selector.keys.first => selector.values.first).update(updated_at: date_to_set)
           end

data/lib/pact_broker/verifications/pact_version_provider_tag_successful_verification.rb

@@ -0,0 +1,11 @@
+require "pact_broker/domain/verification"
+
+# Represents a non WIP, successful verification for a provider version with a tag.
+
+module PactBroker
+  module Verifications
+    class PactVersionProviderTagSuccessfulVerification < Sequel::Model
+      plugin :insert_ignore, identifying_columns: [:pact_version_id, :provider_version_tag_name, :wip]
+    end
+  end
+end

data/lib/pact_broker/verifications/repository.rb

@@ -2,6 +2,7 @@ require "sequel"
 require "pact_broker/domain/verification"
 require "pact_broker/verifications/sequence"
 require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
+require "pact_broker/verifications/pact_version_provider_tag_successful_verification"
 
 module PactBroker
   module Verifications
@@ -27,6 +28,7 @@ module PactBroker
         verification.tag_names = version.tag_names # TODO pass this in from contracts service
         verification.save
         update_latest_verification_id(verification)
+        update_pact_version_provider_tag_verifications(verification, version.tag_names)
         verification
       end
 
@@ -46,6 +48,20 @@ module PactBroker
         LatestVerificationIdForPactVersionAndProviderVersion.new(params).upsert
       end
 
+      def update_pact_version_provider_tag_verifications(verification, tag_names)
+        if verification.success
+          tag_names&.each do | tag_name |
+            PactVersionProviderTagSuccessfulVerification.new(
+              pact_version_id: verification.pact_version_id,
+              provider_version_tag_name: tag_name,
+              wip: verification.wip,
+              verification_id: verification.id,
+              execution_date: verification.execution_date
+            ).insert_ignore
+          end
+        end
+      end
+
       def find consumer_name, provider_name, pact_version_sha, verification_number
         PactBroker::Domain::Verification
           .select_all_qualified

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.91.0"
+  VERSION = "2.93.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.91.0
+  version: 2.93.2
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-15 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -587,6 +587,8 @@ files:
 - db/migrations/20211102_create_table_temp_integrations.rb
 - db/migrations/20211103_migrate_integrations.rb
 - db/migrations/20211104_switch_integrations_and_temp_integrations.rb
+- db/migrations/20211120_create_pact_version_provider_tag_successful_verifications.rb
+- db/migrations/20211121_migrate_pact_version_provider_tag_successful_verifications_data.rb
 - db/migrations/migration_helper.rb
 - docs/CONFIGURATION.md
 - docs/api/WEBHOOKS.md
@@ -797,6 +799,7 @@ files:
 - lib/pact_broker/db/data_migrations/delete_deprecated_webhook_executions.rb
 - lib/pact_broker/db/data_migrations/helpers.rb
 - lib/pact_broker/db/data_migrations/migrate_integrations.rb
+- lib/pact_broker/db/data_migrations/migrate_pact_version_provider_tag_successful_verifications.rb
 - lib/pact_broker/db/data_migrations/migrate_webhook_headers.rb
 - lib/pact_broker/db/data_migrations/set_consumer_ids_for_pact_publications.rb
 - lib/pact_broker/db/data_migrations/set_consumer_version_order_for_pact_publications.rb
@@ -1028,6 +1031,7 @@ files:
 - lib/pact_broker/verifications/latest_verification_for_consumer_and_provider.rb
 - lib/pact_broker/verifications/latest_verification_for_consumer_version_tag.rb
 - lib/pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version.rb
+- lib/pact_broker/verifications/pact_version_provider_tag_successful_verification.rb
 - lib/pact_broker/verifications/placeholder_verification.rb
 - lib/pact_broker/verifications/pseudo_branch_status.rb
 - lib/pact_broker/verifications/repository.rb
@@ -1043,7 +1047,6 @@ files:
 - lib/pact_broker/versions/branch_version.rb
 - lib/pact_broker/versions/branch_version_repository.rb
 - lib/pact_broker/versions/eager_loaders.rb
-- lib/pact_broker/versions/latest_version.rb
 - lib/pact_broker/versions/parse_semantic_version.rb
 - lib/pact_broker/versions/repository.rb
 - lib/pact_broker/versions/selector.rb
@@ -1220,7 +1223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.3.1
 signing_key: 
 specification_version: 4
 summary: See description

data/lib/pact_broker/versions/latest_version.rb

@@ -1,21 +0,0 @@
-require "pact_broker/domain/version"
-
-module PactBroker
-  module Versions
-    include PactBroker::Repositories::Helpers
-
-    class LatestVersion < PactBroker::Domain::Version
-      set_dataset(:latest_versions)
-    end
-  end
-end
-
-# Table: latest_versions
-# Columns:
-#  id             | integer                     |
-#  number         | text                        |
-#  repository_ref | text                        |
-#  pacticipant_id | integer                     |
-#  order          | integer                     |
-#  created_at     | timestamp without time zone |
-#  updated_at     | timestamp without time zone |