pact_broker 2.77.0 → 2.80.0

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

@@ -1,20 +1,19 @@
-require 'spec_helper'
-require 'pact_broker/webhooks/service'
-require 'pact_broker/webhooks/triggered_webhook'
-require 'pact_broker/webhooks/webhook_event'
-require 'webmock/rspec'
-require 'sucker_punch/testing/inline'
-require 'pact_broker/webhooks/execution_configuration'
+require "spec_helper"
+require "pact_broker/webhooks/service"
+require "pact_broker/webhooks/triggered_webhook"
+require "pact_broker/webhooks/webhook_event"
+require "webmock/rspec"
+require "sucker_punch/testing/inline"
+require "pact_broker/webhooks/execution_configuration"
 
 module PactBroker
-
   module Webhooks
     describe Service do
       before do
         allow(Service).to receive(:logger).and_return(logger)
       end
 
-      let(:logger) { double('logger').as_null_object }
+      let(:logger) { double("logger").as_null_object }
 
       describe "validate - integration test" do
         let(:invalid_webhook) { PactBroker::Domain::Webhook.new }
@@ -23,21 +22,21 @@ module PactBroker
           subject { Service.errors(invalid_webhook) }
 
           it "does not contain an error for the uuid" do
-            expect(subject.messages).to_not have_key('uuid')
+            expect(subject.messages).to_not have_key("uuid")
           end
         end
 
         context "with a uuid" do
-          subject { Service.errors(invalid_webhook, '') }
+          subject { Service.errors(invalid_webhook, "") }
 
           it "merges the uuid errors with the webhook errors" do
-            expect(subject.messages['uuid'].first).to include "can only contain"
+            expect(subject.messages["uuid"].first).to include "can only contain"
           end
         end
       end
 
       describe ".valid_uuid_format?" do
-        it 'does something' do
+        it "does something" do
           expect(Service.valid_uuid_format?("_-bcdefghigHIJKLMNOP")).to be true
           expect(Service.valid_uuid_format?("HIJKLMNOP")).to be false
           expect(Service.valid_uuid_format?("abcdefghigHIJKLMNOP\\")).to be false
@@ -73,8 +72,8 @@ module PactBroker
         let(:existing_webhook) { PactBroker::Domain::Webhook.new(request: request) }
         let(:params) do
           {
-            'request' => {
-              'url' => "http://url"
+            "request" => {
+              "url" => "http://url"
             }
           }
         end
@@ -83,58 +82,58 @@ module PactBroker
 
         it "sends through the params to the repository" do
           updated_webhook = nil
-          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | instance, uuid, webhook |
+          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | _instance, _uuid, webhook |
             updated_webhook = webhook
             true
           end
           subject
-          expect(updated_webhook.request.url).to eq 'http://url'
+          expect(updated_webhook.request.url).to eq "http://url"
         end
 
         context "when the webhook has a password and the incoming parameters do not contain a password" do
-          let(:existing_password) { 'password' }
+          let(:existing_password) { "password" }
 
           it "does not overwite the password" do
             updated_webhook = nil
-            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | instance, uuid, webhook |
+            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | _instance, _uuid, webhook |
               updated_webhook = webhook
               true
             end
             subject
-            expect(updated_webhook.request.password).to eq 'password'
+            expect(updated_webhook.request.password).to eq "password"
           end
         end
 
         context "when the webhook has a password and the incoming parameters contain a *** password" do
-          let(:existing_password) { 'password' }
+          let(:existing_password) { "password" }
           let(:params) do
             {
-              'request' => {
-                'url' => 'http://url',
-                'password' => '*******'
+              "request" => {
+                "url" => "http://url",
+                "password" => "*******"
               }
             }
           end
 
           it "does not overwite the password" do
             updated_webhook = nil
-            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | instance, uuid, webhook |
+            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | _instance, _uuid, webhook |
               updated_webhook = webhook
               true
             end
             subject
-            expect(updated_webhook.request.password).to eq 'password'
+            expect(updated_webhook.request.password).to eq "password"
           end
         end
 
         context "when the webhook has an authorization header and the incoming parameters contain a *** authorization header" do
-          let(:headers) { { 'Authorization' => 'existing'} }
+          let(:headers) { { "Authorization" => "existing"} }
           let(:params) do
             {
-              'request' => {
-                'url' => "http://url",
-                'headers' => {
-                  'authorization' => "***********"
+              "request" => {
+                "url" => "http://url",
+                "headers" => {
+                  "authorization" => "***********"
                 }
               }
             }
@@ -142,238 +141,33 @@ module PactBroker
 
           it "does not overwite the authorization header" do
             updated_webhook = nil
-            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | instance, uuid, webhook |
+            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | _instance, _uuid, webhook |
               updated_webhook = webhook
               true
             end
             subject
-            expect(updated_webhook.request.headers['Authorization']).to eq 'existing'
+            expect(updated_webhook.request.headers["Authorization"]).to eq "existing"
           end
         end
 
         context "the incoming parameters contain a password" do
           let(:params) do
             {
-              'request' => {
-                'password' => "updated"
+              "request" => {
+                "password" => "updated"
               }
             }
           end
 
           it "updates the password" do
             updated_webhook = nil
-            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | instance, uuid, webhook |
+            allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:update_by_uuid) do | _instance, _uuid, webhook |
               updated_webhook = webhook
               true
             end
             subject
-            expect(updated_webhook.request.password).to eq 'updated'
-          end
-        end
-      end
-
-      describe ".trigger_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') }
-        let(:provider) { PactBroker::Domain::Pacticipant.new(name: 'Provider') }
-        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) { { 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,
-            logging_options: {}
-          }
-        end
-
-        before do
-          allow(webhook_execution_configuration).to receive(:with_webhook_context).and_return(webhook_execution_configuration)
-          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_or_provider_and_event_name).and_return(webhooks)
-          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:create_triggered_webhook).and_return(triggered_webhook)
-          allow(Job).to receive(:perform_in)
-        end
-
-        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)
-          subject
-        end
-
-        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, expected_event_context, options)
-            subject
-          end
-
-          it "merges the event name in the options" do
-            expect(webhook_execution_configuration).to receive(:with_webhook_context).with(event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED)
-            subject
-          end
-        end
-
-        context "when no webhooks are found" do
-          let(:webhooks) { [] }
-          it "does nothing" do
-            expect(Service).to_not receive(:run_later)
-            subject
+            expect(updated_webhook.request.password).to eq "updated"
           end
-
-          it "logs that no webhook was found" do
-            expect(logger).to receive(:info).with(/No enabled webhooks found/)
-            subject
-          end
-        end
-
-        context "when there is a scheduling error", job: true do
-          before do
-            allow(Job).to receive(:perform_in).and_raise("an error")
-          end
-
-          it "logs the error" do
-            allow(Service.logger).to receive(:warn)
-            expect(Service.logger).to receive(:warn).with(/Error scheduling/, StandardError)
-            subject
-          end
-        end
-      end
-
-      describe ".test_execution" do
-        let(:webhook) do
-          instance_double(PactBroker::Domain::Webhook,
-            trigger_on_provider_verification_published?: trigger_on_verification,
-            consumer_name: 'consumer',
-            provider_name: 'provider',
-            execute: result
-          )
-        end
-        let(:pact) { instance_double(PactBroker::Domain::Pact) }
-        let(:verification) { instance_double(PactBroker::Domain::Verification) }
-        let(:trigger_on_verification) { false }
-        let(:result) { double('result') }
-        let(:execution_configuration) do
-          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)
-          allow(PactBroker::Verifications::Service).to receive(:search_for_latest).and_return(verification)
-          allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('foo')
-          allow(execution_configuration).to receive(:with_failure_log_message).and_return(execution_configuration)
-        end
-
-        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')
-          subject
-        end
-
-        it "returns the result" do
-          expect(subject).to be result
-        end
-
-        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, event_context.merge(event_name: "test"), execution_configuration_hash)
-            subject
-          end
-        end
-
-        context "when a pact cannot be found" do
-          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, anything)
-            subject
-          end
-        end
-
-        context "when the trigger is for a verification publication" do
-          let(:trigger_on_verification) { true }
-
-          it "searches for the latest matching verification" do
-            expect(PactBroker::Verifications::Service).to receive(:search_for_latest).with('consumer', 'provider')
-            subject
-          end
-
-          it "executes the webhook with the pact and the verification" do
-            expect(webhook).to receive(:execute).with(pact, verification, event_context.merge(event_name: "test"), execution_configuration_hash)
-            subject
-          end
-
-          context "when a verification cannot be found" do
-            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, anything)
-              subject
-            end
-          end
-        end
-      end
-
-      describe ".trigger_webhooks integration test", job: true do
-        let!(:http_request) do
-          stub_request(:get, "http://example.org").
-            to_return(:status => 200)
-        end
-
-        let(:events) { [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }] }
-        let(:webhook_execution_configuration) do
-          PactBroker::Webhooks::ExecutionConfiguration.new
-            .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,
-            webhook_execution_configuration: webhook_execution_configuration
-          }
-        end
-        let(:logging_options) { { show_response: true } }
-        let(:database_connector) { ->(&block) { block.call } }
-        let(:pact) do
-          td.create_consumer
-            .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.trigger_webhooks(pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, options) }
-
-        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
-          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).and_call_original
-          subject
-        end
-
-        it "saves the triggered webhook" do
-          expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
-        end
-
-        it "saves the execution" do
-          expect { subject }.to change { PactBroker::Webhooks::Execution.count }.by(1)
-        end
-
-        it "marks the triggered webhook as a success" do
-          subject
-          expect(TriggeredWebhook.first.status).to eq TriggeredWebhook::STATUS_SUCCESS
         end
       end
 
@@ -382,7 +176,7 @@ module PactBroker
 
         it "returns a list of parameters and their descriptions" do
           expect(subject.first.name).to start_with "pactbroker.consumerName"
-          expect(subject.first.description).to eq "the consumer name"
+          expect(subject.first.description).to eq "The consumer name"
         end
       end
     end

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

@@ -1,13 +1,13 @@
-require 'pact_broker/webhooks/status'
+require "pact_broker/webhooks/status"
 
 module PactBroker
   module Webhooks
     describe Status do
-      let(:webhooks) { [double('webhook')]}
+      let(:webhooks) { [double("webhook")]}
       let(:latest_triggered_webhooks) { [ triggered_webhook_1, triggered_webhook_2] }
-      let(:pact) { double('pact') }
-      let(:triggered_webhook_1) { double('triggered_webhook', status: status_1) }
-      let(:triggered_webhook_2) { double('triggered_webhook', status: status_2) }
+      let(:pact) { double("pact") }
+      let(:triggered_webhook_1) { double("triggered_webhook", status: status_1) }
+      let(:triggered_webhook_2) { double("triggered_webhook", status: status_2) }
       let(:status_1) { TriggeredWebhook::STATUS_SUCCESS }
       let(:status_2) { TriggeredWebhook::STATUS_SUCCESS }
 

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

@@ -1,214 +1,339 @@
-require 'pact_broker/webhooks/trigger_service'
+require "pact_broker/webhooks/trigger_service"
 
 module PactBroker
   module Webhooks
     describe TriggerService do
-      let(:pact) { double("pact", pact_version_sha: pact_version_sha) }
+      let(:pact) { double("pact", pact_version_sha: pact_version_sha, consumer_name: "foo", provider_name: "bar") }
       let(:pact_version_sha) { "111" }
       let(:pact_repository) { double("pact_repository", find_previous_pacts: previous_pacts) }
-      let(:webhook_service) { double("webhook_service", trigger_webhooks: nil) }
+      let(:pact_service) { class_double("PactBroker::Pacts::Service").as_stubbed_const }
       let(:previous_pact) { double("previous_pact", pact_version_sha: previous_pact_version_sha) }
       let(:previous_pact_version_sha) { "111" }
       let(:previous_pacts) { { untagged: previous_pact } }
-      let(:logger) { double('logger').as_null_object }
+      let(:logger) { double("logger").as_null_object }
       let(:event_context) { { some: "data" } }
-      let(:webhook_options) { { the: 'options'} }
+      let(:webhook_options) { { the: "options"} }
 
       before do
         allow(TriggerService).to receive(:pact_repository).and_return(pact_repository)
-        allow(TriggerService).to receive(:webhook_service).and_return(webhook_service)
+        allow(TriggerService).to receive(:pact_service).and_return(pact_service)
         allow(TriggerService).to receive(:logger).and_return(logger)
       end
 
+      def find_result_with_message_including(message)
+        subject.find { | result | result.message.include?(message) }
+      end
+
       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, event_context, webhook_options)
+          expect(TriggerService).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, event_context, webhook_options)
+          expect(TriggerService).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, event_context, anything)
+          expect(TriggerService).to_not receive(:trigger_webhooks).with(anything, anything, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, anything)
           subject
         end
       end
+    end
 
-      describe "#trigger_webhooks_for_new_pact" do
-        subject { TriggerService.trigger_webhooks_for_new_pact(pact, event_context, webhook_options) }
+    describe TriggerService do
+      describe ".create_triggered_webhooks_for_event" do
+        before do
+          allow(TriggerService).to receive(:webhook_repository).and_return(webhook_repository)
+          allow(TriggerService).to receive(:logger).and_return(logger)
+          allow(TriggerService).to receive(:pact_service).and_return(pact_service)
+        end
+        let(:pact_service) { class_double("PactBroker::Pacts::Service").as_stubbed_const }
+        let(:logger) { double("logger").as_null_object }
+        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") }
+        let(:provider) { PactBroker::Domain::Pacticipant.new(name: "Provider") }
+        let(:webhooks) { [webhook]}
+        let(:webhook) do
+          instance_double(PactBroker::Domain::Webhook, description: "description", uuid: "1244", expand_currently_deployed_provider_versions?: expand_currently_deployed)
+        end
+        let(:expand_currently_deployed) { false }
+        let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
+        let(:event_name) { PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        let(:event_context) { { some: "data" } }
+        let(:expected_event_context) { { some: "data", event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED } }
+        let(:webhook_repository) { instance_double(Repository, create_triggered_webhook: triggered_webhook, find_webhooks_to_trigger: webhooks) }
 
-        context "when no previous untagged pact exists" do
-          let(:previous_pact) { nil }
+        subject { TriggerService.create_triggered_webhooks_for_event(pact, verification, event_name, event_context) }
 
-          include_examples "triggering a contract_published event"
-          include_examples "triggering a contract_content_changed event"
+        it "finds the webhooks" do
+          expect(webhook_repository).to receive(:find_webhooks_to_trigger).with(consumer: consumer, provider: provider, event_name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME)
+          subject
+        end
 
-          it "logs the reason why it triggered the contract_content_changed event" do
-            expect(logger).to receive(:info).with(/first time untagged pact published/)
+        context "when webhooks are found" do
+          it "merges the event name in the webhook context" do
+            expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, anything, anything, anything, anything, anything, hash_including(event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED))
             subject
           end
-        end
 
-        context "when a previous untagged pact exists and the sha is different" do
-          let(:previous_pact_version_sha) { "222" }
-
-          let(:previous_pacts) { { :untagged => previous_pact } }
+          context "when there should be a webhook triggered for each currently deployed version" do
+            before do
+              allow(TriggerService).to receive(:deployed_version_service).and_return(deployed_version_service)
+              allow(deployed_version_service).to receive(:find_currently_deployed_versions_for_pacticipant).and_return(currently_deployed_versions)
+            end
+            let(:expand_currently_deployed) { true }
+            let(:deployed_version_service) { class_double("PactBroker::Deployments::DeployedVersionService").as_stubbed_const }
+            let(:currently_deployed_version_1) { instance_double("PactBroker::Deployments::DeployedVersion", version_number: "1") }
+            let(:currently_deployed_version_2) { instance_double("PactBroker::Deployments::DeployedVersion", version_number: "2") }
+            let(:currently_deployed_versions) { [currently_deployed_version_1, currently_deployed_version_2] }
+
+            it "creates a triggered webhook for each currently deployed version" do
+              expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, webhook, pact, verification, TriggerService::RESOURCE_CREATION, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, expected_event_context.merge(currently_deployed_provider_version_number: "1"))
+              expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, webhook, pact, verification, TriggerService::RESOURCE_CREATION, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, expected_event_context.merge(currently_deployed_provider_version_number: "2"))
+              subject
+            end
 
-          include_examples "triggering a contract_published event"
-          include_examples "triggering a contract_content_changed event"
+            context "when the same version is deployed to multiple environments" do
+              let(:currently_deployed_version_2) { instance_double("PactBroker::Deployments::DeployedVersion", version_number: "1") }
 
-          it "logs the reason why it triggered the contract_content_changed event" do
-            expect(logger).to receive(:info).with(/pact content has changed since previous untagged version/)
-            subject
+              it "only creates one triggered webhook" do
+                expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, anything, anything, anything, anything, anything, expected_event_context.merge(currently_deployed_provider_version_number: "1"))
+                subject
+              end
+            end
           end
-        end
 
-        context "when a previous untagged pact exists and the sha is the same" do
-          let(:previous_pact_version_sha) { pact_version_sha }
+          context "when there should be a webhook triggered for each consumer version that had a pact verified" do
+            # let(:triggered_webhooks) { [instance_double(TriggeredWebhook, event_context: { some: 'context'}, webhook: instance_double(Webhook, uuid: "webhook-uuid"))]}
 
-          let(:previous_pacts) { { :untagged => previous_pact } }
-
-          include_examples "triggering a contract_published event"
-          include_examples "not triggering a contract_content_changed event"
-        end
+            before do
+              allow(pact_service).to receive(:find_pact).and_return(pact_for_consumer_version_1, pact_for_consumer_version_2)
+              # allow(pact_service).to receive(:find_pact).with(hash_including(consumer_version_number: "2")).and_return(pact_for_consumer_version_2)
+            end
+            let(:event_name) { PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED }
+            let(:pact) { instance_double(PactBroker::Domain::Pact, provider_name: provider.name, consumer_name: consumer.name, 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") }
+            let(:provider) { PactBroker::Domain::Pacticipant.new(name: "Provider") }
+
+            # 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) { { event_name: event_name, consumer_version_number: "1", consumer_version_tags: ["prod", "main"], other: "foo" } }
+            let(:expected_event_context_2) { { event_name: event_name, consumer_version_number: "2", consumer_version_tags: ["feat/2"], other: "foo" } }
+            let(:pact_for_consumer_version_1) { double("pact_for_consumer_version_1") }
+            let(:pact_for_consumer_version_2) { double("pact_for_consumer_version_2") }
+
+            it "finds the pact publication for each consumer version number" do
+              expect(pact_service).to receive(:find_pact).with(hash_including(consumer_version_number: "1")).and_return(pact_for_consumer_version_1)
+              expect(pact_service).to receive(:find_pact).with(hash_including(consumer_version_number: "2")).and_return(pact_for_consumer_version_2)
+              subject
+            end
 
-        context "when no previous pact with a given tag exists" do
-          let(:previous_pact) { nil }
-          let(:previous_pacts) { { "dev" => previous_pact } }
+            context "when there are consumer_version_selectors in the event_context" do
+              it "creates a triggered webhook for each consumer version (ie. commit)" do
+                expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, webhook, pact_for_consumer_version_1, verification, TriggerService::RESOURCE_CREATION, event_name, expected_event_context_1)
+                expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, webhook, pact_for_consumer_version_2, verification, TriggerService::RESOURCE_CREATION, event_name, expected_event_context_2)
+                subject
+              end
+            end
 
-          include_examples "triggering a contract_published event"
-          include_examples "triggering a contract_content_changed event"
+            context "when there are no consumer_version_selectors" do
+              let(:event_context) { { some: "data" } }
 
-          it "logs the reason why it triggered the contract_content_changed event" do
-            expect(logger).to receive(:info).with(/first time pact published with consumer version tagged dev/)
-            subject
+              it "passes through the event context and only makes one triggered webhook" do
+                expect(webhook_repository).to receive(:create_triggered_webhook).with(anything, webhook, pact, verification, TriggerService::RESOURCE_CREATION, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, event_context.merge(event_name: event_name))
+                subject
+              end
+            end
           end
         end
+      end
 
-        context "when a previous pact with a given tag exists and the sha is different" do
-          let(:previous_pact_version_sha) { "222" }
-          let(:previous_pacts) { { "dev" => previous_pact } }
-
-          include_examples "triggering a contract_published event"
-          include_examples "triggering a contract_content_changed event"
+      describe ".schedule_webhooks" do
+        let(:options) do
+          { database_connector: double("database_connector"),
+            webhook_execution_configuration: webhook_execution_configuration,
+            logging_options: {}
+          }
+        end
+        let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook, webhook: webhook, event_context: {}) }
+        let(:triggered_webhooks) { [triggered_webhook] }
+        let(:webhook_execution_configuration) { double("webhook_execution_configuration", webhook_context: webhook_context) }
+        let(:webhook_context) { { base_url: "http://example.org" } }
+        let(:webhook) do
+          instance_double(PactBroker::Domain::Webhook, description: "description", uuid: "1244")
         end
 
-        context "when a previous pact with a given tag exists and the sha is the same" do
-          let(:previous_pact_version_sha) { pact_version_sha }
-          let(:previous_pacts) { { "dev" => previous_pact } }
+        subject { TriggerService.schedule_webhooks(triggered_webhooks, options) }
+
+        context "when there is a scheduling error", job: true do
+          before do
+            allow(TriggerService).to receive(:logger).and_return(logger)
+          end
+
+          let(:logger) { double("logger").as_null_object }
+
+          before do
+            allow(Job).to receive(:perform_in).and_raise("an error")
+          end
 
-          include_examples "triggering a contract_published event"
-          include_examples "not triggering a contract_content_changed event"
+          it "logs the error" do
+            allow(TriggerService.logger).to receive(:warn)
+            expect(TriggerService.logger).to receive(:warn).with(/Error scheduling/, StandardError)
+            subject
+          end
         end
       end
 
-      describe "#trigger_webhooks_for_updated_pact" do
-        let(:existing_pact) do
-          double('existing_pact',
-            pact_version_sha: existing_pact_version_sha,
-            consumer_version_number: "1.2.3"
+      describe ".test_execution" do
+        let(:webhook) do
+          instance_double(PactBroker::Domain::Webhook,
+            trigger_on_provider_verification_published?: trigger_on_verification,
+            consumer_name: "consumer",
+            provider_name: "provider",
+            execute: result
           )
         end
-        let(:existing_pact_version_sha) { pact_version_sha }
+        let(:pact) { instance_double(PactBroker::Domain::Pact) }
+        let(:verification) { instance_double(PactBroker::Domain::Verification) }
+        let(:trigger_on_verification) { false }
+        let(:result) { double("result") }
+        let(:execution_configuration) do
+          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)
+          allow(PactBroker::Verifications::Service).to receive(:search_for_latest).and_return(verification)
+          allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return("foo")
+          allow(execution_configuration).to receive(:with_failure_log_message).and_return(execution_configuration)
+        end
 
-        subject { TriggerService.trigger_webhooks_for_updated_pact(existing_pact, pact, event_context, webhook_options) }
+        subject { TriggerService.test_execution(webhook, event_context, execution_configuration) }
 
-        context "when the pact version sha of the previous revision is different" do
-          let(:existing_pact_version_sha) { "456" }
+        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")
+          subject
+        end
 
-          include_examples "triggering a contract_published event"
-          include_examples "triggering a contract_content_changed event"
+        it "returns the result" do
+          expect(subject).to be result
+        end
 
-          it "logs the reason why it triggered the contract_content_changed event" do
-            expect(logger).to receive(:info).with(/version 1.2.3 has been updated with new content/)
+        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, event_context.merge(event_name: "test"), execution_configuration_hash)
             subject
           end
         end
 
-        context "when the pact version sha of the previous revision is not different, not sure if we'll even get this far if it hasn't changed, but just in case..." do
-          include_examples "triggering a contract_published event"
-          include_examples "not triggering a contract_content_changed event"
-        end
-      end
+        context "when a pact cannot be found" do
+          let(:pact) { nil }
 
-      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"
-          }
+          it "executes the webhook with a placeholder pact" do
+            expect(webhook).to receive(:execute).with(an_instance_of(PactBroker::Pacts::PlaceholderPact), anything, anything, anything)
+            subject
+          end
         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, event_context, webhook_options) }
 
-        context "when the verification is successful" do
+        context "when the trigger is for a verification publication" do
+          let(:trigger_on_verification) { true }
 
-          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 "searches for the latest matching verification" do
+            expect(PactBroker::Verifications::Service).to receive(:search_for_latest).with("consumer", "provider")
+            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
+          it "executes the webhook with the pact and the verification" do
+            expect(webhook).to receive(:execute).with(pact, verification, event_context.merge(event_name: "test"), execution_configuration_hash)
+            subject
           end
 
-          context "when there are no consumer_version_selectors" do
-            let(:event_context) { { some: "data" } }
+          context "when a verification cannot be found" do
+            let(:verification) { nil }
 
-            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)
+            it "executes the webhook with a placeholder verification" do
+              expect(webhook).to receive(:execute).with(anything, an_instance_of(PactBroker::Verifications::PlaceholderVerification), anything, anything)
               subject
             end
           end
         end
+      end
 
-        context "when the verification is not successful" do
-          let(:success) { false }
+      describe ".trigger_webhooks integration test", job: true do
+        let!(:http_request) do
+          stub_request(:get, "http://example.org").
+            to_return(:status => 200)
+        end
 
-          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
+        let(:events) { [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }] }
+        let(:webhook_execution_configuration) do
+          PactBroker::Webhooks::ExecutionConfiguration.new
+            .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,
+            webhook_execution_configuration: webhook_execution_configuration
+          }
+        end
+        let(:logging_options) { { show_response: true } }
+        let(:database_connector) { ->(&block) { block.call } }
+        let(:pact) do
+          td.create_consumer
+            .create_provider
+            .create_consumer_version
+            .create_pact
+            .create_verification
+            .create_webhook(method: "GET", url: "http://example.org", events: events)
+            .and_return(:pact)
+        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
+        let(:triggered_webhooks) { PactBroker::Webhooks::TriggerService.create_triggered_webhooks_for_event(pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context) }
 
-          context "when there are no consumer_version_selectors" do
-            let(:event_context) { { some: "data" } }
+        subject {  PactBroker::Webhooks::TriggerService.schedule_webhooks(triggered_webhooks, options) }
 
-            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
+        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
+          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).and_call_original
+          subject
+        end
+
+        it "saves the triggered webhook" do
+          expect { subject }.to change { PactBroker::Webhooks::TriggeredWebhook.count }.by(1)
+        end
+
+        it "saves the execution" do
+          expect { subject }.to change { PactBroker::Webhooks::Execution.count }.by(1)
+        end
+
+        it "marks the triggered webhook as a success" do
+          subject
+          expect(TriggeredWebhook.first.status).to eq TriggeredWebhook::STATUS_SUCCESS
         end
       end
     end