pact_broker 2.76.1 → 2.76.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1ab8b654502c5bbc4d263c4bd14fdb0e6dc3771173cfdf21a01118143528bd4
-  data.tar.gz: b1d929d7bfe56369c5985b94ad88f9adf3abdb27e9177b6249ba7cd68d03c85d
+  metadata.gz: cdc8ed42038e4b622005f53471a000d870efd99a6dbd6b773aa9e8a3f9a993cb
+  data.tar.gz: d2f42cd3e13007471cdd33fabbe515afa9c9ff4896566868accd9961f66f557f
 SHA512:
-  metadata.gz: ca79f6928c69425d89d0fa179094d007f26d5f25f02ee7fc2be771bb4208d2ecaef136af5391feea4c92588876e7162d205774451d00f9175463f03b9f1cdcd9
-  data.tar.gz: febb82748bb5929d393af212797a3d9c484c9825a8c83bc44e4d52aa7cb6fbce93863decb305a7d6ed3160a3b447bed6368339a38322f6084fb34de97f3698cc
+  metadata.gz: a250f5f452356d3a9eb87659933cc47d0e947b7ce10a8c984d7cd296a28bc9be7dcfe82bd37fba29919f570a949b9b4a46b1622d6d242b92698268e54018aadf
+  data.tar.gz: c136cbe836ed813de2819480cf3347de86248f00258e0f8e89ec33375cf0c929186a65c51ef620995c11d2c596d496bec858c430894f80bacd6f647877f4af3e

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+<a name="v2.76.2"></a>
+### v2.76.2 (2021-01-29)
+
+#### Bug Fixes
+
+* trigger one webhook for each pact publication that the verified content belongs to when using the 'pacts for verification' API (#378)	 ([114ccad0](/../../commit/114ccad0))
+
 <a name="v2.76.1"></a>
 ### v2.76.1 (2021-01-28)
 

data/ISSUES.md

@@ -11,13 +11,21 @@ To use it:
 * Run the Pact Broker using a specific Pact Broker Docker image by setting the required tag for the pact-broker service in the docker-compose-issue-repro-with-pact-broker-docker-image.yml file.
 
     ```
-    docker-compose -f docker-compose-issue-repro-with-pact-broker-docker-image.yml up --build pact-broker
+    # might need to try twice if it doesn't connect to postgres
+    docker-compose  -f docker-compose-issue-repro-with-pact-broker-docker-image.yml up pact-broker
+
+    # if needing webhooks - new window
+    docker-compose -f docker-compose-issue-repro-with-pact-broker-docker-image.yml up webhook-server
+
+    # new window
+    docker-compose -f docker-compose-issue-repro-with-pact-broker-docker-image.yml run repro-issue
+
     ```
 
 * Run the reproduction script.
 
     ```
-    docker-compose -f docker-compose-issue-repro-with-pact-broker-docker-image.yml up repro-issue
+    docker-compose -f docker-compose-issue-repro-with-pact-broker-docker-image.yml run repro-issue
     ```
 
 You can modify `script/reproduce-issue.rb` and then re-run it with the change applied.

data/docker-compose-issue-repro-with-pact-broker-docker-image.yml

@@ -11,23 +11,34 @@ services:
       POSTGRES_DB: postgres
 
   pact-broker:
-    image: pactfoundation/pact-broker:2.73.0.0
+    image: pactfoundation/pact-broker:2.76.0.0
     ports:
       - "9292:9292"
-    depends_on:
-      - postgres
+    # depends_on:
+    #   - postgres
     environment:
       PACT_BROKER_PORT: '9292'
-      PACT_BROKER_DATABASE_URL: "postgres://postgres:password@postgres/postgres"
+      #PACT_BROKER_DATABASE_URL: "postgres://postgres:password@postgres/postgres"
+      PACT_BROKER_DATABASE_URL: "sqlite:////tmp/pact_broker.sqlite3"
       PACT_BROKER_LOG_LEVEL: INFO
       PACT_BROKER_SQL_LOG_LEVEL: DEBUG
+      PACT_BROKER_WEBHOOK_SCHEME_WHITELIST: "http https"
+      PACT_BROKER_WEBHOOK_HOST_WHITELIST: "/.*/"
 
   repro-issue:
     build: .
     depends_on:
       - pact-broker
-    command: dockerize -wait http://pact-broker:9292 -timeout 30s /home/script/reproduce-issue.rb
+    command: -wait http://pact-broker:9292 -timeout 30s /home/script/reproduce-issue.rb
+    entrypoint: dockerize
     environment:
       - PACT_BROKER_BASE_URL=http://pact-broker:9292
     volumes:
       - $PWD:/home
+    working_dir: /home
+
+  webhook-server:
+    build: .
+    entrypoint: ["/bin/sh", "-c", "bundle exec rackup -p 9393 -o 0.0.0.0 /home/script/webhook-server.ru"]
+    volumes:
+      - ./script/webhook-server.ru:/home/script/webhook-server.ru

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

@@ -50,7 +50,7 @@ module PactBroker
         end
 
         def from_json
-          verification = verification_service.create(next_verification_number, verification_params, pact, webhook_options)
+          verification = verification_service.create(next_verification_number, verification_params, pact, event_context, webhook_options)
           response.body = decorator_for(verification).to_json(decorator_options)
           true
         end
@@ -81,11 +81,14 @@ module PactBroker
           metadata[:wip] == 'true'
         end
 
+        def event_context
+          metadata
+        end
+
         def webhook_options
           {
             database_connector: database_connector,
             webhook_execution_configuration: webhook_execution_configuration
-                                      .with_webhook_context(metadata)
           }
         end
 

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

@@ -26,7 +26,7 @@ module PactBroker
         end
 
         def process_post
-          webhook_execution_result = webhook_service.test_execution(webhook, webhook_execution_configuration)
+          webhook_execution_result = webhook_service.test_execution(webhook, webhook_execution_configuration.webhook_context, webhook_execution_configuration)
           response.headers['Content-Type'] = 'application/hal+json;charset=utf-8'
           response.body = post_response_body(webhook_execution_result)
           true

data/lib/pact_broker/domain/webhook.rb

@@ -52,15 +52,15 @@ module PactBroker
         request && request.description
       end
 
-      def execute pact, verification, options
-        logger.info "Executing #{self} webhook_context=#{options.fetch(:webhook_context)}"
-        webhook_request = request.build(template_parameters(pact, verification, options))
+      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))
         http_response, error = execute_request(webhook_request)
 
         PactBroker::Webhooks::WebhookExecutionResult.new(
           webhook_request.http_request,
           http_response,
-          generate_logs(webhook_request, http_response, error, options[:webhook_context], options.fetch(:logging_options)),
+          generate_logs(webhook_request, http_response, error, event_context, options.fetch(:logging_options)),
           error
         )
       end
@@ -106,18 +106,18 @@ module PactBroker
         return http_response, error
       end
 
-      def template_parameters(pact, verification, options)
-        PactBroker::Webhooks::PactAndVerificationParameters.new(pact, verification, options.fetch(:webhook_context)).to_hash
+      def template_parameters(pact, verification, event_context, options)
+        PactBroker::Webhooks::PactAndVerificationParameters.new(pact, verification, event_context).to_hash
       end
 
-      def generate_logs(webhook_request, http_response, error, webhook_context, logging_options)
+      def generate_logs(webhook_request, http_response, error, event_context, logging_options)
         webhook_request_logger = PactBroker::Webhooks::WebhookRequestLogger.new(logging_options)
         webhook_request_logger.log(
           uuid,
           webhook_request,
           http_response,
           error,
-          webhook_context
+          event_context
         )
       end
     end

data/lib/pact_broker/hash_refinements.rb

@@ -30,6 +30,10 @@ module PactBroker
         keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
       end
 
+      def without(*keys)
+        reject { |k,_| keys.include?(k) }
+      end
+
       def camelcase_keys
         camelcase_keys_private(self)
       end

data/lib/pact_broker/pacts/service.rb

@@ -152,7 +152,8 @@ module PactBroker
         update_params = { pact_version_sha: pact_version_sha, json_content: json_content }
         updated_pact = pact_repository.update(existing_pact.id, update_params)
 
-        webhook_trigger_service.trigger_webhooks_for_updated_pact(existing_pact, updated_pact, merge_consumer_version_info(webhook_options, updated_pact))
+        event_context = { consumer_version_tags: updated_pact.consumer_version_tag_names }
+        webhook_trigger_service.trigger_webhooks_for_updated_pact(existing_pact, updated_pact, event_context, merge_consumer_version_info(webhook_options, updated_pact))
 
         updated_pact
       end
@@ -170,7 +171,8 @@ module PactBroker
           pact_version_sha: pact_version_sha,
           json_content: json_content
         )
-        webhook_trigger_service.trigger_webhooks_for_new_pact(pact, merge_consumer_version_info(webhook_options, pact))
+        event_context = { consumer_version_tags: pact.consumer_version_tag_names }
+        webhook_trigger_service.trigger_webhooks_for_new_pact(pact, event_context, merge_consumer_version_info(webhook_options, pact))
         pact
       end
 

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -24,8 +24,8 @@ module PactBroker
         end
       end
 
-      def sleep
-        Kernel.sleep 0.5
+      def sleep(seconds = 0.5)
+        Kernel.sleep(seconds)
         self
       end
 
@@ -111,28 +111,22 @@ module PactBroker
         self
       end
 
+      def verify_latest_pact_for_tag(success: true, provider: last_provider_name, consumer: last_consumer_name, consumer_version_tag: , provider_version:, provider_version_tag: nil)
+        @last_provider_name = provider
+        @last_consumer_name = consumer
+        url_of_pact_to_verify = "pacts/provider/#{encode(provider)}/consumer/#{encode(consumer)}/latest/#{encode(consumer_version_tag)}"
+        publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
+        separate
+        self
+      end
+
       def verify_pact(index: 0, success:, provider: last_provider_name, provider_version_tag: , provider_version: )
         @last_provider_name = provider
         pact_to_verify = @pacts_for_verification_response.body["_embedded"]["pacts"][index]
         raise "No pact found to verify at index #{index}" unless pact_to_verify
         url_of_pact_to_verify = pact_to_verify["_links"]["self"]["href"]
 
-        [*provider_version_tag].each do | tag |
-          create_tag(pacticipant: provider, version: provider_version, tag: tag)
-        end
-        puts "" if [*provider_version_tag].any?
-
-        pact_response = client.get(url_of_pact_to_verify).tap { |response| check_for_error(response) }
-        verification_results_url = pact_response.body["_links"]["pb:publish-verification-results"]["href"]
-
-        results = {
-          success: success,
-          testResults: [],
-          providerApplicationVersion: provider_version
-        }
-        puts "Publishing verification"
-        puts results.to_yaml
-        response = client.post(verification_results_url, results.to_json).tap { |response| check_for_error(response) }
+        publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
         separate
         self
       end
@@ -156,6 +150,36 @@ module PactBroker
         self
       end
 
+      def create_global_webhook_for_verification_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}",
+              "githubVerificationStatus" => "${pactbroker.githubVerificationStatus}",
+              "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
+              "providerVersionTags" => "${pactbroker.providerVersionTags}"
+            }
+          }
+        }
+        path = "webhooks/#{uuid}"
+        response = client.put(path, request_body.to_json).tap { |response| check_for_error(response) }
+        separate
+        self
+      end
+
       def delete_webhook(uuid:)
         puts "Deleting webhook with uuid #{uuid}"
         path = "webhooks/#{uuid}"
@@ -220,6 +244,27 @@ module PactBroker
         }
       end
 
+      private
+
+      def publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, success)
+        [*provider_version_tag].each do | tag |
+          create_tag(pacticipant: provider, version: provider_version, tag: tag)
+        end
+        puts "" if [*provider_version_tag].any?
+
+        pact_response = client.get(url_of_pact_to_verify).tap { |response| check_for_error(response) }
+        verification_results_url = pact_response.body["_links"]["pb:publish-verification-results"]["href"]
+
+        results = {
+          success: success,
+          testResults: [],
+          providerApplicationVersion: provider_version
+        }
+        puts "Publishing verification"
+        puts results.to_yaml
+        response = client.post(verification_results_url, results.to_json).tap { |response| check_for_error(response) }
+      end
+
       def encode string
         ERB::Util.url_encode(string)
       end

data/lib/pact_broker/verifications/service.rb

@@ -20,7 +20,7 @@ module PactBroker
         verification_repository.next_number
       end
 
-      def create next_verification_number, params, pact, webhook_options
+      def create next_verification_number, params, pact, event_context, webhook_options
         logger.info "Creating verification #{next_verification_number} for pact_id=#{pact.id}", payload: params.reject{ |k,_| k == "testResults"}
         verification = PactBroker::Domain::Verification.new
         provider_version_number = params.fetch('providerApplicationVersion')
@@ -35,6 +35,7 @@ module PactBroker
         webhook_trigger_service.trigger_webhooks_for_verification_results_publication(
           pact,
           verification,
+          event_context.merge(provider_version_tags: verification.provider_version_tag_names),
           webhook_options.deep_merge(webhook_execution_configuration: execution_configuration)
         )
         verification

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.76.1'
+  VERSION = '2.76.2'
 end

data/lib/pact_broker/webhooks/pact_and_verification_parameters.rb

@@ -13,6 +13,7 @@ module PactBroker
       BITBUCKET_VERIFICATION_STATUS = 'pactbroker.bitbucketVerificationStatus'
       CONSUMER_LABELS = 'pactbroker.consumerLabels'
       PROVIDER_LABELS = 'pactbroker.providerLabels'
+      EVENT_NAME = 'pactbroker.eventName'
 
       ALL = [
         CONSUMER_NAME,
@@ -26,7 +27,8 @@ module PactBroker
         GITHUB_VERIFICATION_STATUS,
         BITBUCKET_VERIFICATION_STATUS,
         CONSUMER_LABELS,
-        PROVIDER_LABELS
+        PROVIDER_LABELS,
+        EVENT_NAME
       ]
 
       def initialize(pact, trigger_verification, webhook_context)
@@ -49,7 +51,8 @@ module PactBroker
           GITHUB_VERIFICATION_STATUS => github_verification_status,
           BITBUCKET_VERIFICATION_STATUS => bitbucket_verification_status,
           CONSUMER_LABELS => pacticipant_labels(pact && pact.consumer),
-          PROVIDER_LABELS => pacticipant_labels(pact && pact.provider)
+          PROVIDER_LABELS => pacticipant_labels(pact && pact.provider),
+          EVENT_NAME => event_name
         }
       end
 
@@ -116,6 +119,10 @@ module PactBroker
       def pacticipant_labels pacticipant
         pacticipant && pacticipant.labels ? pacticipant.labels.collect(&:name).join(", ") : ""
       end
+
+      def event_name
+        webhook_context.fetch(:event_name)
+      end
     end
   end
-end
+end

data/lib/pact_broker/webhooks/service.rb

@@ -87,7 +87,7 @@ module PactBroker
         webhook_repository.find_all
       end
 
-      def self.test_execution webhook, execution_configuration
+      def self.test_execution webhook, event_context, execution_configuration
         merged_options = execution_configuration.with_failure_log_message("Webhook execution failed").to_hash
 
         verification = nil
@@ -96,7 +96,7 @@ module PactBroker
         end
 
         pact = pact_service.search_for_latest_pact(consumer_name: webhook.consumer_name, provider_name: webhook.provider_name) || PactBroker::Pacts::PlaceholderPact.new
-        webhook.execute(pact, verification, merged_options)
+        webhook.execute(pact, verification, event_context.merge(event_name: "test"), merged_options)
       end
 
       def self.execute_triggered_webhook_now triggered_webhook, webhook_execution_configuration_hash
@@ -121,23 +121,24 @@ module PactBroker
         webhook_repository.find_by_consumer_and_provider consumer, provider
       end
 
-      def self.trigger_webhooks pact, verification, event_name, options
+      def self.trigger_webhooks pact, verification, event_name, event_context, options
         webhooks = webhook_repository.find_by_consumer_and_or_provider_and_event_name pact.consumer, pact.provider, event_name
 
         if webhooks.any?
           webhook_execution_configuration = options.fetch(:webhook_execution_configuration).with_webhook_context(event_name: event_name)
-          run_later(webhooks, pact, verification, event_name, options.merge(webhook_execution_configuration: webhook_execution_configuration))
+          # bit messy to merge in base_url here, but easier than a big refactor
+          base_url = options.fetch(:webhook_execution_configuration).webhook_context.fetch(:base_url)
+          run_later(webhooks, pact, verification, event_name, event_context.merge(event_name: event_name, base_url: base_url), options.merge(webhook_execution_configuration: webhook_execution_configuration))
         else
           logger.info "No enabled webhooks found for consumer \"#{pact.consumer.name}\" and provider \"#{pact.provider.name}\" and event #{event_name}"
         end
       end
 
-      def self.run_later webhooks, pact, verification, event_name, options
+      def self.run_later webhooks, pact, verification, event_name, event_context, options
         trigger_uuid = next_uuid
         webhooks.each do | webhook |
           begin
-            webhook_context = options.fetch(:webhook_execution_configuration).webhook_context
-            triggered_webhook = webhook_repository.create_triggered_webhook(trigger_uuid, webhook, pact, verification, RESOURCE_CREATION, event_name, webhook_context)
+            triggered_webhook = webhook_repository.create_triggered_webhook(trigger_uuid, webhook, pact, verification, RESOURCE_CREATION, event_name, event_context)
             logger.info "Scheduling job for webhook with uuid #{webhook.uuid}"
             logger.debug "Schedule webhook with options #{options}"
             job_data = { triggered_webhook: triggered_webhook }.deep_merge(options)

data/lib/pact_broker/webhooks/trigger_service.rb

@@ -1,4 +1,5 @@
 require 'pact_broker/services'
+require 'pact_broker/hash_refinements'
 
 module PactBroker
   module Webhooks
@@ -8,50 +9,56 @@ module PactBroker
       extend PactBroker::Repositories
       extend PactBroker::Services
       include PactBroker::Logging
+      using PactBroker::HashRefinements
 
-      def trigger_webhooks_for_new_pact(pact, webhook_options)
-        webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, webhook_options
+      def trigger_webhooks_for_new_pact(pact, event_context, webhook_options)
+        webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options
         if pact_is_new_or_newly_tagged_or_pact_has_changed_since_previous_version?(pact)
-          webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, webhook_options
+          webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options
         else
           logger.info "Pact content has not changed since previous version, not triggering webhooks for changed content"
         end
       end
 
-      def trigger_webhooks_for_updated_pact(existing_pact, updated_pact, webhook_options)
-        webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, webhook_options
+      def trigger_webhooks_for_updated_pact(existing_pact, updated_pact, event_context, webhook_options)
+        webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options
         # TODO this should use the sha!
         if existing_pact.pact_version_sha != updated_pact.pact_version_sha
           logger.info "Existing pact for version #{existing_pact.consumer_version_number} has been updated with new content, triggering webhooks for changed content"
-          webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, webhook_options
+          webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options
         else
           logger.info "Pact content has not changed since previous revision, not triggering webhooks for changed content"
         end
       end
 
-      def trigger_webhooks_for_verification_results_publication(pact, verification, webhook_options)
-        if verification.success
-          webhook_service.trigger_webhooks(
-            pact,
-            verification,
-            PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED,
-            webhook_options
-          )
-        else
+      def trigger_webhooks_for_verification_results_publication(pact, verification, event_context, webhook_options)
+        expand_events(event_context).each do | reconstituted_event_context |
+          if verification.success
+            webhook_service.trigger_webhooks(
+              pact,
+              verification,
+              PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED,
+              reconstituted_event_context,
+              webhook_options
+            )
+          else
+            webhook_service.trigger_webhooks(
+              pact,
+              verification,
+              PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED,
+              reconstituted_event_context,
+              webhook_options
+            )
+          end
+
           webhook_service.trigger_webhooks(
             pact,
             verification,
-            PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED,
+            PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED,
+            reconstituted_event_context,
             webhook_options
           )
         end
-
-        webhook_service.trigger_webhooks(
-          pact,
-          verification,
-          PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED,
-          webhook_options
-        )
       end
 
       private
@@ -68,6 +75,32 @@ module PactBroker
         previous_pact.nil? || new_pact.pact_version_sha != previous_pact.pact_version_sha
       end
 
+      def merge_consumer_version_selectors(consumer_version_number, selectors, event_context)
+        event_context.merge(
+          consumer_version_number: consumer_version_number,
+          consumer_version_tags: selectors.collect{ | selector | selector[:tag] }.compact.uniq
+        )
+      end
+
+      # Now that we de-duplicate the pact contents when verifying though the 'pacts for verification' API,
+      # we no longer get a webhook triggered for the verification results publication of each indiviual
+      # consumer version tag, meaning that only the most recent commit will get the updated verification status.
+      # To fix this, each URL of the pacts returned by the 'pacts for verification' API now contains the
+      # relevant selectors in the metadata, so that when the verification results are published,
+      # we can parse that metadata, and trigger one webhook for each consumer version like we used to.
+      # Actually, we used to trigger one webhook per tag, but given that the most likely use of the
+      # verification published webhook is for reporting git statuses,
+      # it makes more sense to trigger per consumer version number (ie. commit).
+      def expand_events(event_context)
+        triggers = if event_context[:consumer_version_selectors].is_a?(Array)
+          event_context[:consumer_version_selectors]
+            .group_by{ | selector | selector[:consumer_version_number] }
+            .collect { | consumer_version_number, selectors | merge_consumer_version_selectors(consumer_version_number, selectors, event_context.without(:consumer_version_selectors)) }
+        else
+          [event_context]
+        end
+      end
+
       def print_debug_messages(changed_pacts)
         if changed_pacts.any?
           messages = changed_pacts.collect do |tag, previous_pact|

data/lib/pact_broker/webhooks/triggered_webhook.rb

@@ -1,6 +1,7 @@
 require 'sequel'
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/webhooks/execution'
+require 'pact_broker/hash_refinements'
 
 # Represents the relationship between a webhook and the event and object
 # that caused it to be triggered. eg a pact publication
@@ -8,6 +9,7 @@ require 'pact_broker/webhooks/execution'
 module PactBroker
   module Webhooks
     class TriggeredWebhook < Sequel::Model(:triggered_webhooks)
+      using PactBroker::HashRefinements
       plugin :timestamps, update_on_create: true
       plugin :serialization, :json, :event_context
 
@@ -60,7 +62,7 @@ module PactBroker
         # getting a random 'no method to_domain for null' error
         # not sure on which object, so splitting this out into two lines
         pact = pact_publication.to_domain
-        webhook.to_domain.execute(pact, verification, options)
+        webhook.to_domain.execute(pact, verification, event_context.symbolize_keys, options)
       end
 
       def consumer_name

data/script/reproduce-issue-starting-up.rb

@@ -1,43 +1,33 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH << "#{Dir.pwd}/lib"
-
 begin
 
+  $LOAD_PATH << "#{Dir.pwd}/lib"
   require 'pact_broker/test/http_test_data_builder'
   base_url = ENV['PACT_BROKER_BASE_URL'] || 'http://localhost:9292'
 
-  td = PactBroker::Test::HttpTestDataBuilder.new(base_url, { })
-  td.delete_integration(consumer: "MyConsumer", provider: "MyProvider")
-    .can_i_deploy(pacticipant: "MyProvider", version: "1", to: "prod")
-    .can_i_deploy(pacticipant: "MyConsumer", version: "1", to: "prod")
-    .publish_pact(consumer: "MyConsumer", consumer_version: "1", provider: "MyProvider", content_id: "111", tag: "feature/a")
-    .can_i_deploy(pacticipant: "MyProvider", version: "1", to: "prod")
+  td = PactBroker::Test::HttpTestDataBuilder.new(base_url)
+  td.delete_integration(consumer: "Foo", provider: "Bar")
+    .delete_integration(consumer: "foo-consumer", provider: "bar-provider")
+    .create_pacticipant("foo-consumer")
+    .create_pacticipant("foo-provider")
+    .create_global_webhook_for_verification_published(uuid: "ba8feb17-558a-4b3f-a078-f52c6fafd014", url: "http://webhook-server:9393")
+    .publish_pact(consumer: "foo-consumer", consumer_version: "1", provider: "bar-provider", content_id: "111", tag: "main")
+    .publish_pact(consumer: "foo-consumer", consumer_version: "2", provider: "bar-provider", content_id: "111", tag: ["feat/x", "feat/y"])
+    .sleep(10)
     .get_pacts_for_verification(
-      enable_pending: true,
       provider_version_tag: "main",
-      include_wip_pacts_since: "2020-01-01",
-      consumer_version_selectors: [{ tag: "main", latest: true }])
+      consumer_version_selectors: [{ tag: "main", latest: true }, { tag: "feat/x", latest: true }, { tag: "feat/y", latest: true }])
     .verify_pact(
       index: 0,
       provider_version_tag: "main",
       provider_version: "1",
-      success: false
+      success: true
     )
-    .get_pacts_for_verification(
-      enable_pending: true,
-      provider_version_tag: "main",
-      include_wip_pacts_since: "2020-01-01",
-      consumer_version_selectors: [{ tag: "main", latest: true }])
-    .can_i_deploy(pacticipant: "MyProvider", version: "1", to: "prod")
-    .can_i_deploy(pacticipant: "MyConsumer", version: "1", to: "prod")
-    .deploy_to_prod(pacticipant: "MyProvider", version: "1")
-    .can_i_deploy(pacticipant: "MyConsumer", version: "1", to: "prod")
-    .deploy_to_prod(pacticipant: "MyConsumer", version: "1")
+
 
 rescue StandardError => e
   puts "#{e.class} #{e.message}"
   puts e.backtrace
   exit 1
 end
-

data/script/reproduce-issue.rb

@@ -6,7 +6,8 @@ begin
   base_url = ENV['PACT_BROKER_BASE_URL'] || 'http://localhost:9292'
 
   td = PactBroker::Test::HttpTestDataBuilder.new(base_url)
-  td.delete_integration(consumer: "foo-consumer", provider: "bar-provider")
+  td.delete_integration(consumer: "Foo", provider: "Bar")
+    .delete_integration(consumer: "foo-consumer", provider: "bar-provider")
     .publish_pact(consumer: "foo-consumer", consumer_version: "1", provider: "bar-provider", content_id: "111", tag: "main")
     .get_pacts_for_verification(
       enable_pending: true,

data/script/trigger-release.sh

@@ -19,7 +19,7 @@ output=$(curl -v https://api.github.com/repos/${repository_slug}/dispatches \
       -H "Authorization: Bearer $GITHUB_ACCESS_TOKEN_FOR_PF_RELEASES" \
       -d "{\"event_type\": \"release-triggered\", \"client_payload\": {\"increment\": ${increment}}}" 2>&1)
 
-if  ! echo "${output}" | grep "HTTP\/1.1 204" > /dev/null; then
+if  ! echo "${output}" | grep "HTTP\/.* 204" > /dev/null; then
   echo "$output" | sed  "s/${GITHUB_ACCESS_TOKEN_FOR_PF_RELEASES}/********/g"
   echo "Failed to trigger release"
   exit 1

data/script/webhook-server.ru

@@ -1,10 +1,10 @@
 require 'rack/utils'
+STDOUT.sync = true
+puts "Starting webhook server"
 
-count = 0
 run -> (env) {
-  count += 1
-  status = (count % 3 == 0) ? 200 : 500
-  puts Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+  status = 200
+  puts Rack::Utils.parse_nested_query(env['QUERY_STRING']) if env['QUERY_STRING'] && env['QUERY_STRING'] != ''
   puts env['rack.input'].read
-  [status, {}, ["Hello. This might be an error.\n"]]
+  [status, {"Content-Type" => "text/plain"}, ["Webhook response.\n"]]
 }

data/spec/lib/pact_broker/api/resources/verifications_spec.rb

@@ -81,16 +81,12 @@ module PactBroker
               expect(subject.headers['Location']).to eq("http://example.org/pacts/provider/Provider/consumer/Consumer/pact-version/1234/verification-results/2")
             end
 
-            it "merges the upstream verification metdata into the webhook context" do
-              expect(webhook_execution_configuration).to receive(:with_webhook_context).with(parsed_metadata)
-              subject
-            end
-
             it "stores the verification in the database" do
               expect(PactBroker::Verifications::Service).to receive(:create).with(
                 next_verification_number,
                 hash_including('some' => 'params', 'wip' => false),
                 pact,
+                parsed_metadata,
                 {
                   webhook_execution_configuration: webhook_execution_configuration,
                   database_connector: database_connector
@@ -117,6 +113,7 @@ module PactBroker
                   anything,
                   hash_including('wip' => true),
                   anything,
+                  anything,
                   anything
                 )
                 subject

data/spec/lib/pact_broker/api/resources/webhook_execution_spec.rb

@@ -30,7 +30,8 @@ module PactBroker
             let(:pact) { instance_double("PactBroker::Domain::Pact") }
             let(:consumer_name) { "foo" }
             let(:provider_name) { "bar" }
-            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
+            let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, webhook_context: event_context) }
+            let(:event_context) { { some: "data" } }
 
             before do
               allow(PactBroker::Webhooks::Service).to receive(:test_execution).and_return(execution_result)
@@ -39,7 +40,7 @@ module PactBroker
             end
 
             it "executes the webhook" do
-              expect(PactBroker::Webhooks::Service).to receive(:test_execution).with(webhook, webhook_execution_configuration)
+              expect(PactBroker::Webhooks::Service).to receive(:test_execution).with(webhook, event_context, webhook_execution_configuration)
               subject
             end
 

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -12,9 +12,9 @@ module PactBroker
       let(:webhook_template_parameters_hash) { { 'foo' => 'bar' } }
       let(:http_request) { double('http request') }
       let(:http_response) { double('http response') }
-      let(:webhook_context) { { some: 'things' } }
+      let(:event_context) { { some: 'things' } }
       let(:logging_options) { { other: 'options' } }
-      let(:options) { { webhook_context: webhook_context, logging_options: logging_options } }
+      let(:options) { { logging_options: logging_options } }
       let(:pact) { double('pact') }
       let(:verification) { double('verification') }
       let(:logger) { double('logger').as_null_object }
@@ -61,11 +61,11 @@ module PactBroker
 
         let(:webhook_request_logger) { instance_double(PactBroker::Webhooks::WebhookRequestLogger, log: "logs") }
 
-        let(:execute) { subject.execute pact, verification, options }
+        let(:execute) { subject.execute(pact, verification, event_context, options) }
 
         it "creates the template parameters" do
           expect(PactBroker::Webhooks::PactAndVerificationParameters).to receive(:new).with(
-            pact, verification, webhook_context
+            pact, verification, event_context
           )
           execute
         end
@@ -81,7 +81,7 @@ module PactBroker
         end
 
         it "generates the execution logs" do
-          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, webhook_context)
+          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil, event_context)
           execute
         end
 
@@ -106,7 +106,7 @@ module PactBroker
           end
 
           it "generates the execution logs" do
-            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), webhook_context)
+            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class), event_context)
             execute
           end
 

data/spec/lib/pact_broker/pacts/service_spec.rb

@@ -33,7 +33,7 @@ module PactBroker
         let(:provider) { double('provider', id: 2) }
         let(:version) { double('version', id: 3, pacticipant_id: 1) }
         let(:existing_pact) { nil }
-        let(:new_pact) { double('new_pact', consumer_version_tag_names: %[dev], json_content: json_content) }
+        let(:new_pact) { double('new_pact', consumer_version_tag_names: %w[dev], json_content: json_content) }
         let(:json_content) { { the: "contract" }.to_json }
         let(:json_content_with_ids) { { the: "contract with ids" }.to_json }
         let(:previous_pacts) { [] }
@@ -49,7 +49,7 @@ module PactBroker
         let(:content_with_interaction_ids) { double('content_with_interaction_ids', to_json: json_content_with_ids) }
         let(:webhook_options) { { webhook_execution_configuration: webhook_execution_configuration } }
         let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
-
+        let(:expected_event_context) { { consumer_version_tags: ["dev"] } }
 
         before do
           allow(Content).to receive(:from_json).and_return(content)
@@ -73,12 +73,12 @@ module PactBroker
           end
 
           it "sets the consumer version tags" do
-            expect(webhook_execution_configuration).to receive(:with_webhook_context).with(consumer_version_tags: %[dev]).and_return(webhook_execution_configuration)
+            expect(webhook_execution_configuration).to receive(:with_webhook_context).with(consumer_version_tags: %w[dev]).and_return(webhook_execution_configuration)
             subject
           end
 
           it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact).with(new_pact, webhook_options)
+            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_new_pact).with(new_pact, expected_event_context, webhook_options)
             subject
           end
         end
@@ -92,6 +92,8 @@ module PactBroker
             )
           end
 
+          let(:expected_event_context) { { consumer_version_tags: ["dev"] } }
+
           it "creates the sha before adding the interaction ids" do
             expect(PactBroker::Pacts::GenerateSha).to receive(:call).ordered
             expect(content).to receive(:with_ids).ordered
@@ -104,7 +106,7 @@ module PactBroker
           end
 
           it "triggers webhooks" do
-            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact).with(existing_pact, new_pact, webhook_options)
+            expect(webhook_trigger_service).to receive(:trigger_webhooks_for_updated_pact).with(existing_pact, new_pact, expected_event_context, webhook_options)
             subject
           end
         end

data/spec/lib/pact_broker/verifications/service_spec.rb

@@ -22,6 +22,8 @@ module PactBroker
         end
 
         let(:options) { { webhook_execution_configuration: webhook_execution_configuration } }
+        let(:event_context) { { some: "data" } }
+        let(:expected_event_context) { { some: "data", provider_version_tags: ["dev"] } }
         let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
         let(:params) { { 'success' => true, 'providerApplicationVersion' => '4.5.6', 'wip' => true, 'testResults' => { 'some' => 'results' }} }
         let(:pact) do
@@ -30,7 +32,7 @@ module PactBroker
             .create_provider_version_tag('dev')
             .and_return(:pact)
         end
-        let(:create_verification) { subject.create 3, params, pact, options }
+        let(:create_verification) { subject.create 3, params, pact, event_context, options }
 
         it "logs the creation" do
           expect(logger).to receive(:info).with(/.*verification.*3/, payload: {"providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true})
@@ -67,6 +69,7 @@ module PactBroker
           expect(PactBroker::Webhooks::TriggerService).to have_received(:trigger_webhooks_for_verification_results_publication).with(
             pact,
             verification,
+            expected_event_context,
             options
           )
         end

data/spec/lib/pact_broker/webhooks/render_spec.rb

@@ -94,7 +94,7 @@ module PactBroker
           [ double("label", name: "foo"), double("label", name: "bar") ]
         end
 
-        let(:webhook_context) { { base_url: base_url } }
+        let(:webhook_context) { { base_url: base_url, event_name: "something" } }
 
         let(:nil_pact) { nil }
         let(:nil_verification) { nil }
@@ -158,7 +158,8 @@ module PactBroker
             {
               consumer_version_number: "webhook-version-number",
               consumer_version_tags: %w[webhook tags],
-              base_url: base_url
+              base_url: base_url,
+              event_name: "something"
 
             }
           end
@@ -186,16 +187,16 @@ module PactBroker
         let(:base_url) { "http://broker" }
 
         let(:template_parameters) do
-          PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+          PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url, event_name: "something" }).to_hash
         end
 
         it "does not blow up with a placeholder pact" do
-          template_parameters = PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url, event_name: "something" }).to_hash
           Render.call("", template_parameters)
         end
 
         it "does not blow up with a placeholder verification" do
-          template_parameters = PactAndVerificationParameters.new(placeholder_pact, placeholder_verification, { base_url: base_url }).to_hash
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, placeholder_verification, { base_url: base_url, event_name: "something" }).to_hash
           Render.call("", template_parameters)
         end
       end

data/spec/lib/pact_broker/webhooks/service_spec.rb

@@ -181,7 +181,9 @@ module PactBroker
         let(:webhooks) { [instance_double(PactBroker::Domain::Webhook, description: 'description', uuid: '1244')]}
         let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
         let(:webhook_execution_configuration) { double('webhook_execution_configuration', webhook_context: webhook_context) }
-        let(:webhook_context) { double('webhook_context') }
+        let(:webhook_context) { { base_url: "http://example.org" } }
+        let(:event_context) { { some: "data" } }
+        let(:expected_event_context) { { some: "data", event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, base_url: "http://example.org" } }
         let(:options) do
           { database_connector: double('database_connector'),
             webhook_execution_configuration: webhook_execution_configuration,
@@ -196,7 +198,7 @@ module PactBroker
           allow(Job).to receive(:perform_in)
         end
 
-        subject { Service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options }
+        subject { Service.trigger_webhooks(pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, options) }
 
         it "finds the webhooks" do
           expect_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_or_provider_and_event_name).with(consumer, provider, PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME)
@@ -205,7 +207,7 @@ module PactBroker
 
         context "when webhooks are found" do
           it "executes the webhook" do
-            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options)
+            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, expected_event_context, options)
             subject
           end
 
@@ -258,6 +260,7 @@ module PactBroker
           instance_double(PactBroker::Webhooks::ExecutionConfiguration, to_hash: execution_configuration_hash)
         end
         let(:execution_configuration_hash) { { the: 'options' } }
+        let(:event_context) { { some: "data" } }
 
         before do
           allow(PactBroker::Pacts::Service).to receive(:search_for_latest_pact).and_return(pact)
@@ -266,7 +269,7 @@ module PactBroker
           allow(execution_configuration).to receive(:with_failure_log_message).and_return(execution_configuration)
         end
 
-        subject { Service.test_execution(webhook, execution_configuration) }
+        subject { Service.test_execution(webhook, event_context, execution_configuration) }
 
         it "searches for the latest matching pact" do
           expect(PactBroker::Pacts::Service).to receive(:search_for_latest_pact).with(consumer_name: 'consumer', provider_name: 'provider')
@@ -279,7 +282,7 @@ module PactBroker
 
         context "when the trigger is not for a verification" do
           it "executes the webhook with the pact" do
-            expect(webhook).to receive(:execute).with(pact, nil, execution_configuration_hash)
+            expect(webhook).to receive(:execute).with(pact, nil, event_context.merge(event_name: "test"), execution_configuration_hash)
             subject
           end
         end
@@ -288,7 +291,7 @@ module PactBroker
           let(:pact) { nil }
 
           it "executes the webhook with a placeholder pact" do
-            expect(webhook).to receive(:execute).with(an_instance_of(PactBroker::Pacts::PlaceholderPact), anything, anything)
+            expect(webhook).to receive(:execute).with(an_instance_of(PactBroker::Pacts::PlaceholderPact), anything, anything, anything)
             subject
           end
         end
@@ -302,7 +305,7 @@ module PactBroker
           end
 
           it "executes the webhook with the pact and the verification" do
-            expect(webhook).to receive(:execute).with(pact, verification, execution_configuration_hash)
+            expect(webhook).to receive(:execute).with(pact, verification, event_context.merge(event_name: "test"), execution_configuration_hash)
             subject
           end
 
@@ -310,7 +313,7 @@ module PactBroker
             let(:verification) { nil }
 
             it "executes the webhook with a placeholder verification" do
-              expect(webhook).to receive(:execute).with(anything, an_instance_of(PactBroker::Verifications::PlaceholderVerification), anything)
+              expect(webhook).to receive(:execute).with(anything, an_instance_of(PactBroker::Verifications::PlaceholderVerification), anything, anything)
               subject
             end
           end
@@ -329,6 +332,7 @@ module PactBroker
             .with_webhook_context(base_url: 'http://example.org')
             .with_show_response(true)
         end
+        let(:event_context) { { some: "data", base_url: "http://example.org" }}
         let(:options) do
           {
             database_connector: database_connector,
@@ -347,7 +351,7 @@ module PactBroker
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.trigger_webhooks pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options }
+        subject { PactBroker::Webhooks::Service.trigger_webhooks(pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, options) }
 
         it "executes the HTTP request of the webhook" do
           subject

data/spec/lib/pact_broker/webhooks/trigger_service_spec.rb

@@ -11,6 +11,7 @@ module PactBroker
       let(:previous_pact_version_sha) { "111" }
       let(:previous_pacts) { { untagged: previous_pact } }
       let(:logger) { double('logger').as_null_object }
+      let(:event_context) { { some: "data" } }
       let(:webhook_options) { { the: 'options'} }
 
       before do
@@ -21,27 +22,27 @@ module PactBroker
 
       shared_examples_for "triggering a contract_published event" do
         it "triggers a contract_published webhook" do
-          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, webhook_options)
+          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options)
           subject
         end
       end
 
       shared_examples_for "triggering a contract_content_changed event" do
         it "triggers a contract_content_changed webhook" do
-          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, webhook_options)
+          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options)
           subject
         end
       end
 
       shared_examples_for "not triggering a contract_content_changed event" do
         it "does not trigger a contract_content_changed webhook" do
-          expect(webhook_service).to_not receive(:trigger_webhooks).with(anything, anything, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, anything)
+          expect(webhook_service).to_not receive(:trigger_webhooks).with(anything, anything, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, anything)
           subject
         end
       end
 
       describe "#trigger_webhooks_for_new_pact" do
-        subject { TriggerService.trigger_webhooks_for_new_pact(pact, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_new_pact(pact, event_context, webhook_options) }
 
         context "when no previous untagged pact exists" do
           let(:previous_pact) { nil }
@@ -117,7 +118,7 @@ module PactBroker
         end
         let(:existing_pact_version_sha) { pact_version_sha }
 
-        subject { TriggerService.trigger_webhooks_for_updated_pact(existing_pact, pact, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_updated_pact(existing_pact, pact, event_context, webhook_options) }
 
         context "when the pact version sha of the previous revision is different" do
           let(:existing_pact_version_sha) { "456" }
@@ -140,32 +141,73 @@ module PactBroker
       describe "#trigger_webhooks_for_verification_results_publication" do
         let(:verification) { double("verification", success: success) }
         let(:success) { true }
+        # See lib/pact_broker/pacts/metadata.rb build_metadata_for_pact_for_verification
+        let(:selector_1) { { latest: true, consumer_version_number: "1", tag: "prod" } }
+        let(:selector_2) { { latest: true, consumer_version_number: "1", tag: "main" } }
+        let(:selector_3) { { latest: true, consumer_version_number: "2", tag: "feat/2" } }
+        let(:event_context) do
+          {
+            consumer_version_selectors: [selector_1, selector_2, selector_3],
+            other: "foo"
+          }
+        end
+        let(:expected_event_context_1) { { consumer_version_number: "1", consumer_version_tags: ["prod", "main"], other: "foo" } }
+        let(:expected_event_context_2) { { consumer_version_number: "2", consumer_version_tags: ["feat/2"], other: "foo" } }
 
-        subject { TriggerService.trigger_webhooks_for_verification_results_publication(pact, verification, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_verification_results_publication(pact, verification, event_context, webhook_options) }
 
         context "when the verification is successful" do
-          it "triggers a provider_verification_succeeded webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, webhook_options)
-            subject
+
+          context "when there are consumer_version_selectors in the event_context" do
+            it "triggers a provider_verification_succeeded webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, expected_event_context_2, webhook_options)
+              subject
+            end
+
+            it "triggers a provider_verification_published webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_2, webhook_options)
+              subject
+            end
           end
 
-          it "triggers a provider_verification_published webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, webhook_options)
-            subject
+          context "when there are no consumer_version_selectors" do
+            let(:event_context) { { some: "data" } }
+
+            it "passes through the event context" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, event_context, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, event_context, webhook_options)
+              subject
+            end
           end
         end
 
         context "when the verification is not successful" do
           let(:success) { false }
 
-          it "triggers a provider_verification_failed webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, webhook_options)
-            subject
+          context "when there are consumer_version_selectors in the event_context" do
+            it "triggers a provider_verification_failed webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, expected_event_context_2, webhook_options)
+              subject
+            end
+
+            it "triggeres a provider_verification_published webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_2, webhook_options)
+              subject
+            end
           end
 
-          it "triggeres a provider_verification_published webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, webhook_options)
-            subject
+          context "when there are no consumer_version_selectors" do
+            let(:event_context) { { some: "data" } }
+
+            it "passes through the event context" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, event_context, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, event_context, webhook_options)
+              subject
+            end
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.76.1
+  version: 2.76.2
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-27 00:00:00.000000000 Z
+date: 2021-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -566,7 +566,6 @@ files:
 - docker-compose-ci-mysql.yml
 - docker-compose-dev-postgres.yml
 - docker-compose-issue-repro-with-pact-broker-docker-image.yml
-- docker-compose-issue-repro.yml
 - docker-compose-test.yml
 - docs/images/Pactflow logo - black small.png
 - example/Gemfile

data/docker-compose-issue-repro.yml

@@ -1,22 +0,0 @@
-version: "3"
-
-services:
-  pact-broker:
-    build: .
-    ports:
-      - "9292:9292"
-    entrypoint: /usr/local/bin/start
-    environment:
-      - RACK_ENV=production
-    volumes:
-      - $PWD:/home
-
-  repro-issue:
-    build: .
-    depends_on:
-      - pact-broker
-    command: dockerize -wait http://pact-broker:9292 -timeout 30s /home/script/reproduce-issue.rb
-    environment:
-      - PACT_BROKER_BASE_URL=http://pact-broker:9292
-    volumes:
-      - $PWD:/home