pact_broker 2.31.0 → 2.32.0

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

@@ -18,9 +18,16 @@ module PactBroker
           allow(PactBroker::Webhooks::Service).to receive(:trigger_webhooks)
         end
 
+        let(:options) { { webhook_context: {} } }
+        let(:expected_options) { { webhook_context: { provider_version_tags: %w[dev] } } }
         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 }
+        let(:pact) do
+          td.create_pact_with_hierarchy
+            .create_provider_version('4.5.6')
+            .create_provider_version_tag('dev')
+            .and_return(:pact)
+        end
+        let(:create_verification) { subject.create 3, params, pact, options }
 
         it "logs the creation" do
           expect(logger).to receive(:info).with(/.*verification.*3.*success/)
@@ -47,7 +54,12 @@ module PactBroker
 
         it "invokes the webhooks for the verification" do
           verification = create_verification
-          expect(PactBroker::Webhooks::Service).to have_received(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED)
+          expect(PactBroker::Webhooks::Service).to have_received(:trigger_webhooks).with(
+            pact,
+            verification,
+            PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED,
+            expected_options
+          )
         end
       end
 

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

@@ -93,7 +93,7 @@ module PactBroker
             expect(subject.number).to eq version_number
             expect(subject.pacticipant.name).to eq pacticipant_name
             expect(subject.tags.first.name).to eq "prod"
-            expect(subject.order).to eq 0
+            expect(subject.order).to_not be nil
           end
 
           context "when case sensitivity is turned off and names with different cases are used" do

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

@@ -17,8 +17,17 @@ module PactBroker
       let(:success) { true }
       let(:logger) { double('logger').as_null_object }
       let(:database_connector) { ->(&block) { block.call } }
+      let(:webhook_context) { { the: "context" } }
+      let(:job_params) do
+        {
+          triggered_webhook: triggered_webhook,
+          database_connector: database_connector,
+          webhook_context: webhook_context,
+          execution_options: { the: 'options' }
+        }
+      end
 
-      subject { Job.new.perform(triggered_webhook: triggered_webhook, database_connector: database_connector, base_url: base_url) }
+      subject { Job.new.perform(job_params) }
 
       it "reloads the TriggeredWebhook object to make sure it has a fresh copy" do
         expect(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).with(id: 1)
@@ -26,7 +35,6 @@ module PactBroker
       end
 
       context "when the job succeeds" do
-
         it "does not reschedule the job" do
           expect(Job).to_not receive(:perform_in)
           subject
@@ -45,7 +53,16 @@ module PactBroker
         end
 
         it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, {triggered_webhook: triggered_webhook, error_count: 1, database_connector: database_connector, base_url: base_url})
+          expect(Job).to receive(:perform_in).with(10, hash_including(error_count: 1))
+          subject
+        end
+
+        it "reschedules the job with the passed in data" do
+          expect(Job).to receive(:perform_in).with(10, hash_including(
+            webhook_context: webhook_context,
+            database_connector: database_connector,
+            triggered_webhook: triggered_webhook
+          ))
           subject
         end
 
@@ -60,16 +77,19 @@ module PactBroker
         let(:success) { false }
 
         it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, {triggered_webhook: triggered_webhook, error_count: 1, database_connector: database_connector, base_url: base_url})
+          expect(Job).to receive(:perform_in).with(10, hash_including(error_count: 1))
           subject
         end
 
         it "executes the job with an log message indicating that the webhook will be retried" do
           expect(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now)
             .with(triggered_webhook, {
-              failure_log_message: "Retrying webhook in 10 seconds",
-              success_log_message: "Successfully executed webhook",
-              base_url: base_url
+              execution_options: {
+                failure_log_message: "Retrying webhook in 10 seconds",
+                success_log_message: "Successfully executed webhook",
+                the: 'options'
+              },
+              webhook_context: webhook_context
           })
           subject
         end
@@ -84,12 +104,13 @@ module PactBroker
       context "when an error occurs for the second time" do
         before do
           allow(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now).and_raise("an error")
+          job_params[:error_count] = 1
         end
 
-        subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 1, database_connector: database_connector, base_url: base_url) }
+        # subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 1, database_connector: database_connector, base_url: base_url) }
 
         it "reschedules the job in 60 seconds" do
-          expect(Job).to receive(:perform_in).with(60, {triggered_webhook: triggered_webhook, error_count: 2, database_connector: database_connector, base_url: base_url})
+          expect(Job).to receive(:perform_in).with(60, hash_including(error_count: 2))
           subject
         end
 
@@ -102,16 +123,20 @@ module PactBroker
 
       context "when the job is not successful for the last time" do
         let(:success) { false }
+        before do
+          job_params[:error_count] = 6
+        end
 
-        subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 6, database_connector: database_connector, base_url: base_url) }
+        # subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 6, database_connector: database_connector, base_url: base_url) }
 
         it "executes the job with an log message indicating that the webhook has failed" do
           expect(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now)
-            .with(triggered_webhook, {
-              failure_log_message: "Webhook execution failed after 7 attempts",
-              success_log_message: "Successfully executed webhook",
-              base_url: base_url
-          })
+            .with(triggered_webhook, hash_including(
+              execution_options: hash_including(
+                failure_log_message: "Webhook execution failed after 7 attempts",
+                success_log_message: "Successfully executed webhook")
+            )
+          )
           subject
         end
 
@@ -131,6 +156,18 @@ module PactBroker
           subject
         end
       end
+
+      context "when the webhook gets deleted between executions" do
+        before do
+          allow(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).and_return(nil)
+        end
+
+        it "does not reschedule the job" do
+          expect(Job).to_not receive(:perform_in)
+          expect(logger).to receive(:info).with(/Could not find webhook with id: 1/)
+          subject
+        end
+      end
     end
   end
 end

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

@@ -8,7 +8,7 @@ module PactBroker
     describe Render do
       describe "#call" do
         before do
-          allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_url).and_return("http://foo")
+          allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_version_url_with_metadata).and_return("http://foo")
           allow(PactBroker::Api::PactBrokerUrls).to receive(:verification_url) do | verification, base_url |
             expect(verification).to_not be nil
             "http://verification"
@@ -92,11 +92,11 @@ module PactBroker
           [ double("label", name: "foo"), double("label", name: "bar") ]
         end
 
+        let(:webhook_context) { { base_url: base_url } }
+
         let(:nil_pact) { nil }
         let(:nil_verification) { nil }
 
-        subject { Render.call(template, pact, verification, base_url) }
-
         TEST_CASES = [
           ["${pactbroker.pactUrl}", "http://foo", :pact, :verification],
           ["${pactbroker.consumerVersionNumber}", "1.2.3+foo", :pact, :verification],
@@ -124,7 +124,7 @@ module PactBroker
             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, base_url)
+              output = Render.call(template, the_pact, the_verification, webhook_context)
               expect(output).to eq expected_output
             end
           end
@@ -132,7 +132,7 @@ module PactBroker
 
         context "with an escaper" do
           subject do
-            Render.call(template, pact, verification, base_url) do | value |
+            Render.call(template, pact, verification, webhook_context) do | value |
               CGI.escape(value)
             end
           end
@@ -142,6 +142,27 @@ module PactBroker
 
           it { is_expected.to eq "http%3A%2F%2Ffoo" }
         end
+
+        context "with webhook context data passed in" do
+          let(:webhook_context) do
+            {
+              consumer_version_number: "webhook-version-number",
+              consumer_version_tags: %w[webhook tags]
+            }
+          end
+
+          it "uses the consumer_version_number in preference to the field on the domain models" do
+            template = "${pactbroker.consumerVersionNumber}"
+            output = Render.call(template, pact, verification, webhook_context)
+            expect(output).to eq "webhook-version-number"
+          end
+
+          it "uses the consumer_version_tags in preference to the field on the domain models" do
+            template = "${pactbroker.consumerVersionTags}"
+            output = Render.call(template, pact, verification, webhook_context)
+            expect(output).to eq "webhook, tags"
+          end
+        end
       end
 
       describe "#call with placeholder domain objects" do
@@ -150,11 +171,11 @@ module PactBroker
         let(:base_url) { "http://broker" }
 
         it "does not blow up with a placeholder pact" do
-          Render.call("", placeholder_pact, nil, base_url)
+          Render.call("", placeholder_pact, nil, {})
         end
 
         it "does not blow up with a placeholder verification" do
-          Render.call("", placeholder_pact, placeholder_verification, base_url)
+          Render.call("", placeholder_pact, placeholder_verification, {})
         end
       end
     end

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

@@ -196,6 +196,13 @@ module PactBroker
       end
 
       describe "update_by_uuid" do
+        before do
+          td.create_consumer("Foo")
+            .create_provider
+            .create_webhook(old_webhook_params)
+            .create_consumer("Foo2")
+        end
+
         let(:uuid) { '1234' }
         let(:old_webhook_params) do
           {
@@ -209,7 +216,7 @@ module PactBroker
             password: 'password'
           }
         end
-        let(:new_webhook_params) do
+        let(:new_request_webhook_params) do
           {
             method: 'GET',
             url: 'http://example.com',
@@ -217,16 +224,17 @@ module PactBroker
             headers: {'Content-Type' => 'text/plain'}
           }
         end
+        let(:new_request) { PactBroker::Domain::WebhookRequest.new(new_request_webhook_params) }
         let(:new_event) do
           PactBroker::Webhooks::WebhookEvent.new(name: 'something_else')
         end
-        before do
-          td.create_consumer
-            .create_provider
-            .create_webhook(old_webhook_params)
-        end
+        let(:new_consumer) { PactBroker::Domain::Pacticipant.new(name: "Foo2") }
         let(:new_webhook) do
-          PactBroker::Domain::Webhook.new(events: [new_event], request: PactBroker::Domain::WebhookRequest.new(new_webhook_params))
+          PactBroker::Domain::Webhook.new(
+            consumer: new_consumer,
+            events: [new_event],
+            request: new_request
+          )
         end
 
         subject { Repository.new.update_by_uuid(uuid, new_webhook) }
@@ -241,6 +249,7 @@ module PactBroker
           expect(updated_webhook.request.username).to eq nil
           expect(updated_webhook.request.password).to eq nil
           expect(updated_webhook.events.first.name).to eq 'something_else'
+          expect(updated_webhook.consumer.name).to eq "Foo2"
         end
       end
 
@@ -332,7 +341,6 @@ module PactBroker
         subject { Repository.new.find_by_consumer_and_provider_and_event_name td.consumer, td.provider, 'something_happened' }
 
         context "when a webhook exists with a matching consumer and provider and event name" do
-
           before do
             td
               .create_consumer("Consumer")
@@ -347,32 +355,15 @@ module PactBroker
           it "returns an array of webhooks" do
             expect(subject.collect(&:uuid).sort).to eq ['1', '2']
           end
-        end
-      end
-
-      describe "find_for_pact_and_event_name" do
-        context "when a webhook exists with a matching consumer and provider and event name" do
-          before do
-            td
-              .create_consumer("Consumer")
-              .create_consumer_version("1")
-              .create_provider("Another Provider")
-              .create_webhook
-              .create_provider("Provider")
-              .create_pact
-              .create_webhook(uuid: '1', events: [{ name: 'something_happened' }])
-              .create_webhook(uuid: '2', events: [{ name: 'something_happened' }])
-              .create_webhook(uuid: '3', events: [{ name: 'something_else_happened' }])
-              .create_consumer_webhook(uuid: '4', events: [{ name: 'something_happened' }])
-              .create_provider_webhook(uuid: '5', events: [{ name: 'something_happened' }])
-              .create_global_webhook(uuid: '6', events: [{ name: 'something_happened' }])
-              .create_global_webhook(uuid: '7', events: [{ name: 'something_else_happened' }])
-          end
 
-          subject { Repository.new.find_for_pact_and_event_name(td.pact, 'something_happened') }
+          context "when the webhook is not enabled" do
+            before do
+              Webhook.where(uuid: '2').update(enabled: false)
+            end
 
-          it "returns an array of webhooks" do
-            expect(subject.collect(&:uuid).sort).to eq ['1', '2', '4', '5', '6']
+            it "is not returned" do
+              expect(subject.collect(&:uuid).sort).to_not include('2  ')
+            end
           end
         end
       end

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

@@ -33,8 +33,117 @@ module PactBroker
         end
       end
 
-      describe ".trigger_webhooks" do
+      describe ".update_by_uuid" do
+        before do
+          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_uuid).and_return(existing_webhook)
+        end
+
+        let(:request) { PactBroker::Webhooks::WebhookRequestTemplate.new(password: existing_password, headers: headers)}
+        let(:existing_password) { nil }
+        let(:headers) { {} }
+        let(:existing_webhook) { PactBroker::Domain::Webhook.new(request: request) }
+        let(:params) do
+          {
+            'request' => {
+              'url' => "http://url"
+            }
+          }
+        end
+
+        subject { Service.update_by_uuid("1234", params) }
+
+        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 |
+            updated_webhook = webhook
+            true
+          end
+          subject
+          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' }
+
+          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 |
+              updated_webhook = webhook
+              true
+            end
+            subject
+            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(:params) do
+            {
+              '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 |
+              updated_webhook = webhook
+              true
+            end
+            subject
+            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(:params) do
+            {
+              'request' => {
+                'url' => "http://url",
+                'headers' => {
+                  'authorization' => "***********"
+                }
+              }
+            }
+          end
+
+          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 |
+              updated_webhook = webhook
+              true
+            end
+            subject
+            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"
+              }
+            }
+          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 |
+              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') }
@@ -42,6 +151,12 @@ module PactBroker
         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(:options) do
+          { database_connector: double('database_connector'),
+            webhook_context: {},
+            execution_options: {}
+          }
+        end
 
         before do
           allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_or_provider_and_event_name).and_return(webhooks)
@@ -49,7 +164,7 @@ module PactBroker
           allow(Job).to receive(:perform_in)
         end
 
-        subject { Service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        subject { Service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, 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)
@@ -58,7 +173,7 @@ module PactBroker
 
         context "when webhooks are found" do
           it "executes the webhook" do
-            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED)
+            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options)
             subject
           end
         end
@@ -71,7 +186,7 @@ module PactBroker
           end
 
           it "logs that no webhook was found" do
-            expect(logger).to receive(:debug).with(/No webhook found/)
+            expect(logger).to receive(:debug).with(/No enabled webhooks found/)
             subject
           end
         end
@@ -104,9 +219,13 @@ module PactBroker
         let(:result) { double('result') }
         let(:options) do
           {
-            failure_log_message: "Webhook execution failed",
-            show_response: 'foo',
-            base_url: 'http://broker'
+            execution_options: {
+              failure_log_message: "Webhook execution failed",
+              show_response: 'foo',
+            },
+            webhook_context: {
+              base_url: 'http://broker'
+            }
           }
         end
 
@@ -114,10 +233,9 @@ module PactBroker
           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(Service).to receive(:base_url).and_return("http://broker")
         end
 
-        subject { Service.test_execution(webhook) }
+        subject { Service.test_execution(webhook, options) }
 
         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')
@@ -168,54 +286,54 @@ module PactBroker
         end
       end
 
-      describe ".execute_webhook_now integration test", job: true do
-        let(:td) { TestDataBuilder.new }
-
-        let!(:http_request) do
-          stub_request(:get, "http://example.org").
-            to_return(:status => 200)
-        end
-
-        let!(:pact) do
-          td.create_consumer
-            .create_provider
-            .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, td.verification }
-
-        it "executes the HTTP request of the webhook" do
-          subject
-          expect(http_request).to have_been_made
-        end
-
-        it "saves the triggered webhook" do
-          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
-
-        it "marks the triggered webhook as a success" do
-          subject
-          expect(TriggeredWebhook.first.status).to eq TriggeredWebhook::STATUS_SUCCESS
-        end
-      end
+      # describe ".execute_webhook_now integration test", job: true do
+      #   let(:td) { TestDataBuilder.new }
+
+      #   let!(:http_request) do
+      #     stub_request(:get, "http://example.org").
+      #       to_return(:status => 200)
+      #   end
+
+      #   let!(:pact) do
+      #     td.create_consumer
+      #       .create_provider
+      #       .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, td.verification }
+
+      #   it "executes the HTTP request of the webhook" do
+      #     subject
+      #     expect(http_request).to have_been_made
+      #   end
+
+      #   it "saves the triggered webhook" do
+      #     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
+
+      #   it "marks the triggered webhook as a success" do
+      #     subject
+      #     expect(TriggeredWebhook.first.status).to eq TriggeredWebhook::STATUS_SUCCESS
+      #   end
+      # end
 
       describe ".trigger_webhooks integration test", job: true do
         let!(:http_request) do
@@ -224,7 +342,15 @@ module PactBroker
         end
 
         let(:events) { [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }] }
-
+        let(:options) do
+          {
+            database_connector: database_connector,
+            webhook_context: { base_url: 'http://example.org' },
+            execution_options: execution_options
+          }
+        end
+        let(:execution_options) { { show_response: true } }
+        let(:database_connector) { ->(&block) { block.call } }
         let(:pact) do
           td.create_consumer
             .create_provider
@@ -235,7 +361,7 @@ module PactBroker
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.trigger_webhooks pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        subject { PactBroker::Webhooks::Service.trigger_webhooks pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options }
 
         it "executes the HTTP request of the webhook" do
           subject
@@ -243,9 +369,7 @@ module PactBroker
         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(hash_including(expected_options)).and_call_original
+          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).with(hash_including(execution_options)).and_call_original
           subject
         end