pact_broker 2.103.0 → 2.105.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a82ecff0b79c081b9f3712bde752b9983e7377eb8d48120616c8c3fcf237076c
-  data.tar.gz: cef4b3136255cbba17ad31e9001c935393989df848666ddb712e81884ac61003
+  metadata.gz: c43c0dbf719c9e927fad6ffcee28b559036726a61a41813a3451554e5f1db087
+  data.tar.gz: '0964dcfea819d1ccc1c1ccc15d8a7493670dfbefbde75aedb63ac9405c7c764d'
 SHA512:
-  metadata.gz: cb22f318c1f69dc91ceb7a84c940170600ceaf4a53e3ef65eabb7876fd2510867ad243cb1fb4cb22cf06e7b370f868cb01199697de73835879423d1371d6e19b
-  data.tar.gz: 87507ea9c45bc37318b98a9b8d53ab5a703eeffd1970cb111f3c8d639015f08442a0839376c4d59cc3e321005cb77da11466a1ca5340661905d66578c5aa669d
+  metadata.gz: 12f323b624a2ff4dcc7827e254ec71c83a1d3ffe89532746feb67e360aa5fda938927f43176b86ea08b7b3fddf66d4ef0a5c8cf9ec6b4190332e572a2fd4ad0a
+  data.tar.gz: a3a5aed03639c5ef8ab602da938e502e4b0434248c99de262bac7a1d6a09e42e4991d32748ae542bfdf1376db133957ff69652b99e49cc1fdfc22f0845907f22

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+<a name="v2.105.0"></a>
+### v2.105.0 (2022-10-19)
+
+#### Features
+
+* update wording of version description for version in environment	 ([d122fa68](/../../commit/d122fa68))
+
+* **webhooks**
+  * allow auth headers to be logged for debugging purposes (#575)	 ([102b1930](/../../commit/102b1930))
+
+#### Bug Fixes
+
+* add validation to ensure an environment or to tag is specified for the /can-i-deploy endpoint	 ([e9d772eb](/../../commit/e9d772eb))
+* implement pending logic for provider branches	 ([7cdf1a7c](/../../commit/7cdf1a7c))
+
+* **wip pacts**
+  * fix performance issue encountered when removing explicitly specified pacts from the list of potential WIP pacts (#573)	 ([757f0301](/../../commit/757f0301))
+
+<a name="v2.104.0"></a>
+### v2.104.0 (2022-09-17)
+
+#### Features
+
+* ignore deleted webhooks when calculating the latest triggered webhook status	 ([c3105dcb](/../../commit/c3105dcb))
+
 <a name="v2.103.0"></a>
 ### v2.103.0 (2022-09-14)
 

data/lib/pact_broker/api/middleware/http_debug_logs.rb

@@ -21,9 +21,9 @@ module PactBroker
             env_to_log = env.reject { | header, _ | header.start_with?(*EXCLUDE_HEADERS) }
             env_to_log["rack.session"] = env["rack.session"].to_hash if env["rack.session"]
             env_to_log["rack.input"] = request_body(env) if env["rack.input"]
-            logger.debug("env", payload: env_to_log)
+            logger.debug("env", env_to_log)
             status, headers, body = @app.call(env)
-            logger.debug("response", payload: { "status" => status, "headers" => headers, "body" => body })
+            logger.debug("response", "status" => status, "headers" => headers, "body" => body)
             [status, headers, body]
           else
             @app.call(env)

data/lib/pact_broker/app.rb

@@ -223,7 +223,7 @@ module PactBroker
           except: configuration.rack_protection_except
         }.compact
 
-        logger.info("Configuring Rack::Protection", payload: rack_protection_options)
+        logger.info("Configuring Rack::Protection", rack_protection_options)
         @app_builder.use Rack::Protection, rack_protection_options
 
         is_hal_browser = ->(env) { env["PATH_INFO"] == "/hal-browser/browser.html" }

data/lib/pact_broker/config/runtime_configuration.rb

@@ -52,6 +52,7 @@ module PactBroker
         webhook_http_code_success: [200, 201, 202, 203, 204, 205, 206],
         webhook_scheme_whitelist: ["https"],
         webhook_host_whitelist: [],
+        webhook_redact_sensitive_data: true,
         disable_ssl_verification: false,
         user_agent: "Pact Broker v#{PactBroker::VERSION}"
       )

data/lib/pact_broker/config/runtime_configuration_logging_methods.rb

@@ -31,6 +31,9 @@ module PactBroker
               source: source_info.dig(key, :source) || {:type=>:defaults}
             }
           end.sort_by { |key, _| key }.each { |key, value| log_config_inner(key, value, logger) }
+          if self.webhook_redact_sensitive_data == false
+            logger.warn("WARNING!!! webhook_redact_sensitive_data is set to false. This will allow authentication information to be included in the webhook logs. This should only be used for debugging purposes. Do not run the application permanently in production with this value.")
+          end
         end
 
         def log_config_inner(key, value, logger)

data/lib/pact_broker/configuration.rb

@@ -94,7 +94,7 @@ module PactBroker
       end
 
       if logger.debug?
-        logger.debug("Overridding runtime configuration", payload: { overrides: valid_overrides, ignoring: invalid_overrides })
+        logger.debug("Overridding runtime configuration", overrides: valid_overrides, ignoring: invalid_overrides)
       end
 
       valid_overrides.each do | key, value |
@@ -106,7 +106,6 @@ module PactBroker
 
     def logger_from_runtime_configuration
       @logger_from_runtime_configuration ||= begin
-        runtime_configuration.validate_logging_attributes!
         SemanticLogger.default_level = runtime_configuration.log_level
         if runtime_configuration.log_stream == :file
           path = runtime_configuration.log_dir + "/pact_broker.log"

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

@@ -23,9 +23,9 @@ module PactBroker
 
           if main_branch_name
             connection[:pacticipants].where(id: pacticipant_row[:id], main_branch: nil).update(main_branch: main_branch_name)
-            logger.info("Setting main branch for pacticipant", payload: { branch: main_branch_name, pacticipant_name: pacticipant_row[:name] })
+            logger.info("Setting main branch for pacticipant", branch: main_branch_name, pacticipant_name: pacticipant_row[:name])
           else
-            logger.info("Cannot determine main branch for pacticipant", payload: { branch: nil, pacticipant_name: pacticipant_row[:name] })
+            logger.info("Cannot determine main branch for pacticipant", branch: nil, pacticipant_name: pacticipant_row[:name])
           end
         end
 

data/lib/pact_broker/domain/pact.rb

@@ -94,7 +94,13 @@ module PactBroker
         provider_version_tags - tags_with_successful_verifications_from_that_branch - tags_with_previous_successful_verifications_from_other_branches
       end
 
-      def pending?
+      # @param [String] branch_name the name of the provider branch that will be verifying the pacts
+      # @return Boolean whether or not the pact is in pending state (ie. the build should not fail if the verification fails)
+      def pending_for_provider_branch?(branch_name)
+        pact_version.pending_for_provider_branch?(branch_name)
+      end
+
+      def pending_for_any_provider_branch?
         !pact_version.verified_successfully_by_any_provider_version?
       end
 

data/lib/pact_broker/initializers/database_connection.rb

@@ -4,7 +4,7 @@ require "fileutils"
 
 module PactBroker
   def self.create_database_connection(config, logger = nil)
-    logger&.info "Connecting to database:", payload: "#{config.merge(password: "*****")}"
+    logger&.info("Connecting to database:", config.merge(password: "*****"))
 
     sequel_config = config.dup
     max_retries = sequel_config.delete(:connect_max_retries) || 0

data/lib/pact_broker/integrations/integration.rb

@@ -12,7 +12,14 @@ module PactBroker
       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_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])
+
+      one_to_many(:latest_triggered_webhooks,
+        :class => PactBroker::Webhooks::TriggeredWebhook,
+        key: [:consumer_id, :provider_id],
+        allow_eager: true,
+        primary_key: [:consumer_id, :provider_id]) do | ds |
+          ds.latest_triggered_webhooks
+        end
 
       # 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.

data/lib/pact_broker/locale/en.yml

@@ -85,6 +85,7 @@ en:
         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.
+        must_specify_environment_or_tag: Must specify either an environment or a 'to' tag.
         cannot_specify_tag_and_environment: Cannot specify both a 'to' tag and an environment.
         cannot_specify_latest_and_environment: Cannot specify both latest=true and an environment.
         cannot_specify_more_than_one_destination_identifier: Cannot specify more than one of tag, environment and mainBranch.

data/lib/pact_broker/matrix/can_i_deploy_query_schema.rb

@@ -2,12 +2,14 @@ require "dry-validation"
 require "pact_broker/messages"
 require "pact_broker/api/contracts/dry_validation_predicates"
 require "pact_broker/project_root"
+require "pact_broker/string_refinements"
 
 module PactBroker
   module Api
     module Contracts
       class CanIDeployQuerySchema
         extend PactBroker::Messages
+        using PactBroker::StringRefinements
 
         SCHEMA = Dry::Validation.Schema do
           configure do
@@ -26,6 +28,10 @@ module PactBroker
             result[:to] ||= []
             result[:to] << message("errors.validation.cannot_specify_tag_and_environment")
           end
+          if params[:to].blank? && params[:environment].blank?
+            result[:environment] ||= []
+            result[:environment] << message("errors.validation.must_specify_environment_or_tag")
+          end
           result
         end
 

data/lib/pact_broker/matrix/deployment_status_summary.rb

@@ -161,7 +161,7 @@ module PactBroker
       end
 
       def log_required_integrations_without_a_row_occurred integrations
-        logger.info("required_integrations_without_a_row returned non empty", payload: { integrations: integrations, considered_rows: considered_rows })
+        logger.info("required_integrations_without_a_row returned non empty", integrations: integrations, considered_rows: considered_rows)
       end
 
       def row_exists_for_integration(integration)

data/lib/pact_broker/matrix/resolved_selector.rb

@@ -211,9 +211,9 @@ module PactBroker
           "a version of #{pacticipant_name} with tag #{tag} (no such version exists)"
         elsif environment_name && pacticipant_version_number
           prefix = one_of_many? ? "one of the versions" : "the version"
-          "#{prefix} of #{pacticipant_name} currently deployed or released to #{environment_name} (#{pacticipant_version_number})"
+          "#{prefix} of #{pacticipant_name} currently in #{environment_name} (#{pacticipant_version_number})"
         elsif environment_name
-          "a version of #{pacticipant_name} currently deployed or released to #{environment_name} (no version is currently recorded as deployed/released in this environment)"
+          "a version of #{pacticipant_name} currently in #{environment_name} (no version is currently recorded as deployed/released in this environment)"
         elsif pacticipant_version_number && version_does_not_exist?
           "version #{pacticipant_version_number} of #{pacticipant_name} (no such version exists)"
         elsif pacticipant_version_number

data/lib/pact_broker/pacts/pact_version.rb

@@ -80,6 +80,14 @@ module PactBroker
           }
           join(:tags, tags_join)
         end
+
+        def join_branch_versions_for_branch_name_to_verifications(branch_name)
+          branch_versions_join = {
+            Sequel[:branch_versions][:version_id] => Sequel[:verifications][:provider_version_id],
+            Sequel[:branch_versions][:branch_name] => branch_name
+          }
+          join(:branch_versions, branch_versions_join)
+        end
       end
 
       def name
@@ -106,6 +114,10 @@ module PactBroker
         latest_consumer_version.number
       end
 
+      def pending_for_provider_branch?(branch_name)
+        !any_successful_verifications_from_provider_branch?(branch_name) && !any_successful_verifications_from_another_branch_from_before_this_branch_created?(branch_name)
+      end
+
       def select_provider_tags_with_successful_verifications_from_another_branch_from_before_this_branch_created(tags)
         tags.select do | tag |
           first_tag_with_name = PactBroker::Domain::Tag.where(pacticipant_id: provider_id, name: tag).order(:created_at).first
@@ -157,6 +169,33 @@ module PactBroker
           )
         end
       end
+
+      def any_successful_verifications_from_provider_branch?(branch_name)
+        PactVersion.where(Sequel[:pact_versions][:id] => id)
+          .join_successful_verifications
+          .join_branch_versions_for_branch_name_to_verifications(branch_name)
+          .any?
+      end
+
+      def any_successful_verifications_from_another_branch_from_before_this_branch_created?(branch_name)
+        branch = PactBroker::Versions::Branch.where(pacticipant_id: provider_id, name: branch_name).single_record
+
+        verifications_join = {
+          Sequel[:verifications][:pact_version_id] => Sequel[:pact_versions][:id],
+          Sequel[:verifications][:success] => true
+        }
+        query = PactVersion.where(Sequel[:pact_versions][:id] => id)
+          .join(:verifications, verifications_join)
+          .join(:branch_versions, Sequel[:branch_versions][:version_id] => Sequel[:verifications][:provider_version_id]) do
+            Sequel.lit("branch_versions.branch_name != ?", branch_name)
+          end
+
+        if branch
+          query = query.where { Sequel[:verifications][:created_at] < branch.created_at }
+        end
+
+        query.any?
+      end
     end
   end
 end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -12,6 +12,7 @@ require "pact_broker/repositories/scopes"
 
 module PactBroker
   module Pacts
+    # rubocop: disable Metrics/ClassLength
     class PactsForVerificationRepository
       include PactBroker::Logging
       include PactBroker::Repositories
@@ -26,6 +27,7 @@ module PactBroker
         :pact_version
       ]
 
+      # @return [VerifiablePact] an array of VerifiablePact objects
       def find(provider_name, consumer_version_selectors)
         selected_pacts = find_pacts_by_selector(provider_name, consumer_version_selectors)
         selected_pacts = selected_pacts + find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
@@ -43,7 +45,7 @@ module PactBroker
       # provider tags they are pending for.
       # Don't include pact publications that were created before the provider tag was first used
       # (that is, before the provider's git branch was created).
-      def find_wip provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options = {}
+      def find_wip(provider_name, provider_version_branch, provider_tags_names, explicitly_specified_verifiable_pacts, options = {})
         # TODO not sure about this
         if provider_tags_names.empty? && provider_version_branch == nil
           log_debug_for_wip do
@@ -53,7 +55,7 @@ module PactBroker
         end
 
         if provider_version_branch
-          return find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, specified_pact_version_shas, options)
+          return find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, explicitly_specified_verifiable_pacts, options)
         end
 
         provider = pacticipant_repository.find_by_name(provider_name)
@@ -63,7 +65,7 @@ module PactBroker
           provider,
           provider_tags_names,
           wip_start_date,
-          specified_pact_version_shas,
+          explicitly_specified_verifiable_pacts,
           :latest_by_consumer_tag
         )
 
@@ -71,7 +73,7 @@ module PactBroker
           provider,
           provider_tags_names,
           wip_start_date,
-          specified_pact_version_shas,
+          explicitly_specified_verifiable_pacts,
           :latest_by_consumer_branch
         )
 
@@ -139,7 +141,7 @@ module PactBroker
         selectors = selector_for_latest_main_version_or_overall_latest(provider)
         selectors << Selector.for_currently_deployed
         selectors << Selector.for_currently_supported
-        logger.debug("Default selectors", payload: selectors)
+        logger.debug("Default selectors", selectors)
         selectors
       end
 
@@ -193,11 +195,11 @@ module PactBroker
       end
 
       # TODO ? find the WIP pacts by consumer branch
-      def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, wip_start_date, specified_pact_version_shas, pact_publication_scope)
+      def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, wip_start_date, explicitly_specified_verifiable_pacts, pact_publication_scope)
         potential_wip_pacts_by_consumer_tag_query = PactPublication.for_provider(provider).created_after(wip_start_date).send(pact_publication_scope)
 
         log_debug_for_wip do
-          log_pact_publications("Potential WIP pacts for provider tag(s) #{provider_tags_names.join(", ")} created after #{wip_start_date} by #{pact_publication_scope}", potential_wip_pacts_by_consumer_tag_query)
+          log_pact_publications_from_query("Potential WIP pacts for provider tag(s) #{provider_tags_names.join(", ")} created after #{wip_start_date} by #{pact_publication_scope}", potential_wip_pacts_by_consumer_tag_query)
         end
 
         tag_to_pact_publications = provider_tags_names.each_with_object({}) do | provider_tag_name, tag_to_pact_publication |
@@ -205,7 +207,7 @@ module PactBroker
             potential_wip_pacts_by_consumer_tag_query,
             provider,
             provider_tag_name,
-            specified_pact_version_shas
+            explicitly_specified_verifiable_pacts
           )
         end
 
@@ -225,7 +227,7 @@ module PactBroker
         end
       end
 
-      def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, specified_pact_version_shas, options)
+      def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, explicitly_specified_verifiable_pacts, options)
         provider = pacticipant_repository.find_by_name(provider_name)
         wip_start_date = options.fetch(:include_wip_pacts_since)
 
@@ -233,22 +235,22 @@ module PactBroker
         potential_wip_by_consumer_tag = PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_tag
 
         log_debug_for_wip do
-          log_pact_publications("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer branch", potential_wip_by_consumer_branch)
-          log_pact_publications("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer tag", potential_wip_by_consumer_tag)
+          log_pact_publications_from_query("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer branch", potential_wip_by_consumer_branch)
+          log_pact_publications_from_query("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer tag", potential_wip_by_consumer_tag)
         end
 
         wip_pact_publications_by_branch = remove_non_wip_for_branch(
           potential_wip_by_consumer_branch,
           provider,
           provider_version_branch,
-          specified_pact_version_shas
+          explicitly_specified_verifiable_pacts
         )
 
         wip_pact_publications_by_tag = remove_non_wip_for_branch(
           potential_wip_by_consumer_tag,
           provider,
           provider_version_branch,
-          specified_pact_version_shas
+          explicitly_specified_verifiable_pacts
         )
 
         verifiable_pacts = (wip_pact_publications_by_branch + wip_pact_publications_by_tag).collect do | pact_publication |
@@ -259,55 +261,61 @@ module PactBroker
         deduplicate_verifiable_pacts(verifiable_pacts).sort
       end
 
-      def remove_non_wip_for_branch(pact_publications_query, provider, provider_version_branch, specified_pact_version_shas)
-        specified_explicitly = pact_publications_query.for_pact_version_sha(specified_pact_version_shas)
+      def remove_non_wip_for_branch(pact_publications_query, provider, provider_version_branch, explicitly_specified_verifiable_pacts)
         verified_by_this_branch = pact_publications_query.successfully_verified_by_provider_branch_when_not_wip(provider.id, provider_version_branch)
         verified_by_other_branch = pact_publications_query.successfully_verified_by_provider_another_branch_before_this_branch_first_created(provider.id, provider_version_branch)
 
         log_debug_for_wip do
-          log_pact_publications("Ignoring pacts explicitly specified in the selectors", specified_explicitly)
-          log_pact_publications("Ignoring pacts successfully verified by this provider branch when not WIP", verified_by_this_branch)
-          log_pact_publications("Ignoring pacts successfully verified by another provider branch when not WIP", verified_by_other_branch)
+          log_pact_publications("Ignoring pacts explicitly specified in the selectors", explicitly_specified_verifiable_pacts)
+          log_pact_publications_from_query("Ignoring pacts successfully verified by this provider branch when not WIP", verified_by_this_branch)
+          log_pact_publications_from_query("Ignoring pacts successfully verified by another provider branch when not WIP", verified_by_other_branch)
         end
 
-        PactPublication.subtract(
-          pact_publications_query.eager(*PUBLICATION_ASSOCIATIONS_FOR_EAGER_LOAD).all,
-          specified_explicitly.all,
-          verified_by_this_branch.all,
-          verified_by_other_branch.all
-        )
+        remove_explicitly_specified_verifiable_pacts(PactPublication.subtract(
+            pact_publications_query.eager(*PUBLICATION_ASSOCIATIONS_FOR_EAGER_LOAD).all,
+            verified_by_this_branch.all,
+            verified_by_other_branch.all),
+          explicitly_specified_verifiable_pacts)
       end
 
-      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)
+      def remove_non_wip_for_tag(pact_publications_query, provider, tag, explicitly_specified_verifiable_pacts)
         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
-          log_pact_publications("Ignoring pacts explicitly specified in the selectors", specified_explicitly)
-          log_pact_publications("Ignoring pacts successfully verified by this provider tag when not WIP", verified_by_this_tag)
-          log_pact_publications("Ignoring pacts successfully verified by another provider tag when not WIP", verified_by_another_tag)
+          log_pact_publications("Ignoring pacts explicitly specified in the selectors", explicitly_specified_verifiable_pacts)
+          log_pact_publications_from_query("Ignoring pacts successfully verified by this provider tag when not WIP", verified_by_this_tag)
+          log_pact_publications_from_query("Ignoring pacts successfully verified by another provider tag when not WIP", verified_by_another_tag)
         end
 
-        PactPublication.subtract(
-          pact_publications_query.eager(*PUBLICATION_ASSOCIATIONS_FOR_EAGER_LOAD).all,
-          specified_explicitly.all,
-          verified_by_this_tag.all,
-          verified_by_another_tag.all)
+        remove_explicitly_specified_verifiable_pacts(
+          PactPublication.subtract(
+            pact_publications_query.eager(*PUBLICATION_ASSOCIATIONS_FOR_EAGER_LOAD).all,
+            verified_by_this_tag.all,
+            verified_by_another_tag.all),
+          explicitly_specified_verifiable_pacts)
       end
 
-      def collect_consumer_name_and_version_number(pact_publications_query)
-        pact_publications = pact_publications_query
-                              .eager(:consumer, :consumer_version)
-                              .order(:consumer_version_order)
-                              .all_forbidding_lazy_load
-                              .sort
+      def remove_explicitly_specified_verifiable_pacts(pact_publications, explicitly_specified_verifiable_pacts)
+        pact_publications.reject do | pact_publication |
+          explicitly_specified_verifiable_pacts.find{ | explict_pact |
+            explict_pact.consumer.id == pact_publication.consumer_id &&
+              explict_pact.provider.id == pact_publication.provider_id &&
+              explict_pact.pact_version_sha == pact_publication.pact_version_sha
+          }
+        end
+      end
 
+      def collect_consumer_name_and_version_number(pact_publications)
         pact_publications.collect do |p|
-          suffix =  if p.values[:tag_name]
-                      " (tag #{p.values[:tag_name]})"
-                    elsif p.values[:branch_name]
-                      " (branch #{p.values[:branch_name]})"
+          suffix =  if p.respond_to?(:values)
+                      if p.values[:tag_name]
+                        " (tag #{p.values[:tag_name]})"
+                      elsif p.values[:branch_name]
+                        " (branch #{p.values[:branch_name]})"
+                      else
+                        ""
+                      end
                     else
                       ""
                     end
@@ -316,10 +324,28 @@ module PactBroker
         end
       end
 
-      def log_pact_publications(message, pact_publications_query)
-        pact_publication_descriptions = collect_consumer_name_and_version_number(pact_publications_query)
+      def with_sorted_eager_fields(pact_publications_query)
+        pact_publications_query
+          .eager(:provider)
+          .eager(:consumer, :consumer_version)
+          .order(:consumer_version_order)
+          .all_forbidding_lazy_load
+          .sort
+      end
+
+      def log_pact_publications_from_query(message, pact_publications_query)
+        pact_publication_descriptions = collect_consumer_name_and_version_number(with_sorted_eager_fields(pact_publications_query))
+        if pact_publication_descriptions.any?
+          logger.debug("#{message}", pact_publication_descriptions)
+        else
+          logger.debug("#{message} (none)")
+        end
+      end
+
+      def log_pact_publications(message, pact_publications)
+        pact_publication_descriptions = collect_consumer_name_and_version_number(pact_publications)
         if pact_publication_descriptions.any?
-          logger.debug("#{message}", payload: pact_publication_descriptions)
+          logger.debug("#{message}", pact_publication_descriptions)
         else
           logger.debug("#{message} (none)")
         end
@@ -333,5 +359,6 @@ module PactBroker
         end
       end
     end
+    # rubocop: enable Metrics/ClassLength
   end
 end

data/lib/pact_broker/pacts/repository.rb

@@ -158,8 +158,8 @@ module PactBroker
         PactsForVerificationRepository.new.find(provider_name, consumer_version_selectors)
       end
 
-      def find_wip_pact_versions_for_provider provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options = {}
-        PactsForVerificationRepository.new.find_wip(provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options)
+      def find_wip_pact_versions_for_provider provider_name, provider_version_branch, provider_tags_names, explicitly_specified_verifiable_pacts, options = {}
+        PactsForVerificationRepository.new.find_wip(provider_name, provider_version_branch, provider_tags_names, explicitly_specified_verifiable_pacts, options)
       end
 
       def find_pact_versions_for_provider provider_name, tag = nil

data/lib/pact_broker/pacts/service.rb

@@ -43,7 +43,7 @@ module PactBroker
       end
 
       def delete params
-        logger.info "Deleting pact version", payload: params
+        logger.info("Deleting pact version", 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)
@@ -122,12 +122,11 @@ module PactBroker
           .find_for_verification(provider_name, consumer_version_selectors)
           .collect do | selected_pact |
             # Todo move this into the repository
-            squash_pacts_for_verification(provider_version_tags, selected_pact, options[:include_pending_status])
+            squash_pacts_for_verification(provider_version_tags, provider_version_branch, selected_pact, options[:include_pending_status])
           end
 
         verifiable_wip_pacts =  if options[:include_wip_pacts_since]
-                                  specified_pact_version_shas = explicitly_specified_verifiable_pacts.collect(&:pact_version_sha)
-                                  pact_repository.find_wip_pact_versions_for_provider(provider_name, provider_version_branch, provider_version_tags, specified_pact_version_shas, options)
+                                  pact_repository.find_wip_pact_versions_for_provider(provider_name, provider_version_branch, provider_version_tags, explicitly_specified_verifiable_pacts, options)
                                 else
                                   []
                                 end
@@ -156,8 +155,8 @@ 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.without(:json_content)
-        logger.debug "Content #{params[:json_content]}"
+        logger.info("Updating existing pact publication", 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])
         update_params = { pact_version_sha: pact_version_sha, json_content: json_content }
@@ -185,8 +184,8 @@ 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", payload: params.without(:json_content)
-        logger.debug "Content #{params[:json_content]}"
+        logger.info("Creating new pact publication", 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])
         pact = pact_repository.create(

data/lib/pact_broker/pacts/squash_pacts_for_verification.rb

@@ -5,17 +5,19 @@
 module PactBroker
   module Pacts
     module SquashPactsForVerification
-      def self.call(provider_version_tags, selected_pact, include_pending_status = false)
+      def self.call(provider_version_tags, provider_version_branch, selected_pact, include_pending_status = false)
         domain_pact = selected_pact.pact
 
         if include_pending_status
           pending_provider_tags = []
           pending = nil
-          if provider_version_tags.any?
+          if provider_version_branch
+            pending = domain_pact.pending_for_provider_branch?(provider_version_branch)
+          elsif provider_version_tags.any?
             pending_provider_tags = domain_pact.select_pending_provider_version_tags(provider_version_tags)
             pending = pending_provider_tags.any?
           else
-            pending = domain_pact.pending?
+            pending = domain_pact.pending_for_any_provider_branch?
           end
           non_pending_provider_tags = provider_version_tags - pending_provider_tags
           VerifiablePact.new(
@@ -23,7 +25,8 @@ module PactBroker
             selected_pact.selectors,
             pending,
             pending_provider_tags,
-            non_pending_provider_tags
+            non_pending_provider_tags,
+            provider_version_branch
           )
         else
           VerifiablePact.new(

data/lib/pact_broker/tasks/clean_task.rb

@@ -63,7 +63,7 @@ module PactBroker
       end
 
       def output string, payload = {}
-        logger ? logger.info(string, payload: payload) : puts("#{string} #{payload.to_json}")
+        logger ? logger.info(string, payload) : puts("#{string} #{payload.to_json}")
       end
 
       def add_defaults_to_keep_selectors

data/lib/pact_broker/tasks/delete_overwritten_data_task.rb

@@ -46,7 +46,7 @@ module PactBroker
       end
 
       def output string, payload = {}
-        logger ? logger.info(string, payload: payload) : puts("#{string} #{payload.to_json}")
+        logger ? logger.info(string, payload) : puts("#{string} #{payload.to_json}")
       end
     end
   end

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -265,7 +265,9 @@ module PactBroker
           "request" => {
             "method" => "POST",
             "url" => url,
-            "body" => body || default_body
+            "body" => body || default_body,
+            "username" => "user",
+            "password" => "pass"
           }
         }.compact
         path = "webhooks/#{uuid}"
@@ -286,32 +288,9 @@ module PactBroker
       def create_global_webhook_for_anything_published(uuid: nil, url: "https://postman-echo.com/post")
         puts "Creating global webhook for contract changed event with uuid #{uuid}"
         uuid ||= SecureRandom.uuid
-        request_body = {
-          "description" => "A webhook for all consumers and providers",
-          "events" => [{
-            "name" => "contract_published"
-          },{
-            "name" => "provider_verification_published"
-          }],
-          "request" => {
-            "method" => "POST",
-            "url" => url,
-            "headers" => { "Content-Type" => "application/json"},
-            "body" => {
-              "eventName" => "${pactbroker.eventName}",
-              "consumerVersionNumber" => "${pactbroker.consumerVersionNumber}",
-              "consumerVersionTags" => "${pactbroker.consumerVersionTags}",
-              "consumerVersionBranch" => "${pactbroker.consumerVersionBranch}",
-              "githubVerificationStatus" => "${pactbroker.githubVerificationStatus}",
-              "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
-              "providerVersionTags" => "${pactbroker.providerVersionTags}",
-              "providerVersionBranch" => "${pactbroker.providerVersionBranch}",
-              "canIMerge" => "${pactbroker.providerMainBranchGithubVerificationStatus}"
-            }
-          }
-        }
+
         path = "webhooks/#{uuid}"
-        client.put(path, request_body.to_json).tap { |response| check_for_error(response) }
+        client.put(path, webhook_body_with_all_parameters(url).to_json).tap { |response| check_for_error(response) }
         separate
         self
       end
@@ -438,6 +417,35 @@ module PactBroker
           puts response.body
         end
       end
+
+      def webhook_body_with_all_parameters(url)
+        {
+          "description" => "A webhook for all consumers and providers",
+          "events" => [{
+            "name" => "contract_published"
+          },{
+            "name" => "provider_verification_published"
+          }],
+          "request" => {
+            "method" => "POST",
+            "url" => url,
+            "headers" => { "Content-Type" => "application/json"},
+            "username" => "user",
+            "password" => "pass",
+            "body" => {
+              "eventName" => "${pactbroker.eventName}",
+              "consumerVersionNumber" => "${pactbroker.consumerVersionNumber}",
+              "consumerVersionTags" => "${pactbroker.consumerVersionTags}",
+              "consumerVersionBranch" => "${pactbroker.consumerVersionBranch}",
+              "githubVerificationStatus" => "${pactbroker.githubVerificationStatus}",
+              "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
+              "providerVersionTags" => "${pactbroker.providerVersionTags}",
+              "providerVersionBranch" => "${pactbroker.providerVersionBranch}",
+              "canIMerge" => "${pactbroker.providerMainBranchGithubVerificationStatus}"
+            }
+          }
+        }
+      end
     end
   end
 end

data/lib/pact_broker/test/test_data_builder.rb

@@ -399,22 +399,13 @@ module PactBroker
         verification = PactBroker::Domain::Verification.new(parameters)
         pact_version = PactBroker::Pacts::Repository.new.find_pact_version(@consumer, @provider, pact.pact_version_sha)
         @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
+        branch_version = PactBroker::Versions::BranchVersionRepository.new.add_branch(@provider_version, branch) if branch
 
-        if tag_names.any?
-          tag_names.each do | tag_name |
-            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
+        set_created_at_for_provider_tags(parameters, tag_names)
 
         @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)
-
+        set_created_at_for_verification_resources(parameters, pact_version.id, branch, branch_version)
         self
       end
 
@@ -674,6 +665,31 @@ module PactBroker
           [nil, Domain::WebhookPacticipant.new(label: label)]
         end
       end
+
+      def set_created_at_for_provider_tags(parameters, tag_names)
+        if tag_names.any?
+          tag_names.each do | tag_name |
+            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
+      end
+
+      def set_created_at_for_verification_resources(parameters, pact_version_id, branch, branch_version)
+        if branch
+          set_created_at_if_set(parameters[:created_at], :branch_versions, id: branch_version.id)
+
+          # if the branch has just been created...
+          if branch_version.branch.branch_versions.size == 1
+            set_created_at_if_set(parameters[:created_at], :branches, id: branch_version.branch.id)
+          end
+        end
+
+        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)
+      end
     end
   end
 end

data/lib/pact_broker/verifications/service.rb

@@ -33,7 +33,7 @@ module PactBroker
       # verified_pacts is an array of SelectedPact objects
       def create next_verification_number, params, verified_pacts, event_context
         first_verified_pact = verified_pacts.first
-        logger.info "Creating verification #{next_verification_number} for pact_version_sha=#{first_verified_pact.pact_version_sha}", payload: params.reject{ |k,_| k == "testResults"}
+        logger.info("Creating verification #{next_verification_number} for pact_version_sha=#{first_verified_pact.pact_version_sha}", params.without("testResults"))
         verification = PactBroker::Domain::Verification.new
         provider_version_number = params.fetch("providerApplicationVersion")
         PactBroker::Api::Decorators::VerificationDecorator.new(verification).from_hash(params)

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.103.0"
+  VERSION = "2.105.0"
 end

data/lib/pact_broker/versions/branch.rb

@@ -8,6 +8,7 @@ module PactBroker
       plugin :insert_ignore, identifying_columns: [:name, :pacticipant_id]
 
       associate(:many_to_one, :pacticipant, :class => "PactBroker::Domain::Pacticipant", :key => :pacticipant_id, :primary_key => :id)
+      associate(:one_to_many, :branch_versions, :class => "PactBroker::Versions::BranchVersion", :key => :branch_id, :primary_key => :id)
 
       dataset_module do
         include PactBroker::Repositories::Helpers

data/lib/pact_broker/webhooks/event_listener.rb

@@ -53,10 +53,10 @@ module PactBroker
 
       def log_detected_event
         event = detected_events.last
-        logger.debug "Event detected", payload: { event_name: event.name, event_comment: event.comment }
+        logger.debug("Event detected", event_name: event.name, event_comment: event.comment)
         if event.triggered_webhooks&.any?
           triggered_webhook_descriptions = event.triggered_webhooks.collect{ |tw| { event_name: event.name, webhook_uuid: tw.webhook_uuid, triggered_webhook_uuid: tw.uuid, webhook_description: tw.webhook.description } }
-          logger.info "Triggered webhooks for #{event.name}", payload: { triggered_webhooks: triggered_webhook_descriptions }
+          logger.info("Triggered webhooks for #{event.name}", triggered_webhooks: triggered_webhook_descriptions)
         else
           logger.debug "No enabled webhooks found for event #{event.name}"
         end

data/lib/pact_broker/webhooks/execution_configuration.rb

@@ -25,6 +25,10 @@ module PactBroker
         with_updated_attribute(logging_options: { failure_log_message: value })
       end
 
+      def with_redact_sensitive_data(value)
+        with_updated_attribute(logging_options: { redact_sensitive_data: value })
+      end
+
       def with_retry_schedule(value)
         with_updated_attribute(retry_schedule: value)
       end

data/lib/pact_broker/webhooks/execution_configuration_creator.rb

@@ -10,6 +10,7 @@ module PactBroker
       def self.call(resource)
         PactBroker::Webhooks::ExecutionConfiguration.new
           .with_show_response(PactBroker.configuration.show_webhook_response?)
+          .with_redact_sensitive_data(PactBroker.configuration.webhook_redact_sensitive_data)
           .with_retry_schedule(PactBroker.configuration.webhook_retry_schedule)
           .with_http_success_codes(PactBroker.configuration.webhook_http_code_success)
           .with_user_agent(PactBroker.configuration.user_agent)

data/lib/pact_broker/webhooks/repository.rb

@@ -159,9 +159,9 @@ module PactBroker
 
       def find_latest_triggered_webhooks consumer, provider
         # policy already applied to pact
-        deliberately_unscoped(LatestTriggeredWebhook)
+        deliberately_unscoped(TriggeredWebhook)
           .where(consumer: consumer, provider: provider)
-          .order(:id)
+          .latest_triggered_webhooks
           .all
       end
 

data/lib/pact_broker/webhooks/triggered_webhook.rb

@@ -45,6 +45,13 @@ module PactBroker
         def not_run
           where(status: STATUS_NOT_RUN)
         end
+
+        # Return the dataset for the latest triggered webhooks grouped by
+        # consumer, provider, webhook and event.
+        # Excludes the deleted webhooks
+        def latest_triggered_webhooks
+          exclude(webhook_id: nil).max_group_by(:id, [:consumer_id, :provider_id, :webhook_uuid, :event_name]).order(:id)
+        end
       end
 
       associate(:one_to_many, :webhook_executions, :class => "PactBroker::Webhooks::Execution", :key => :triggered_webhook_id, :primary_key => :id, :order => :id)

data/lib/pact_broker/webhooks/webhook_request_logger.rb

@@ -51,7 +51,7 @@ module PactBroker
       end
 
       def log_request(webhook_request)
-        http_request = HttpRequestWithRedactedHeaders.new(webhook_request.http_request)
+        http_request = options[:redact_sensitive_data] ? HttpRequestWithRedactedHeaders.new(webhook_request.http_request) : webhook_request.http_request
         logger.info "Making webhook #{webhook_request.uuid} request #{http_request.method.upcase} URI=#{webhook_request.url} (headers and body in debug logs)"
         logger.debug "Webhook #{webhook_request.uuid} request headers=#{http_request.to_hash}"
         logger.debug "Webhook #{webhook_request.uuid} request body=#{http_request.body}"

data/pact_broker.gemspec

@@ -78,7 +78,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "dry-types", "~> 0.10.3" # https://travis-ci.org/pact-foundation/pact_broker/jobs/249448621
   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 "semantic_logger", "~> 4.11"
   gem.add_runtime_dependency "sanitize", "6.0"
   gem.add_runtime_dependency "wisper", "~> 2.0"
   gem.add_runtime_dependency "anyway_config", "~> 2.1"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.103.0
+  version: 2.105.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-16 00:00:00.000000000 Z
+date: 2022-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -334,14 +334,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.11'
 - !ruby/object:Gem::Dependency
   name: sanitize
   requirement: !ruby/object:Gem::Requirement
@@ -1227,7 +1227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.22
+rubygems_version: 3.3.24
 signing_key:
 specification_version: 4
 summary: See description