pact_broker 2.20.0 → 2.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e14b4974d382ad35da338f8b493f4ea721105a7c
-  data.tar.gz: 3d27068e75bea109b5bc3bac0262061ce973f574
+  metadata.gz: 4e08f85dd95e1f881127b7592ac697e7b327e0ab
+  data.tar.gz: c13635638b9768858e0fd87c46a593d440586ba8
 SHA512:
-  metadata.gz: bf62aadde7feb83cb578fccb4a853530e1d2c3967f9abfc85d649ff9640c58f410bcfaa5b6a0d347444cf1aab47f7bf5e68d00f67c71d34c9d4fc8ebb3fc8e25
-  data.tar.gz: fb663dbb7503fb6f1d43f53c820257844a2573f9cf1913995e22d04f8cc3e15c53acf59e56fe5bb9e049ef5d9d915e660eeec99f58defcc46b5d22d71df392d4
+  metadata.gz: daff9fab78dd9a83bd51f0010c6c3b754c4aeb30eb6bdc40cb22772c7d654de4d7af91882c3e5429d687c63c9464ef326e6c4d095e58cf379b8e3a807f04448d
+  data.tar.gz: 1b305e38c05e8d2395260f4909439aa354c7ebd4b555a36fe38531b306a612b1a05bcce611880b8a17d0db1652dffd9847271f4eebe8d7e080daba2a98da6f83

data/.travis.yml

@@ -2,7 +2,6 @@ language: ruby
 rvm:
   - 2.4.1
   - 2.3.4
-  - 2.2.7
 services:
   - postgresql
   - mysql

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+<a name="v2.21.0"></a>
+### v2.21.0 (2018-06-10)
+
+
+#### Features
+
+* add ${pactbroker.consumerVersionTags} and ${pactbroker.providerVersionTags} to webhook templates	 ([e5121b1](/../../commit/e5121b1))
+* add ${pactbroker.verificationResultUrl} to webhook templates	 ([e19c9c9](/../../commit/e19c9c9))
+* redact potentially sensitive headers in the webhook resource	 ([619c7e9](/../../commit/619c7e9))
+* add ${pactbroker.githubVerificationStatus} to webhook templates	 ([abccf7a](/../../commit/abccf7a))
+* add ${pactbroker.providerVersionNumber} to webhook templates	 ([86bc1ec](/../../commit/86bc1ec))
+
+
+#### Bug Fixes
+
+* correctly trigger contract_content_changed webhooks when first version of a pact is published	 ([73a06ff](/../../commit/73a06ff))
+* correctly handle template parameters in URL when rendering webhook resource	 ([a4b69db](/../../commit/a4b69db))
+* correct call to execute webhooks when pact changes	 ([076afe6](/../../commit/076afe6))
+* ensure webhook hosts cannot contain templated parameters	 ([fe05919](/../../commit/fe05919))
+* allow pact broker template parameter in URL	 ([c91d04e](/../../commit/c91d04e))
+* correct logic for showing webhook response bodies in logs when a whitelist is configured	 ([db2f9d1](/../../commit/db2f9d1))
+
+
 <a name="v2.20.0"></a>
 ### v2.20.0 (2018-06-03)
 

data/db/migrations/20180608_add_verification_to_triggered_webhook.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table(:triggered_webhooks) do
+      add_foreign_key(:verification_id, :verifications)
+    end
+  end
+end

data/lib/pact_broker/api/contracts/webhook_contract.rb

@@ -1,6 +1,7 @@
 require 'reform'
 require 'reform/form'
 require 'pact_broker/webhooks/check_host_whitelist'
+require 'pact_broker/webhooks/render'
 
 module PactBroker
   module Api
@@ -70,7 +71,7 @@ module PactBroker
               end
 
               def valid_url?(url)
-                uri = URI(url)
+                uri = parse_uri(url)
                 uri.scheme && uri.host
               rescue URI::InvalidURIError
                 false
@@ -83,7 +84,7 @@ module PactBroker
               end
 
               def allowed_webhook_scheme?(url)
-                scheme = URI(url).scheme
+                scheme = parse_uri(url).scheme
                 PactBroker.configuration.webhook_scheme_whitelist.any? do | allowed_scheme |
                   scheme.downcase == allowed_scheme.downcase
                 end
@@ -91,19 +92,27 @@ module PactBroker
 
               def allowed_webhook_host?(url)
                 if host_whitelist.any?
-                  PactBroker::Webhooks::CheckHostWhitelist.call(URI(url).host, host_whitelist).any?
+                  PactBroker::Webhooks::CheckHostWhitelist.call(parse_uri(url).host, host_whitelist).any?
                 else
                   true
                 end
               end
 
+              def non_templated_host?(url)
+                parse_uri(url).host == parse_uri(url, 'differentplaceholder').host
+              end
+
               def host_whitelist
                 PactBroker.configuration.webhook_host_whitelist
               end
+
+              def parse_uri(uri_string, placeholder = 'placeholder')
+                URI(uri_string.gsub(PactBroker::Webhooks::Render::TEMPLATE_PARAMETER_REGEXP, placeholder))
+              end
             end
 
             required(:http_method).filled(:valid_method?, :allowed_webhook_method?)
-            required(:url).filled(:valid_url?, :allowed_webhook_scheme?, :allowed_webhook_host?)
+            required(:url).filled(:valid_url?, :allowed_webhook_scheme?, :allowed_webhook_host?, :non_templated_host?)
           end
         end
 

data/lib/pact_broker/api/decorators/webhook_request_decorator.rb

@@ -7,11 +7,15 @@ module PactBroker
 
         property :method
         property :url
-        property :headers, getter: lambda { | _ | headers.empty? ? nil : headers }
+        property :headers, getter: lambda { | _ | headers.empty? ? nil : self.redacted_headers }
         property :body
         property :username
         property :password, getter: lambda { | _ | display_password }
 
+
+        def redacted_headers
+          represented.headers
+        end
       end
     end
   end

data/lib/pact_broker/doc/views/webhooks.markdown

@@ -86,8 +86,15 @@ Pact Broker Github repository.
 
 The following variables may be used in the request parameters or body, and will be replaced with their appropriate values at runtime.
 
-`${pactbroker.pactUrl}`: the "permalink" URL to the newly published pact (the URL specifying the consumer version URL, rather than the "/latest" format.)
+`${pactbroker.consumerName}`: the consumer name
+`${pactbroker.providerName}`: the provider name
 `${pactbroker.consumerVersionNumber}`: the version number of the most recent consumer version associated with the pact content.
+`${pactbroker.providerVersionNumber}`: the provider version number for the verification result
+`${pactbroker.consumerVersionTags}`: the list of tag names for the most recent consumer version associated with the pact content, separated by ", ".
+`${pactbroker.providerVersionTags}`: the list of tag names for the provider version associated with the verification result, separated by ", ".
+`${pactbroker.githubVerificationStatus}`: the verification status using the correct keywords for posting to the the [Github commit status API](https://developer.github.com/v3/repos/statuses).
+`${pactbroker.pactUrl}`: the "permalink" URL to the newly published pact (the URL specifying the consumer version URL, rather than the "/latest" format.)
+`${pactbroker.verificationResultUrl}`: the URL to the relevant verification result.
 
 Example usage:
 

data/lib/pact_broker/domain/pact.rb

@@ -6,7 +6,7 @@ module PactBroker
   module Domain
     class Pact
 
-      attr_accessor :id, :provider, :consumer_version, :consumer, :created_at, :json_content, :consumer_version_number, :revision_number, :pact_version_sha
+      attr_accessor :id, :provider, :consumer_version, :consumer, :created_at, :json_content, :consumer_version_number, :revision_number, :pact_version_sha, :latest_verification
 
       def initialize attributes
         attributes.each_pair do | key, value |

data/lib/pact_broker/domain/version.rb

@@ -11,7 +11,7 @@ module PactBroker
       set_primary_key :id
       one_to_many :pact_publications, order: :revision_number, class: "PactBroker::Pacts::PactPublication", key: :consumer_version_id
       associate(:many_to_one, :pacticipant, :class => "PactBroker::Domain::Pacticipant", :key => :pacticipant_id, :primary_key => :id)
-      one_to_many :tags, :reciprocal => :version
+      one_to_many :tags, :reciprocal => :version, order: :created_at
 
       dataset_module do
         include PactBroker::Repositories::Helpers

data/lib/pact_broker/domain/webhook.rb

@@ -32,9 +32,9 @@ module PactBroker
         request && request.description
       end
 
-      def execute pact, options
+      def execute pact, verification, options
         logger.info "Executing #{self}"
-        request.execute pact, options
+        request.execute pact, verification, options
       end
 
       def to_s

data/lib/pact_broker/domain/webhook_request.rb

@@ -4,7 +4,6 @@ require 'pact_broker/domain/webhook_execution_result'
 require 'pact_broker/logging'
 require 'pact_broker/messages'
 require 'net/http'
-require 'pact_broker/webhooks/redact_logs'
 require 'pact_broker/webhooks/render'
 require 'pact_broker/api/pact_broker_urls'
 require 'pact_broker/build_http_options'
@@ -27,6 +26,7 @@ module PactBroker
 
       include PactBroker::Logging
       include PactBroker::Messages
+      HEADERS_TO_REDACT = [/authorization/i, /token/i]
 
       attr_accessor :method, :url, :headers, :body, :username, :password, :uuid
 
@@ -45,18 +45,25 @@ module PactBroker
       end
 
       def description
-        "#{method.upcase} #{URI(url).host}"
+        "#{method.upcase} #{URI(url.gsub(PactBroker::Webhooks::Render::TEMPLATE_PARAMETER_REGEXP, 'placeholder')).host}"
       end
 
       def display_password
         password.nil? ? nil : "**********"
       end
 
-      def execute pact, options = {}
+      def redacted_headers
+        headers.each_with_object({}) do | (name, value), new_headers |
+          redact = HEADERS_TO_REDACT.any?{ | pattern | name =~ pattern }
+          new_headers[name] = redact ? "**********" : value
+        end
+      end
+
+      def execute pact, verification, options = {}
         logs = StringIO.new
         execution_logger = Logger.new(logs)
         begin
-          execute_and_build_result(pact, options, logs, execution_logger)
+          execute_and_build_result(pact, verification, options, logs, execution_logger)
         rescue StandardError => e
           handle_error_and_build_result(e, options, logs, execution_logger)
         end
@@ -64,9 +71,9 @@ module PactBroker
 
       private
 
-      def execute_and_build_result pact, options, logs, execution_logger
-        uri = build_uri(pact)
-        req = build_request(uri, pact, execution_logger)
+      def execute_and_build_result pact, verification, options, logs, execution_logger
+        uri = build_uri(pact, verification)
+        req = build_request(uri, pact, verification, execution_logger)
         response = do_request(uri, req)
         log_response(response, execution_logger, options)
         result = WebhookExecutionResult.new(response, logs.string)
@@ -80,19 +87,20 @@ module PactBroker
         WebhookExecutionResult.new(nil, logs.string, e)
       end
 
-      def build_request uri, pact, execution_logger
+      def build_request uri, pact, verification, execution_logger
         req = http_request(uri)
-        execution_logger.info "HTTP/1.1 #{method.upcase} #{url_with_credentials(pact)}"
+        execution_logger.info "HTTP/1.1 #{method.upcase} #{url_with_credentials(pact, verification)}"
 
+        headers_to_log = redacted_headers
         headers.each_pair do | name, value |
-          execution_logger.info Webhooks::RedactLogs.call("#{name}: #{value}")
+          execution_logger.info "#{name}: #{headers_to_log[name]}"
           req[name] = value
         end
 
         req.basic_auth(username, password) if username
 
         unless body.nil?
-          req.body = PactBroker::Webhooks::Render.call(String === body ? body : body.to_json, pact)
+          req.body = PactBroker::Webhooks::Render.call(String === body ? body : body.to_json, pact, verification)
         end
 
         execution_logger.info(req.body) if req.body
@@ -166,19 +174,19 @@ module PactBroker
       end
 
       def to_s
-        "#{method.upcase} #{url}, username=#{username}, password=#{display_password}, headers=#{headers}, body=#{body}"
+        "#{method.upcase} #{url}, username=#{username}, password=#{display_password}, headers=#{redacted_headers}, body=#{body}"
       end
 
       def http_request(uri)
         Net::HTTP.const_get(method.capitalize).new(uri)
       end
 
-      def build_uri pact
-        URI(PactBroker::Webhooks::Render.call(url, pact){ | value | CGI::escape(value)} )
+      def build_uri(pact, verification)
+        URI(PactBroker::Webhooks::Render.call(url, pact, verification){ | value | CGI::escape(value)} )
       end
 
-      def url_with_credentials pact
-        u = build_uri(pact)
+      def url_with_credentials pact, verification
+        u = build_uri(pact, verification)
         u.userinfo = "#{CGI::escape username}:#{display_password}" if username
         u
       end

data/lib/pact_broker/locale/en.yml

@@ -7,6 +7,7 @@ en:
     valid_version_number?: "Version number '%{value}' cannot be parsed to a version number. The expected format (unless this configuration has been overridden) is a semantic version. eg. 1.3.0 or 2.0.4.rc1"
     name_in_path_matches_name_in_pact?: "does not match %{left} name in path ('%{right}')."
     valid_consumer_version_number?: "Consumer version number '%{value}' cannot be parsed to a version number. The expected format (unless this configuration has been overridden) is a semantic version. eg. 1.3.0 or 2.0.4.rc1"
+    non_templated_host?: "cannot have a template parameter in the host"
 
   pact_broker:
     messages:

data/lib/pact_broker/pacts/pact_publication.rb

@@ -26,6 +26,10 @@ module PactBroker
         LatestTaggedPactPublications.where(id: id).select(:tag_name).collect{|t| t[:tag_name]}
       end
 
+      def latest_verification
+        pact_version.latest_verification
+      end
+
       def to_domain
         PactBroker::Domain::Pact.new(
           id: id,
@@ -36,6 +40,7 @@ module PactBroker
           revision_number: revision_number,
           json_content: pact_version.content,
           pact_version_sha: pact_version.sha,
+          latest_verification: latest_verification,
           created_at: created_at
           )
       end

data/lib/pact_broker/pacts/pact_version.rb

@@ -3,7 +3,8 @@ require 'sequel'
 module PactBroker
   module Pacts
     class PactVersion < Sequel::Model(:pact_versions)
-      one_to_many :pact_publications, :reciprocal => :pact_version
+      one_to_many :pact_publications, reciprocal: :pact_version
+      one_to_many :verifications, reciprocal: :verification, order: :id, :class => "PactBroker::Domain::Verification"
 
       def name
         "Pact between #{consumer_name} and #{provider_name}"
@@ -31,6 +32,10 @@ module PactBroker
           .last
       end
 
+      def latest_verification
+        verifications.last
+      end
+
       def consumer_versions
         PactBroker::Domain::Version.where(id: PactBroker::Pacts::PactPublication.select(:consumer_version_id).where(pact_version_id: id)).order(:order)
       end

data/lib/pact_broker/pacts/service.rb

@@ -94,9 +94,10 @@ module PactBroker
         distinct
       end
 
-      def pact_has_changed_since_previous_version? pact
+      # TODO also take into account overridden revisions
+      def pact_is_new_or_pact_has_changed_since_previous_version? pact
         previous_pact = pact_repository.find_previous_pact pact
-        previous_pact && pact.json_content != previous_pact.json_content
+        previous_pact.nil? || pact.json_content != previous_pact.json_content
       end
 
       private
@@ -107,7 +108,9 @@ module PactBroker
         updated_pact = pact_repository.update existing_pact.id, params
 
         if existing_pact.json_content != updated_pact.json_content
-          webhook_service.execute_webhooks updated_pact, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+          webhook_service.execute_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+        else
+          logger.debug "Pact has not changed since previous revision, not triggering webhooks"
         end
 
         updated_pact
@@ -122,8 +125,11 @@ module PactBroker
       end
 
       def trigger_webhooks pact
-        if pact_has_changed_since_previous_version? pact
-          webhook_service.execute_webhooks pact, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+        # TODO add tests for this
+        if pact_is_new_or_pact_has_changed_since_previous_version?(pact)
+          webhook_service.execute_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+        else
+          logger.debug "Pact has not changed since previous version, not triggering webhooks"
         end
       end
     end

data/lib/pact_broker/verifications/service.rb

@@ -22,8 +22,9 @@ module PactBroker
         provider_version_number = params.fetch('providerApplicationVersion')
         PactBroker::Api::Decorators::VerificationDecorator.new(verification).from_hash(params)
         verification.number = next_verification_number
-        webhook_service.execute_webhooks pact, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED
         verification = verification_repository.create(verification, provider_version_number, pact)
+        webhook_service.execute_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED
+        verification
       end
 
       def errors params

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.20.0'
+  VERSION = '2.21.0'
 end

data/lib/pact_broker/webhooks/render.rb

@@ -1,11 +1,22 @@
 module PactBroker
   module Webhooks
     class Render
-      def self.call(body, pact, verification = nil, &escaper)
+
+      TEMPLATE_PARAMETER_REGEXP = /\$\{pactbroker\.[^\}]+\}/
+
+      def self.call(template, pact, trigger_verification = nil, &escaper)
         base_url = PactBroker.configuration.base_url
+        verification = trigger_verification || (pact && pact.latest_verification)
         params = {
-          '${pactbroker.pactUrl}' => PactBroker::Api::PactBrokerUrls.pact_url(base_url, pact),
-          '${pactbroker.consumerVersionNumber}' => pact.consumer_version_number
+          '${pactbroker.pactUrl}' => pact ? PactBroker::Api::PactBrokerUrls.pact_url(base_url, pact) : "",
+          '${pactbroker.verificationResultUrl}' => verification_url(verification),
+          '${pactbroker.consumerVersionNumber}' => pact ? pact.consumer_version_number : "",
+          '${pactbroker.providerVersionNumber}' => verification ? verification.provider_version_number : "",
+          '${pactbroker.providerVersionTags}' => provider_version_tags(verification),
+          '${pactbroker.consumerVersionTags}' => consumer_version_tags(pact),
+          '${pactbroker.consumerName}' => pact ? pact.consumer_name : "",
+          '${pactbroker.providerName}' => pact ? pact.provider_name : "",
+          '${pactbroker.githubVerificationStatus}' => github_verification_status(verification)
         }
 
         if escaper
@@ -14,8 +25,40 @@ module PactBroker
           end
         end
 
-        params.inject(body) do | body, (key, value) |
-          body.gsub(key, value)
+        params.inject(template) do | template, (key, value) |
+          template.gsub(key, value)
+        end
+      end
+
+      def self.github_verification_status verification
+        if verification
+          verification.success ? "success" : "failure"
+        else
+          "pending"
+        end
+      end
+
+      def self.verification_url verification
+        if verification
+          PactBroker::Api::PactBrokerUrls.verification_url(verification, PactBroker.configuration.base_url)
+        else
+          ""
+        end
+      end
+
+      def self.consumer_version_tags pact
+        if pact
+          pact.consumer_version.tags.collect(&:name).join(", ")
+        else
+          ""
+        end
+      end
+
+      def self.provider_version_tags verification
+        if verification
+          verification.provider_version.tags.collect(&:name).join(", ")
+        else
+          ""
         end
       end
     end

data/lib/pact_broker/webhooks/repository.rb

@@ -78,11 +78,12 @@ module PactBroker
         .collect(&:to_domain)
       end
 
-      def create_triggered_webhook trigger_uuid, webhook, pact, trigger_type
+      def create_triggered_webhook trigger_uuid, webhook, pact, verification, trigger_type
         db_webhook = Webhook.where(uuid: webhook.uuid).single_record
         TriggeredWebhook.create(
           status: TriggeredWebhook::STATUS_NOT_RUN,
           pact_publication_id: pact.id,
+          verification: verification,
           webhook: db_webhook,
           webhook_uuid: db_webhook.uuid,
           trigger_uuid: trigger_uuid,

data/lib/pact_broker/webhooks/service.rb

@@ -59,9 +59,9 @@ module PactBroker
         webhook_repository.find_all
       end
 
-      def self.execute_webhook_now webhook, pact
-        triggered_webhook = webhook_repository.create_triggered_webhook(next_uuid, webhook, pact, USER)
-        options = { failure_log_message: "Webhook execution failed", show_response: PactBroker.configuration.show_webhook_response?}
+      def self.execute_webhook_now webhook, pact, verification = nil
+        triggered_webhook = webhook_repository.create_triggered_webhook(next_uuid, webhook, pact, verification, USER)
+        options = { failure_log_message: "Webhook execution failed"}
         webhook_execution_result = execute_triggered_webhook_now triggered_webhook, options
         if webhook_execution_result.success?
           webhook_repository.update_triggered_webhook_status triggered_webhook, TriggeredWebhook::STATUS_SUCCESS
@@ -72,7 +72,7 @@ module PactBroker
       end
 
       def self.execute_triggered_webhook_now triggered_webhook, options
-        webhook_execution_result = triggered_webhook.execute options
+        webhook_execution_result = triggered_webhook.execute options.merge(show_response: PactBroker.configuration.show_webhook_response?)
         webhook_repository.create_execution triggered_webhook, webhook_execution_result
         webhook_execution_result
       end
@@ -85,21 +85,21 @@ module PactBroker
         webhook_repository.find_by_consumer_and_provider consumer, provider
       end
 
-      def self.execute_webhooks pact, event_name
+      def self.execute_webhooks pact, verification, event_name
         webhooks = webhook_repository.find_by_consumer_and_provider_and_event_name pact.consumer, pact.provider, event_name
 
         if webhooks.any?
-          run_later(webhooks, pact, event_name)
+          run_later(webhooks, pact, verification, event_name)
         else
           logger.debug "No webhook found for consumer \"#{pact.consumer.name}\" and provider \"#{pact.provider.name}\""
         end
       end
 
-      def self.run_later webhooks, pact, event_name
+      def self.run_later webhooks, pact, verification, event_name
         trigger_uuid = next_uuid
         webhooks.each do | webhook |
           begin
-            triggered_webhook = webhook_repository.create_triggered_webhook(trigger_uuid, webhook, pact, RESOURCE_CREATION)
+            triggered_webhook = webhook_repository.create_triggered_webhook(trigger_uuid, webhook, pact, verification, RESOURCE_CREATION)
             logger.info "Scheduling job for #{webhook.description} with uuid #{webhook.uuid}"
             # Bit of a dodgey hack to make sure the request transaction has finished before we execute the webhook
             Job.perform_in(5, triggered_webhook: triggered_webhook)

data/lib/pact_broker/webhooks/triggered_webhook.rb

@@ -37,6 +37,7 @@ module PactBroker
       associate(:one_to_many, :webhook_executions, :class => "PactBroker::Webhooks::Execution", :key => :triggered_webhook_id, :primary_key => :id, :order => :id)
       associate(:many_to_one, :webhook, :class => "PactBroker::Webhooks::Webhook", :key => :webhook_id, :primary_key => :id)
       associate(:many_to_one, :pact_publication, :class => "PactBroker::Pacts::PactPublication", :key => :pact_publication_id, :primary_key => :id)
+      associate(:many_to_one, :verification, :class => "PactBroker::Domain::Verification", :key => :verification_id, :primary_key => :id)
       associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
 
@@ -49,7 +50,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, options)
+        webhook.to_domain.execute(pact, verification, options)
       end
 
       def consumer_name

data/spec/integration/webhooks/certificate_spec.rb

@@ -16,7 +16,7 @@ describe "executing a webhook to a server with a self signed certificate" do
 
   let(:pact) { td.create_pact_with_hierarchy.and_return(:pact) }
 
-  subject { webhook_request.execute(pact) }
+  subject { webhook_request.execute(pact, nil) }
 
   context "without the correct cacert" do
     it "fails" do

data/spec/lib/pact_broker/api/contracts/webhook_contract_spec.rb

@@ -179,8 +179,31 @@ module PactBroker
               expect(subject.errors[:"request.url"]).to eq ["is not a valid URL eg. http://example.org"]
             end
           end
-        end
 
+          context "with a URL that has templated parameters in it" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['request']['url'] = 'https://foo/commits/${pactbroker.consumerVersionNumber}'
+              end
+            end
+
+            it "is empty" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a URL that has templated parameters in the host" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash['request']['url'] = 'https://${pactbroker.consumerVersionNumber}/commits'
+              end
+            end
+
+            it "contains an error" do
+              expect(subject.errors[:"request.url"]).to eq ["cannot have a template parameter in the host"]
+            end
+          end
+        end
       end
     end
   end

data/spec/lib/pact_broker/api/decorators/webhook_decorator_spec.rb

@@ -88,6 +88,13 @@ module PactBroker
               expect(parsed_json[:request]).to_not have_key :headers
             end
           end
+
+          context 'when the headers contain sensitve information' do
+            let(:headers) { { 'Authorization' => 'foo' } }
+            it 'redacts them' do
+              expect(parsed_json[:request][:headers][:'Authorization']).to eq "**********"
+            end
+          end
         end
 
         describe 'from_json' do

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

@@ -16,29 +16,41 @@ module PactBroker
       let(:username) { nil }
       let(:password) { nil }
       let(:url) { 'http://example.org/hook' }
+      let(:headers) { {'Content-Type' => 'text/plain', 'Authorization' => 'foo'} }
       let(:body) { 'body' }
       let(:logs) { StringIO.new }
       let(:execution_logger) { Logger.new(logs) }
       let(:options) { {failure_log_message: 'oops', show_response: show_response} }
       let(:show_response) { true }
       let(:pact) { instance_double('PactBroker::Domain::Pact') }
+      let(:verification) { instance_double('PactBroker::Domain::Verification') }
+      let(:logs) { execute.logs }
 
       subject do
         WebhookRequest.new(
           method: 'post',
           url: url,
-          headers: {'Content-Type' => 'text/plain', 'Authorization' => 'foo'},
+          headers: headers,
           username: username,
           password: password,
           body: body)
       end
 
-      let(:logs) { subject.execute(pact, options).logs }
+      let(:execute) { subject.execute(pact, verification, options) }
+
 
       describe "description" do
         it "returns a brief description of the HTTP request" do
           expect(subject.description).to eq 'POST example.org'
         end
+
+        context "when the URL has a template parameter in it" do
+          let(:url) { "http://foo/commits/${pactbroker.consumerVersionNumber}" }
+
+          it "doesn't explode" do
+            expect(subject.description).to eq 'POST foo'
+          end
+        end
       end
 
       describe "display_password" do
@@ -55,6 +67,36 @@ module PactBroker
         end
       end
 
+      describe "redacted_headers" do
+        let(:headers) do
+          {
+            'Authorization' => 'foo',
+            'X-authorization' => 'bar',
+            'token' => 'bar',
+            'Token' => 'bar',
+            'X-Auth-Token' => 'bar',
+            'X-Authorization-Token' => 'bar',
+            'OK' => 'ok'
+          }
+        end
+
+        let(:expected_headers) do
+          {
+            'Authorization' => '**********',
+            'X-authorization' => '**********',
+            'token' => '**********',
+            'Token' => '**********',
+            'X-Auth-Token' => '**********',
+            'X-Authorization-Token' => '**********',
+            'OK' => 'ok'
+          }
+        end
+
+        it "redacts sensitive headers" do
+          expect(subject.redacted_headers).to eq expected_headers
+        end
+      end
+
       describe "execute" do
         let!(:http_request) do
           stub_request(:post, "http://example.org/hook").
@@ -65,20 +107,20 @@ module PactBroker
         let(:request_body) { 'body' }
 
         it "renders the url template" do
-          expect(PactBroker::Webhooks::Render).to receive(:call).with("http://example.org/hook", pact) do | content, pact, verification, &block |
+          expect(PactBroker::Webhooks::Render).to receive(:call).with("http://example.org/hook", pact, verification) do | content, pact, verification, &block |
             expect(content).to eq "http://example.org/hook"
             expect(pact).to be pact
-            expect(verification).to be nil
+            expect(verification).to be verification
             expect(block.call("foo bar")).to eq "foo+bar"
             "http://example.org/hook"
           end
-          subject.execute(pact, options)
+          execute
         end
 
         context "when the body is a string" do
           it "renders the body template with the String" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with('body', pact)
-            subject.execute(pact, options)
+            expect(PactBroker::Webhooks::Render).to receive(:call).with('body', pact, verification)
+            execute
           end
         end
 
@@ -87,20 +129,20 @@ module PactBroker
           let(:request_body) { '{"foo":"bar"}' }
 
           it "renders the body template with JSON" do
-            expect(PactBroker::Webhooks::Render).to receive(:call).with(request_body, pact)
-            subject.execute(pact, options)
+            expect(PactBroker::Webhooks::Render).to receive(:call).with(request_body, pact, verification)
+            execute
           end
         end
 
         it "executes the configured request" do
-          subject.execute(pact, options)
+          execute
           expect(http_request).to have_been_made
         end
 
         it "logs the request" do
           allow(PactBroker.logger).to receive(:info)
           expect(PactBroker.logger).to receive(:info).with(/POST.*example.*text.*body/)
-          subject.execute(pact, options)
+          execute
         end
 
         it "logs the response" do
@@ -109,7 +151,7 @@ module PactBroker
           expect(PactBroker.logger).to receive(:info).with(/response.*200/)
           expect(PactBroker.logger).to receive(:debug).with(/content-type/)
           expect(PactBroker.logger).to receive(:debug).with(/respbod/)
-          subject.execute(pact, options)
+          execute
         end
 
         describe "execution logs" do
@@ -123,7 +165,7 @@ module PactBroker
           end
 
           it "redacts potentially sensitive headers" do
-            expect(logs).to include "Authorization: [REDACTED]"
+            expect(logs).to include "Authorization: **********"
           end
 
           it "logs the request body" do
@@ -204,7 +246,7 @@ module PactBroker
             let(:password) { "password" }
 
             it "uses the credentials" do
-              subject.execute(pact, options)
+              execute
               expect(http_request_with_basic_auth).to have_been_made
             end
           end
@@ -214,7 +256,7 @@ module PactBroker
             let(:password) { "p@$$w0rd!" }
 
             it "uses the credentials" do
-              subject.execute(pact, options)
+              execute
               expect(http_request_with_basic_auth).to have_been_made
             end
           end
@@ -231,7 +273,7 @@ module PactBroker
           end
 
           it "uses SSL" do
-            subject.execute(pact, options)
+            execute
             expect(https_request).to have_been_made
           end
         end
@@ -246,18 +288,18 @@ module PactBroker
           end
 
           it "executes the request without a body" do
-            subject.execute(pact, options)
+            execute
             expect(http_request).to have_been_made
           end
         end
 
         context "when the request is successful" do
           it "returns a WebhookExecutionResult with success=true" do
-            expect(subject.execute(pact, options).success?).to be true
+            expect(execute.success?).to be true
           end
 
           it "sets the response on the result" do
-            expect(subject.execute(pact, options).response).to be_instance_of(Net::HTTPOK)
+            expect(execute.response).to be_instance_of(Net::HTTPOK)
           end
         end
 
@@ -270,11 +312,11 @@ module PactBroker
           end
 
           it "returns a WebhookExecutionResult with success=false" do
-            expect(subject.execute(pact, options).success?).to be false
+            expect(execute.success?).to be false
           end
 
           it "sets the response on the result" do
-            expect(subject.execute(pact, options).response).to be_instance_of(Net::HTTPInternalServerError)
+            expect(execute.response).to be_instance_of(Net::HTTPInternalServerError)
           end
         end
 
@@ -285,7 +327,7 @@ module PactBroker
           end
 
           it "removes the non UTF-8 characters before saving the logs so they don't blow up the database" do
-            result = subject.execute(pact, options)
+            result = execute
             expect(result.logs).to include "This has some  invalid chars"
           end
 
@@ -293,7 +335,7 @@ module PactBroker
             logger = double("logger").as_null_object
             allow(Logger).to receive(:new).and_return(logger)
             expect(logger).to receive(:debug).with(/Note that invalid UTF-8 byte sequences were removed/)
-            subject.execute(pact, options)
+            execute
           end
         end
 
@@ -308,15 +350,15 @@ module PactBroker
 
           it "logs the error" do
             expect(PactBroker.logger).to receive(:error).with(/Error.*WebhookTestError.*blah/)
-            subject.execute(pact, options)
+            execute
           end
 
           it "returns a WebhookExecutionResult with success=false" do
-            expect(subject.execute(pact, options).success?).to be false
+            expect(execute.success?).to be false
           end
 
           it "returns a WebhookExecutionResult with an error" do
-            expect(subject.execute(pact, options).error).to be_instance_of WebhookTestError
+            expect(execute.error).to be_instance_of WebhookTestError
           end
 
           it "logs the failure_log_message" do

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

@@ -12,6 +12,7 @@ module PactBroker
       let(:request) { instance_double(PactBroker::Domain::WebhookRequest, execute: nil)}
       let(:options) { double('options') }
       let(:pact) { double('pact') }
+      let(:verification) { double('verification') }
 
       subject { Webhook.new(request: request, consumer: consumer, provider: provider,) }
 
@@ -24,14 +25,14 @@ module PactBroker
       describe "execute" do
 
         it "executes the request" do
-          expect(request).to receive(:execute).with(pact, options)
-          subject.execute pact, options
+          expect(request).to receive(:execute).with(pact, verification, options)
+          subject.execute pact, verification, options
         end
 
         it "logs before and after" do
           allow(PactBroker.logger).to receive(:info)
           expect(PactBroker.logger).to receive(:info).with(/Executing/)
-          subject.execute pact, options
+          subject.execute pact, verification, options
         end
       end
     end

data/spec/lib/pact_broker/matrix/head_row_spec.rb

@@ -50,10 +50,9 @@ module PactBroker
               .create_pact
           end
 
-          subject { HeadRow.eager(:consumer_version_tags).eager(:latest_verification_for_consumer_version_tag).order(:pact_publication_id).all }
+          subject { HeadRow.where(verification_id: nil, consumer_version_tag_name: "prod").eager(:consumer_version_tags).eager(:latest_verification_for_consumer_version_tag).order(:pact_publication_id).all }
 
           it "returns the most recent verification for the previous version with the same tag" do
-            expect(subject.last.verification_id).to be nil # this pact version has not been verified directly
             expect(subject.last.latest_verification_for_consumer_version_tag.provider_version.number).to eq "11"
           end
         end

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

@@ -30,7 +30,7 @@ module PactBroker
 
       end
 
-      describe "#pact_has_changed_since_previous_version?" do
+      describe "#pact_is_new_or_pact_has_changed_since_previous_version?" do
         let(:json_content) { { 'some' => 'json'}.to_json }
         let(:pact) { instance_double(PactBroker::Domain::Pact, json_content: json_content)}
 
@@ -38,7 +38,7 @@ module PactBroker
           allow_any_instance_of(Pacts::Repository).to receive(:find_previous_pact).and_return(previous_pact)
         end
 
-        subject { Service.pact_has_changed_since_previous_version? pact }
+        subject { Service.pact_is_new_or_pact_has_changed_since_previous_version? pact }
 
         context "when a previous pact is found" do
           let(:previous_pact) { instance_double(PactBroker::Domain::Pact, json_content: previous_json_content)}
@@ -60,8 +60,9 @@ module PactBroker
 
         context "when a previous pact is not found" do
           let(:previous_pact) { nil }
-          it "returns false" do
-            expect(subject).to be_falsey
+
+          it "returns true" do
+            expect(subject).to be_truthy
           end
         end
       end

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

@@ -9,6 +9,10 @@ module PactBroker
       subject { PactBroker::Verifications::Service }
 
       describe "#create" do
+        before do
+          allow(PactBroker::Webhooks::Service).to receive(:execute_webhooks)
+        end
+
         let(:params) { {'success' => true, 'providerApplicationVersion' => '4.5.6'} }
         let(:pact) { TestDataBuilder.new.create_pact_with_hierarchy.and_return(:pact) }
         let(:create_verification) { subject.create 3, params, pact }
@@ -36,6 +40,11 @@ module PactBroker
           expect(verification.provider_version).to_not be nil
           expect(verification.provider_version_number).to eq '4.5.6'
         end
+
+        it "invokes the webhooks for the verification" do
+          verification = create_verification
+          expect(PactBroker::Webhooks::Service).to have_received(:execute_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED)
+        end
       end
 
       describe "#errors" do

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

@@ -7,28 +7,112 @@ module PactBroker
       describe "#call" do
         before do
           allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).and_return("http://foo")
+          allow(PactBroker::Api::PactBrokerUrls).to receive(:verification_url) do | verification, base_url |
+            expect(verification).to_not be nil
+            "http://verification"
+          end
         end
 
-        let(:body) do
-          "Foo ${pactbroker.pactUrl} ${pactbroker.consumerVersionNumber}"
+        let(:pact) do
+          double("pact",
+            consumer_version: consumer_version,
+            consumer_version_number: "1.2.3+foo",
+            consumer_name: "Foo",
+            provider_name: "Bar",
+            latest_verification: nil)
         end
 
-        let(:pact) do
-          instance_double("pact", consumer_version_number: "1.2.3+foo")
+        let(:pact_with_no_verification) { pact }
+
+        let(:pact_with_successful_verification) do
+          double("pact",
+            consumer_version: consumer_version,
+            consumer_version_number: "1.2.3+foo",
+            consumer_name: "Foo",
+            provider_name: "Bar",
+            latest_verification: verification)
+        end
+
+        let(:pact_with_failed_verification) do
+          double("pact",
+            consumer_version: consumer_version,
+            consumer_version_number: "1.2.3+foo",
+            consumer_name: "Foo",
+            provider_name: "Bar",
+            latest_verification: failed_verification)
+        end
+
+        let(:verification) do
+          double("verification", provider_version_number: "3", success: true, provider_version: provider_version)
+        end
+
+        let(:failed_verification) do
+          double("verification", provider_version_number: "3", success: false, provider_version: provider_version)
+        end
+
+        let(:provider_version) do
+          double("version", tags: provider_tags)
         end
 
-        subject { Render.call(body, pact, nil) }
+        let(:consumer_version) do
+          double("version", tags: consumer_tags)
+        end
+
+        let(:provider_tags) do
+          [ double("tag", name: "test"), double("tag", name: "prod") ]
+        end
+
+        let(:consumer_tags) do
+          [ double("tag", name: "test") ]
+        end
+
+        let(:nil_pact) { nil }
+        let(:nil_verification) { nil }
 
-        it { is_expected.to eq "Foo http://foo 1.2.3+foo" }
+        subject { Render.call(template, pact, verification) }
+
+        TEST_CASES = [
+          ["${pactbroker.pactUrl}", "http://foo", :pact, :verification],
+          ["${pactbroker.consumerVersionNumber}", "1.2.3+foo", :pact, :verification],
+          ["${pactbroker.providerVersionNumber}", "3", :pact, :verification],
+          ["${pactbroker.providerVersionNumber}", "", :pact, :nil_verification],
+          ["${pactbroker.consumerName}", "Foo", :pact, :verification],
+          ["${pactbroker.providerName}", "Bar", :pact, :verification],
+          ["${pactbroker.githubVerificationStatus}", "success", :pact, :verification],
+          ["${pactbroker.githubVerificationStatus}", "failure", :pact, :failed_verification],
+          ["${pactbroker.githubVerificationStatus}", "pending", :nil_pact, :nil_verification],
+          ["${pactbroker.githubVerificationStatus}", "pending", :pact_with_no_verification, :nil_verification],
+          ["${pactbroker.githubVerificationStatus}", "success", :pact_with_successful_verification, :nil_verification],
+          ["${pactbroker.githubVerificationStatus}", "failure", :pact_with_failed_verification, :nil_verification],
+          ["${pactbroker.verificationResultUrl}", "", :pact_with_no_verification, :nil_verification],
+          ["${pactbroker.verificationResultUrl}", "http://verification", :pact_with_successful_verification, :nil_verification],
+          ["${pactbroker.verificationResultUrl}", "http://verification", :pact_with_successful_verification, :verification],
+          ["${pactbroker.providerVersionTags}", "test, prod", :pact_with_successful_verification, :verification],
+          ["${pactbroker.consumerVersionTags}", "test", :pact_with_successful_verification, :verification],
+        ]
+
+        TEST_CASES.each do | (template, expected_output, pact_var_name, verification_var_name) |
+          context "with #{pact_var_name} and #{verification_var_name}" do
+            it "replaces #{template} with #{expected_output.inspect}" do
+              the_pact = send(pact_var_name)
+              the_verification = send(verification_var_name)
+              output = Render.call(template, the_pact, the_verification)
+              expect(output).to eq expected_output
+            end
+          end
+        end
 
         context "with an escaper" do
           subject do
-            Render.call(body, pact, nil) do | value |
+            Render.call(template, pact, verification) do | value |
               CGI.escape(value)
             end
           end
+          let(:template) do
+            "${pactbroker.pactUrl}"
+          end
 
-          it { is_expected.to eq "Foo http%3A%2F%2Ffoo 1.2.3%2Bfoo" }
+          it { is_expected.to eq "http%3A%2F%2Ffoo" }
         end
       end
     end

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

@@ -333,14 +333,16 @@ module PactBroker
             .create_webhook
             .create_consumer_version
             .create_pact
+            .create_verification
         end
 
-        subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, 'publication' }
+        subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, td.verification, 'publication' }
 
         it "creates a TriggeredWebhook" do
           expect(subject.webhook_uuid ).to eq td.webhook.uuid
           expect(subject.consumer).to eq td.consumer
           expect(subject.provider).to eq td.provider
+          expect(subject.verification).to eq td.verification
           expect(subject.trigger_uuid).to eq '1234'
           expect(subject.trigger_type).to eq 'publication'
         end
@@ -364,6 +366,14 @@ module PactBroker
         it "sets the PactPublication" do
           expect(subject.pact_publication.id).to eq td.pact.id
         end
+
+        context "without a verification" do
+          subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, nil, 'publication' }
+
+          it "does not set the verification" do
+            expect(subject.verification).to be nil
+          end
+        end
       end
 
       describe "create_execution" do

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

@@ -30,6 +30,7 @@ module PactBroker
 
       describe ".execute_webhooks" do
 
+        let(:verification) { instance_double(PactBroker::Domain::Verification)}
         let(:pact) { instance_double(PactBroker::Domain::Pact, consumer: consumer, provider: provider, consumer_version: consumer_version)}
         let(:consumer_version) { PactBroker::Domain::Version.new(number: '1.2.3') }
         let(:consumer) { PactBroker::Domain::Pacticipant.new(name: 'Consumer') }
@@ -43,7 +44,7 @@ module PactBroker
           allow(Job).to receive(:perform_in)
         end
 
-        subject { Service.execute_webhooks pact, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        subject { Service.execute_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
 
         it "finds the webhooks" do
           expect_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_provider_and_event_name).with(consumer, provider, PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME)
@@ -52,7 +53,7 @@ module PactBroker
 
         context "when webhooks are found" do
           it "executes the webhook" do
-            expect(Service).to receive(:run_later).with(webhooks, pact, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED)
+            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED)
             subject
           end
         end
@@ -97,17 +98,11 @@ module PactBroker
             .create_consumer_version
             .create_pact
             .create_webhook(method: 'GET', url: 'http://example.org')
+            .create_verification
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.execute_webhook_now td.webhook, pact }
-
-        it "executes the triggered webhook with the correct options" do
-          allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('foo')
-          expected_options = { :failure_log_message => "Webhook execution failed", :show_response => 'foo' }
-          expect_any_instance_of(PactBroker::Webhooks::TriggeredWebhook).to receive(:execute).with(expected_options).and_call_original
-          subject
-        end
+        subject { PactBroker::Webhooks::Service.execute_webhook_now td.webhook, pact, td.verification }
 
         it "executes the HTTP request of the webhook" do
           subject
@@ -118,6 +113,16 @@ module PactBroker
           expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
         end
 
+        it "saves the pact" do
+          subject
+          expect(PactBroker::Webhooks::TriggeredWebhook.order(:id).last.pact_publication_id).to_not be nil
+        end
+
+        it "saves the verification" do
+          subject
+          expect(PactBroker::Webhooks::TriggeredWebhook.order(:id).last.verification_id).to_not be nil
+        end
+
         it "saves the execution" do
           expect { subject }.to change { PactBroker::Webhooks::Execution.count }.by(1)
         end
@@ -141,17 +146,25 @@ module PactBroker
             .create_provider
             .create_consumer_version
             .create_pact
+            .create_verification
             .create_webhook(method: 'GET', url: 'http://example.org', events: events)
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.execute_webhooks pact, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        subject { PactBroker::Webhooks::Service.execute_webhooks pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
 
         it "executes the HTTP request of the webhook" do
           subject
           expect(http_request).to have_been_made
         end
 
+        it "executes the webhook with the correct options" do
+          allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('foo')
+          expected_options = {:show_response => 'foo' }
+          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).with(anything, anything, hash_including(expected_options)).and_call_original
+          subject
+        end
+
         it "saves the triggered webhook" do
           expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
         end

data/spec/support/test_data_builder.rb

@@ -35,6 +35,7 @@ class TestDataBuilder
   attr_reader :provider
   attr_reader :consumer_version
   attr_reader :pact
+  attr_reader :verification
   attr_reader :webhook
   attr_reader :webhook_execution
   attr_reader :triggered_webhook
@@ -254,10 +255,14 @@ class TestDataBuilder
     self
   end
 
+  def create_verification_webhook params = {}
+    create_webhook params.merge(events: [{ name: PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED }])
+  end
+
   def create_triggered_webhook params = {}
     params.delete(:comment)
     trigger_uuid = params[:trigger_uuid] || webhook_service.next_uuid
-    @triggered_webhook = webhook_repository.create_triggered_webhook trigger_uuid, @webhook, @pact, PactBroker::Webhooks::Service::RESOURCE_CREATION
+    @triggered_webhook = webhook_repository.create_triggered_webhook trigger_uuid, @webhook, @pact, nil, PactBroker::Webhooks::Service::RESOURCE_CREATION
     @triggered_webhook.update(status: params[:status]) if params[:status]
     set_created_at_if_set params[:created_at], :triggered_webhooks, {id: @triggered_webhook.id}
     self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.20.0
+  version: 2.21.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-07 00:00:00.000000000 Z
+date: 2018-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -617,6 +617,7 @@ files:
 - db/migrations/20180330_refresh_matrix.rb
 - db/migrations/20180523_create_latest_verifications_for_consumer_version_tags.rb
 - db/migrations/20180524_create_latest_verifications_for_consumer_and_provider.rb
+- db/migrations/20180608_add_verification_to_triggered_webhook.rb
 - db/migrations/migration_helper.rb
 - db/pact_broker_database.sqlite3
 - db/test/backwards_compatibility/.rspec