pact_broker 2.77.0 → 2.80.0

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

@@ -1,14 +1,14 @@
-require 'pact_broker/versions/abbreviate_number'
+require "pact_broker/versions/abbreviate_number"
 
 module PactBroker
   module Versions
     describe AbbreviateNumber do
       describe "#call" do
         TEST_CASES = [
-          ['202326572516dea6998a7f311fcaa161c0768fc2', '2023265'],
-          ['1.2.3+areallyreallyreallylongexplanation', '1.2.3+areallyreallyreallylongexplanation'],
-          ['2516dea6998a7f', '2516dea6998a7f'],
-          ['1.2.3+202326572516dea6998a7f311fcaa161c0768fc2', '1.2.3+2023265']
+          ["202326572516dea6998a7f311fcaa161c0768fc2", "2023265"],
+          ["1.2.3+areallyreallyreallylongexplanation", "1.2.3+areallyreallyreallylongexplanation"],
+          ["2516dea6998a7f", "2516dea6998a7f"],
+          ["1.2.3+202326572516dea6998a7f311fcaa161c0768fc2", "1.2.3+2023265"]
         ]
 
         TEST_CASES.each do |(input, output)|

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

@@ -1,5 +1,5 @@
-require 'spec_helper'
-require 'pact_broker/versions/parse_semantic_version'
+require "spec_helper"
+require "pact_broker/versions/parse_semantic_version"
 
 module PactBroker
   module Versions

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

@@ -1,5 +1,5 @@
-require 'spec_helper'
-require 'pact_broker/versions/repository'
+require "spec_helper"
+require "pact_broker/versions/repository"
 
 module PactBroker
   module Versions
@@ -123,7 +123,7 @@ module PactBroker
         end
       end
 
-      describe "#create_or_update" do
+      describe "#create_or_overwrite" do
         before do
           td.subtract_day
             .create_consumer("Foo")
@@ -133,9 +133,10 @@ module PactBroker
 
         let(:pacticipant) { td.and_return(:consumer) }
         let(:version_number) { "1234" }
-        let(:version) { PactBroker::Domain::Version.new(branch: "new-branch") }
+        let(:tags) { nil }
+        let(:open_struct_version) { OpenStruct.new(branch: "new-branch", tags: tags) }
 
-        subject { Repository.new.create_or_update(pacticipant, version_number, version) }
+        subject { Repository.new.create_or_overwrite(pacticipant, version_number, open_struct_version) }
 
         it "overwrites the values" do
           expect(subject.branch).to eq "new-branch"
@@ -146,6 +147,15 @@ module PactBroker
           expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
         end
 
+        context "when there are tags specified" do
+          let(:tags) { [ OpenStruct.new(name: "main")] }
+
+          it "overwrites the tags" do
+            expect(subject.tags.count).to eq 1
+            expect(subject.tags.first.name).to eq "main"
+          end
+        end
+
         it "does not change the created date" do
           expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").created_at }
         end
@@ -159,7 +169,7 @@ module PactBroker
         end
 
         context "when the version does not already exist" do
-          let(:version) { PactBroker::Domain::Version.new(number: "555", branch: "new-branch") }
+          let(:version) { OpenStruct.new(number: "555", branch: "new-branch") }
 
           it "sets the order" do
             expect(subject.order).to_not be nil

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

@@ -1,4 +1,4 @@
-require 'pact_broker/versions/service'
+require "pact_broker/versions/service"
 
 module PactBroker
 

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

@@ -1,4 +1,4 @@
-require 'pact_broker/webhooks/check_host_whitelist'
+require "pact_broker/webhooks/check_host_whitelist"
 
 module PactBroker
   module Webhooks

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

@@ -1,4 +1,4 @@
-require 'pact_broker/webhooks/execution_configuration'
+require "pact_broker/webhooks/execution_configuration"
 
 module PactBroker
   module Webhooks

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

@@ -1,12 +1,12 @@
-require 'pact_broker/webhooks/job'
-require 'pact_broker/webhooks/execution_configuration'
+require "pact_broker/webhooks/job"
+require "pact_broker/webhooks/execution_configuration"
 
 module PactBroker
   module Webhooks
     describe Job do
       before do
         PactBroker.configuration.webhook_retry_schedule = [10, 60, 120, 300, 600, 1200]
-        allow(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now).and_return(result)
+        allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_return(result)
         allow(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
         allow(PactBroker::Webhooks::TriggeredWebhook).to receive(:find).and_return(triggered_webhook)
         allow(Job).to receive(:logger).and_return(logger)
@@ -15,12 +15,12 @@ module PactBroker
       end
 
       let(:base_url) { "http://broker" }
-      let(:triggered_webhook) { instance_double("PactBroker::Webhooks::TriggeredWebhook", webhook_uuid: '1234', id: 1) }
+      let(:triggered_webhook) { instance_double("PactBroker::Webhooks::TriggeredWebhook", webhook_uuid: "1234", id: 1) }
       let(:result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: success) }
       let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration, to_hash: webhook_execution_configuration_hash) }
-      let(:webhook_execution_configuration_hash) { { the: 'options' } }
+      let(:webhook_execution_configuration_hash) { { the: "options" } }
       let(:success) { true }
-      let(:logger) { double('logger').as_null_object }
+      let(:logger) { double("logger").as_null_object }
       let(:database_connector) { ->(&block) { block.call } }
       let(:webhook_context) { { the: "context" } }
       let(:job_params) do
@@ -53,7 +53,7 @@ module PactBroker
 
       context "when an error occurs for the first time" do
         before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now).and_raise(error)
+          allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_raise(error)
         end
 
         let(:error) { "an error" }
@@ -107,7 +107,7 @@ module PactBroker
         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)
+          expect(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now)
             .with(triggered_webhook, webhook_execution_configuration_hash)
           subject
         end
@@ -121,7 +121,7 @@ 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")
+          allow(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now).and_raise("an error")
           job_params[:error_count] = 1
         end
 
@@ -150,7 +150,7 @@ module PactBroker
           expect(webhook_execution_configuration).to receive(:with_failure_log_message).with("Webhook execution failed after 7 attempts")
           expect(webhook_execution_configuration).to receive(:with_success_log_message).with("Successfully executed webhook")
 
-          expect(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now)
+          expect(PactBroker::Webhooks::TriggerService).to receive(:execute_triggered_webhook_now)
             .with(triggered_webhook, webhook_execution_configuration_hash)
           subject
         end

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

@@ -0,0 +1,16 @@
+require "pact_broker/webhooks/pact_and_verification_parameters"
+require "pact_broker/messages"
+
+module PactBroker
+  module Webhooks
+    describe PactAndVerificationParameters do
+      PactAndVerificationParameters::ALL.each do | parameter |
+        describe parameter do
+          it "has a description in lib/pact_broker/locale/en.yml" do
+            expect(PactBroker::Messages.message("messages.webhooks.parameters.#{parameter}", default: nil)).to_not be_nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'pact_broker/webhooks/redact_logs'
+require "pact_broker/webhooks/redact_logs"
 
 module PactBroker
   module Webhooks

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

@@ -1,9 +1,9 @@
-require 'pact_broker/webhooks/render'
-require 'pact_broker/pacts/placeholder_pact'
-require 'pact_broker/verifications/placeholder_verification'
-require 'pact_broker/webhooks/pact_and_verification_parameters'
+require "pact_broker/webhooks/render"
+require "pact_broker/pacts/placeholder_pact"
+require "pact_broker/verifications/placeholder_verification"
+require "pact_broker/webhooks/pact_and_verification_parameters"
 
-require 'cgi'
+require "cgi"
 
 module PactBroker
   module Webhooks
@@ -11,7 +11,7 @@ module PactBroker
       describe "#call" do
         before do
           allow(PactBroker::Api::PactBrokerUrls).to receive(:pact_version_url_with_webhook_metadata).and_return("http://foo")
-          allow(PactBroker::Api::PactBrokerUrls).to receive(:verification_url) do | verification, base_url |
+          allow(PactBroker::Api::PactBrokerUrls).to receive(:verification_url) do | verification, _base_url |
             expect(verification).to_not be nil
             "http://verification"
           end
@@ -54,11 +54,11 @@ module PactBroker
             latest_verification: failed_verification)
         end
 
-        let (:provider) do
+        let(:provider) do
           double("provider", labels: provider_labels)
         end
 
-        let (:consumer) do
+        let(:consumer) do
           double("consumer", labels: consumer_labels)
         end
 
@@ -71,11 +71,11 @@ module PactBroker
         end
 
         let(:provider_version) do
-          double("version", tags: provider_tags)
+          double("version", tags: provider_tags, branch: "provider-branch")
         end
 
         let(:consumer_version) do
-          double("version", tags: consumer_tags)
+          double("version", tags: consumer_tags, branch: "consumer-branch")
         end
 
         let(:provider_tags) do
@@ -118,11 +118,20 @@ module PactBroker
           ["${pactbroker.bitbucketVerificationStatus}", "INPROGRESS", :pact_with_no_verification, :nil_verification],
           ["${pactbroker.bitbucketVerificationStatus}", "SUCCESSFUL", :pact_with_successful_verification, :nil_verification],
           ["${pactbroker.bitbucketVerificationStatus}", "FAILED", :pact_with_failed_verification, :nil_verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "succeeded", :pact, :verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "failed", :pact, :failed_verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "pending", :nil_pact, :nil_verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "pending", :pact_with_no_verification, :nil_verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "succeeded", :pact_with_successful_verification, :nil_verification],
+          ["${pactbroker.azureDevOpsVerificationStatus}", "failed", :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.providerVersionBranch}", "provider-branch", :pact_with_successful_verification, :verification],
+          ["${pactbroker.providerVersionBranch}", "", :pact_with_no_verification, :nil_verification],
           ["${pactbroker.consumerVersionTags}", "test", :pact_with_successful_verification, :verification],
+          ["${pactbroker.consumerVersionBranch}", "consumer-branch", :pact_with_successful_verification, :verification],
           ["${pactbroker.consumerLabels}", "foo, bar", :pact_with_successful_verification, :verification],
           ["${pactbroker.providerLabels}", "finance, IT", :pact, :nil_verification],
         ]

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

@@ -1,29 +1,29 @@
-require 'spec_helper'
-require 'pact_broker/webhooks/repository'
+require "spec_helper"
+require "pact_broker/webhooks/repository"
 
 module PactBroker
   module Webhooks
     describe Repository do
-      let(:url) { 'http://example.org' }
-      let(:body) { {'some' => 'json' } }
-      let(:headers) { {'Content-Type' => 'application/json', 'Accept' => 'application/json'} }
+      let(:url) { "http://example.org" }
+      let(:body) { {"some" => "json" } }
+      let(:headers) { {"Content-Type" => "application/json", "Accept" => "application/json"} }
       let(:request) do
         Webhooks::WebhookRequestTemplate.new(
-          method: 'post',
+          method: "post",
           url: url,
           headers: headers,
-          username: 'username',
-          password: 'password',
+          username: "username",
+          password: "password",
           body: body)
       end
       let(:event) do
-        PactBroker::Webhooks::WebhookEvent.new(name: 'something_happened')
+        PactBroker::Webhooks::WebhookEvent.new(name: "something_happened")
       end
       let(:events) { [event]}
       let(:webhook) { Domain::Webhook.new(request: request, events: events) }
-      let(:consumer) { td.create_pacticipant('Consumer').and_return(:pacticipant) }
-      let(:provider) { td.create_pacticipant('Provider').and_return(:pacticipant) }
-      let(:uuid) { 'the-uuid' }
+      let(:consumer) { td.create_pacticipant("Consumer").and_return(:pacticipant) }
+      let(:provider) { td.create_pacticipant("Provider").and_return(:pacticipant) }
+      let(:uuid) { "the-uuid" }
       let(:created_webhook_record) { ::DB::PACT_BROKER_DB[:webhooks].order(:id).last }
       let(:created_events) { ::DB::PACT_BROKER_DB[:webhook_events].where(webhook_id: created_webhook_record[:id]).order(:name).all }
       let(:expected_webhook_record) do
@@ -31,7 +31,7 @@ module PactBroker
           uuid: "the-uuid",
           method: "post",
           url: "http://example.org",
-          username: 'username',
+          username: "username",
           password:  "cGFzc3dvcmQ=",
           body: body.to_json,
           consumer_id:  consumer.id,
@@ -71,47 +71,109 @@ module PactBroker
       describe "delete_by_uuid" do
         before do
           Repository.new.create uuid, webhook, consumer, provider
-          Repository.new.create 'another-uuid', webhook, consumer, provider
+          Repository.new.create "another-uuid", webhook, consumer, provider
         end
 
         subject { Repository.new.delete_by_uuid(uuid) }
 
         it "deletes the webhook" do
-          expect { subject }.to change {
-            ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
-            }.by(-1)
+          expect { subject }.to change { ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count }.by(-1)
         end
       end
 
       describe "delete_by_pacticipant" do
-
         before do
-          allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid, 'another-uuid')
-          Repository.new.create(uuid, webhook, consumer, provider)
+          td.create_consumer("other-consumer")
+            .create_provider("other-provider")
+            .create_consumer_version
+            .create_pact
+            .create_webhook(uuid: "other-uuid")
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_consumer("foo")
+            .create_provider("bar")
+            .create_consumer_version
+            .create_pact
+            .create_webhook(uuid: "1234")
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_webhook(uuid: "5555")
+            .create_triggered_webhook
+            .create_webhook_execution
+          # simulate resource already deleted
+          Webhook.where(uuid: "5555").delete
         end
 
         context "when the pacticipant is the consumer" do
 
-          subject { Repository.new.delete_by_pacticipant consumer }
+          subject { Repository.new.delete_by_pacticipant td.consumer }
 
-          it "deletes the webhook" do
-            expect { subject }.to change {
-              ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
-              }.by(-1)
+          it "deletes the matching webhook" do
+            expect { subject }.to change { Webhook.where(uuid: "1234").count }.by(-1)
+          end
+
+          it "does not delete the unmatching webhooks" do
+            expect { subject }.to change { Webhook.count }.by(-1)
+          end
+
+          it "deletes the triggered webhooks" do
+            expect { subject }.to change { TriggeredWebhook.count }.by(-2)
           end
         end
 
         context "when the pacticipant is the provider" do
+          subject { Repository.new.delete_by_pacticipant(td.provider) }
 
-          subject { Repository.new.delete_by_pacticipant provider }
+          it "deletes the matching webhooks" do
+            expect { subject }.to change { Webhook.where(uuid: "1234").count }.by(-1)
+          end
 
-          it "deletes the webhook" do
-            expect { subject }.to change {
-              ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
-              }.by(-1)
+          it "does not delete the unmatching webhooks" do
+            expect { subject }.to change { Webhook.count }.by(-1)
+          end
+
+          it "deletes the triggered webhooks" do
+            expect { subject }.to change { TriggeredWebhook.count }.by(-2)
           end
         end
+      end
 
+      describe "delete_by_consumer_and_provider" do
+        before do
+          td.create_consumer("foo")
+            .create_provider("other-provider")
+            .create_consumer_version
+            .create_pact
+            .create_webhook(uuid: "other-uuid")
+            .comment("kept because doesn't match provider")
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_provider("bar")
+            .create_consumer_version
+            .create_pact
+            .create_webhook(uuid: "1234")
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_webhook(uuid: "5555")
+            .create_triggered_webhook
+            .create_webhook_execution
+          # simulate resource already deleted
+          Webhook.where(uuid: "5555").delete
+        end
+
+        subject { Repository.new.delete_by_consumer_and_provider(td.consumer, td.provider) }
+
+        it "deletes the webhooks that match both consumer and provider" do
+          expect { subject }.to change { Webhook.where(uuid: "1234").count }.by(-1)
+        end
+
+        it "does not delete the unmatching webhooks" do
+          expect { subject }.to change { Webhook.count }.by(-1)
+        end
+
+        it "deletes the triggered webhooks" do
+          expect { subject }.to change { TriggeredWebhook.count }.by(-2)
+        end
       end
 
       describe "find_by_uuid" do
@@ -145,11 +207,11 @@ module PactBroker
           end
 
           it "returns a webhook with the username set" do
-            expect(subject.request.username).to eq 'username'
+            expect(subject.request.username).to eq "username"
           end
 
           it "returns a webhook with the password set" do
-            expect(subject.request.password).to eq 'password'
+            expect(subject.request.password).to eq "password"
           end
 
           it "returns a webhook with the url set" do
@@ -199,30 +261,30 @@ module PactBroker
             .create_consumer("Foo2")
         end
 
-        let(:uuid) { '1234' }
+        let(:uuid) { "1234" }
         let(:old_webhook_params) do
           {
-            events: [{ name: 'something' }],
+            events: [{ name: "something" }],
             uuid: uuid,
-            method: 'POST',
-            url: 'http://example.org',
+            method: "POST",
+            url: "http://example.org",
             body: '{"foo":1}',
-            headers: {'Content-Type' => 'application/json'},
-            username: 'username',
-            password: 'password'
+            headers: {"Content-Type" => "application/json"},
+            username: "username",
+            password: "password"
           }
         end
         let(:new_request_webhook_params) do
           {
-            method: 'GET',
-            url: 'http://example.com',
-            body: 'foo',
-            headers: {'Content-Type' => 'text/plain'}
+            method: "GET",
+            url: "http://example.com",
+            body: "foo",
+            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')
+          PactBroker::Webhooks::WebhookEvent.new(name: "something_else")
         end
         let(:new_consumer) { PactBroker::Domain::Pacticipant.new(name: "Foo2") }
         let(:new_webhook) do
@@ -237,13 +299,13 @@ module PactBroker
 
         it "updates the webhook" do
           expect(subject.uuid).to eq uuid
-          expect(subject.request.method).to eq 'GET'
-          expect(subject.request.url).to eq 'http://example.com'
-          expect(subject.request.body).to eq 'foo'
-          expect(subject.request.headers).to eq 'Content-Type' => 'text/plain'
+          expect(subject.request.method).to eq "GET"
+          expect(subject.request.url).to eq "http://example.com"
+          expect(subject.request.body).to eq "foo"
+          expect(subject.request.headers).to eq "Content-Type" => "text/plain"
           expect(subject.request.username).to eq nil
           expect(subject.request.password).to eq nil
-          expect(subject.events.first.name).to eq 'something_else'
+          expect(subject.events.first.name).to eq "something_else"
           expect(subject.consumer.name).to eq "Foo2"
         end
 
@@ -263,8 +325,9 @@ module PactBroker
 
       describe "find_all" do
         before do
+          allow(PactBroker).to receive(:policy_scope!).and_call_original
           Repository.new.create uuid, webhook, consumer, provider
-          Repository.new.create 'some-other-uuid', webhook, consumer, provider
+          Repository.new.create "some-other-uuid", webhook, consumer, provider
         end
 
         subject { Repository.new.find_all }
@@ -273,6 +336,11 @@ module PactBroker
           expect(subject.size).to be 2
           expect(subject.first).to be_instance_of Domain::Webhook
         end
+
+        it "uses the policy" do
+          expect(PactBroker).to receive(:policy_scope!)
+          subject
+        end
       end
 
       describe "find_by_consumer_and_provider" do
@@ -345,35 +413,58 @@ module PactBroker
         end
       end
 
-      describe "find_by_consumer_and_provider_and_event_name" do
-        subject { Repository.new.find_by_consumer_and_provider_and_event_name td.consumer, td.provider, 'something_happened' }
+      describe "find_webhooks_to_trigger" do
+        before do
+          allow(PactBroker).to receive(:policy_scope!).and_call_original
+        end
+
+        let(:enabled) { true }
+
+        subject { Repository.new.find_webhooks_to_trigger(consumer: td.consumer, provider: td.provider, event_name: "contract_published") }
 
-        context "when a webhook exists with a matching consumer and provider and event name" do
+        it "does not use a policy" do
+          td.create_webhook(event_names: ["contract_published"], enabled: enabled)
+            .create_consumer("Foo")
+            .create_provider("Bar")
+          expect(PactBroker).to_not receive(:policy_scope!)
+          expect(subject.size).to eq 1
+        end
+
+        context "when the webhook is disabled" do
           before do
-            td
-              .create_consumer("Consumer")
-              .create_provider("Another Provider")
-              .create_webhook
-              .create_provider("Provider")
-              .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' }])
+            td.create_webhook(event_names: ["contract_published"], enabled: enabled)
+              .create_consumer("Foo")
+              .create_provider("Bar")
           end
+          let(:enabled) { false }
+          its(:size) { is_expected.to eq 0 }
+        end
 
-          it "returns an array of webhooks" do
-            expect(subject.collect(&:uuid).sort).to eq ['1', '2']
+        context "when the webhook is specified for a consumer and all providers" do
+          before do
+            td.create_consumer("Foo1")
+              .create_provider("Bar1")
+              .create_webhook(provider: nil, event_names: ["contract_published"])
           end
 
-          context "when the webhook is not enabled" do
-            before do
-              Webhook.where(uuid: '2').update(enabled: false)
-            end
+          its(:size) { is_expected.to eq 1 }
 
-            it "is not returned" do
-              expect(subject.collect(&:uuid).sort).to_not include('2  ')
-            end
+          it "returns the right webhook" do
+            expect(subject.first.consumer).to eq td.consumer
+            expect(subject.first.provider).to be nil
           end
         end
+
+        context "when the webhook is specified for matching consumer but not provider" do
+          before do
+            td.create_consumer("Foo1")
+              .create_provider("Bar1")
+              .create_webhook(event_names: ["contract_published"])
+              .create_provider("Bar3")
+          end
+
+          its(:size) { is_expected.to eq 0 }
+        end
       end
 
       describe "create_triggered_webhook" do
@@ -386,18 +477,18 @@ module PactBroker
             .create_verification
         end
 
-        let(:event_context) { { 'some' => 'info' } }
+        let(:event_context) { { "some" => "info" } }
 
-        subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, td.verification, 'publication', 'some_event', event_context }
+        subject { Repository.new.create_triggered_webhook "1234", td.webhook, td.pact, td.verification, "publication", "some_event", event_context }
 
         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'
-          expect(subject.event_name).to eq 'some_event'
+          expect(subject.uuid).to eq "1234"
+          expect(subject.trigger_type).to eq "publication"
+          expect(subject.event_name).to eq "some_event"
           expect(subject.event_context).to eq event_context
         end
 
@@ -422,7 +513,7 @@ module PactBroker
         end
 
         context "without a verification" do
-          subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, nil, 'publication', 'some_event', {} }
+          subject { Repository.new.create_triggered_webhook "1234", td.webhook, td.pact, nil, "publication", "some_event", {} }
 
           it "does not set the verification" do
             expect(subject.verification).to be nil
@@ -464,7 +555,7 @@ module PactBroker
             allow(repository).to receive(:logger).and_return(logger)
           end
 
-          let(:logger) { double('logger') }
+          let(:logger) { double("logger") }
 
           it "just logs the error" do
             expect(logger).to receive(:info).with(/triggered webhook with id #{td.triggered_webhook.id}/)
@@ -473,73 +564,6 @@ module PactBroker
         end
       end
 
-      describe "delete_triggered_webhooks_by_webhook_uuid" do
-        before do
-          td.create_consumer
-            .create_provider
-            .create_consumer_version
-            .create_pact
-            .create_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-            .create_webhook
-            .create_triggered_webhook
-            .create_webhook_execution
-        end
-        let(:webhook_id) { Webhook.find(uuid: td.webhook.uuid).id }
-
-        subject { Repository.new.delete_triggered_webhooks_by_webhook_uuid td.webhook.uuid }
-
-        it "deletes the related triggered webhooks" do
-          expect { subject }.to change {
-              TriggeredWebhook.where(id: td.triggered_webhook.id).count
-            }.from(1).to(0)
-        end
-
-        it "does not delete the unrelated triggered webhooks" do
-          expect { subject }.to_not change {
-              TriggeredWebhook.exclude(id: td.triggered_webhook.id).count
-            }
-        end
-
-        it "deletes the related webhook executions" do
-          expect { subject }.to change {
-              Execution.count
-            }.by(-1)
-        end
-      end
-
-      describe "delete_executions_by_pacticipant" do
-        before do
-          td.create_consumer
-            .create_provider
-            .create_webhook
-            .create_consumer_version
-            .create_pact
-            .create_triggered_webhook
-            .create_webhook_execution
-          # Replicate the old way of doing it
-        end
-
-        context "with triggered webhooks" do
-          it "deletes the execution by consumer" do
-            expect { Repository.new.delete_executions_by_pacticipant td.consumer }
-              .to change { Execution.count }.by(-1)
-          end
-
-          it "deletes the execution by provider" do
-            expect { Repository.new.delete_executions_by_pacticipant td.provider }
-              .to change { Execution.count }.by(-1)
-          end
-
-          it "does not delete executions for non related pacticipants" do
-            another_consumer = td.create_consumer.and_return(:consumer)
-            expect { Repository.new.delete_executions_by_pacticipant another_consumer }
-              .to change { Execution.count }.by(0)
-          end
-        end
-      end
-
       describe "find_latest_triggered_webhooks" do
         before do
           td
@@ -548,52 +572,54 @@ module PactBroker
             .create_triggered_webhook
             .create_webhook_execution
             .create_pact_with_hierarchy
-            .create_webhook(uuid: '123')
-            .create_triggered_webhook(trigger_uuid: '256', created_at: DateTime.new(2016))
+            .create_webhook(uuid: "123")
+            .create_triggered_webhook(uuid: "256", created_at: DateTime.new(2016))
             .create_webhook_execution
-            .create_triggered_webhook(trigger_uuid: '332', created_at: DateTime.new(2017))
+            .create_triggered_webhook(uuid: "332", created_at: DateTime.new(2017))
             .create_webhook_execution
-            .create_webhook(uuid: '987')
-            .create_triggered_webhook(trigger_uuid: '876', created_at: DateTime.new(2017))
+            .create_webhook(uuid: "987")
+            .create_triggered_webhook(uuid: "876", created_at: DateTime.new(2017))
             .create_webhook_execution
-            .create_triggered_webhook(trigger_uuid: '638', created_at: DateTime.new(2018))
+            .create_triggered_webhook(uuid: "638", created_at: DateTime.new(2018))
             .create_webhook_execution
         end
 
         subject { Repository.new.find_latest_triggered_webhooks(td.consumer, td.provider) }
 
         it "finds the latest triggered webhooks" do
-          expect(subject.collect(&:trigger_uuid).sort).to eq ['332', '638']
+          expect(subject.collect(&:uuid).sort).to eq ["332", "638"]
         end
 
         context "when a webhook has been triggered by different events" do
           before do
             td.create_pact_with_hierarchy("Foo2", "1.0.0", "Bar2")
               .create_webhook
-              .create_triggered_webhook(trigger_uuid: '333', event_name: 'foo')
-              .create_triggered_webhook(trigger_uuid: '555', event_name: 'foo')
+              .create_triggered_webhook(uuid: "333", event_name: "foo")
+              .create_triggered_webhook(uuid: "555", event_name: "foo")
               .create_webhook_execution
-              .create_triggered_webhook(trigger_uuid: '444', event_name: 'bar')
-              .create_triggered_webhook(trigger_uuid: '777', event_name: 'bar')
+              .create_triggered_webhook(uuid: "444", event_name: "bar")
+              .create_triggered_webhook(uuid: "777", event_name: "bar")
               .create_webhook_execution
-              .create_triggered_webhook(trigger_uuid: '111', event_name: nil)
-              .create_triggered_webhook(trigger_uuid: '888', event_name: nil)
+              .create_triggered_webhook(uuid: "111", event_name: nil)
+              .create_triggered_webhook(uuid: "888", event_name: nil)
               .create_webhook_execution
           end
 
           it "returns one for each event" do
-            expect(subject.collect(&:trigger_uuid).sort).to eq ['555', '777', '888']
+            # ignoring the ones with nil event_names because they're old data, and shouldn't be
+            # considered as a separate "group"
+            expect(subject.collect(&:uuid).sort).to eq ["555", "777"]
           end
         end
 
         context "when there are two 'latest' triggered webhooks at the same time" do
           before do
-            td.create_triggered_webhook(trigger_uuid: '888', created_at: DateTime.new(2018))
+            td.create_triggered_webhook(uuid: "888", created_at: DateTime.new(2018))
               .create_webhook_execution
           end
 
           it "returns the one with the bigger ID" do
-            expect(subject.collect(&:trigger_uuid).sort).to eq ['332', '888']
+            expect(subject.collect(&:uuid).sort).to eq ["332", "888"]
           end
         end
 
@@ -618,26 +644,26 @@ module PactBroker
             .create_webhook_execution
             .create_pact_with_hierarchy
             .create_webhook
-            .create_triggered_webhook(trigger_uuid: '256', created_at: DateTime.new(2016))
+            .create_triggered_webhook(uuid: "256", created_at: DateTime.new(2016))
             .create_webhook_execution
-            .create_triggered_webhook(trigger_uuid: '332', created_at: DateTime.new(2017))
+            .create_triggered_webhook(uuid: "332", created_at: DateTime.new(2017))
             .create_webhook_execution
-            .create_provider_webhook(uuid: '987')
-            .create_triggered_webhook(trigger_uuid: '876', created_at: DateTime.new(2017))
+            .create_provider_webhook(uuidd: "987")
+            .create_triggered_webhook(uuid: "876", created_at: DateTime.new(2017))
             .create_webhook_execution
-            .create_triggered_webhook(trigger_uuid: '638', created_at: DateTime.new(2018))
+            .create_triggered_webhook(uuid: "638", created_at: DateTime.new(2018))
             .create_webhook_execution
             .create_consumer_webhook
-            .create_triggered_webhook(trigger_uuid: '555', created_at: DateTime.new(2017))
+            .create_triggered_webhook(uuid: "555", created_at: DateTime.new(2017))
             .create_webhook_execution
-            .create_triggered_webhook(trigger_uuid: '777', created_at: DateTime.new(2018))
+            .create_triggered_webhook(uuid: "777", created_at: DateTime.new(2018))
             .create_webhook_execution
         end
 
         subject { Repository.new.find_latest_triggered_webhooks_for_pact(td.pact) }
 
         it "finds the latest triggered webhooks" do
-          expect(subject.collect(&:trigger_uuid).sort).to eq ['332', '638', '777']
+          expect(subject.collect(&:uuid).sort).to eq ["332", "638", "777"]
         end
       end
 
@@ -646,18 +672,18 @@ module PactBroker
           td
             .create_pact_with_hierarchy("Foo", "1", "Bar")
             .create_webhook
-            .create_triggered_webhook(trigger_uuid: "1")
+            .create_triggered_webhook(uuid: "1")
             .create_webhook_execution
             .create_consumer_version("2")
             .create_pact
-            .create_triggered_webhook(trigger_uuid: "2")
+            .create_triggered_webhook(uuid: "2")
             .create_webhook_execution
         end
 
         subject { Repository.new.find_triggered_webhooks_for_pact(td.pact) }
 
         it "finds the triggered webhooks" do
-          expect(subject.collect(&:trigger_uuid).sort).to eq ["2"]
+          expect(subject.collect(&:uuid).sort).to eq ["2"]
         end
       end
 
@@ -667,15 +693,15 @@ module PactBroker
             .create_pact_with_hierarchy("Foo", "1", "Bar")
             .create_verification_webhook
             .create_verification(provider_version: "1")
-            .create_triggered_webhook(trigger_uuid: "1")
+            .create_triggered_webhook(uuid: "1")
             .create_verification(provider_version: "2", number: 2)
-            .create_triggered_webhook(trigger_uuid: "2")
+            .create_triggered_webhook(uuid: "2")
         end
 
         subject { Repository.new.find_triggered_webhooks_for_verification(td.verification) }
 
         it "finds the triggered webhooks" do
-          expect(subject.collect(&:trigger_uuid).sort).to eq ["2"]
+          expect(subject.collect(&:uuid).sort).to eq ["2"]
         end
       end
 
@@ -739,7 +765,7 @@ module PactBroker
           end
 
           it "deletes the webhooks belonging to the consumer version" do
-            expect { subject }.to change{ TriggeredWebhook.count }.by (-1)
+            expect { subject }.to change{ TriggeredWebhook.count }.by(-1)
           end
         end
 
@@ -748,14 +774,14 @@ module PactBroker
             td
               .create_pact_with_hierarchy
               .create_verification(provider_version: "1")
-              .create_provider_webhook(event_names: ['provider_verification_published'])
+              .create_provider_webhook(event_names: ["provider_verification_published"])
               .create_triggered_webhook
               .create_webhook_execution
               .and_return(:provider_version)
           end
 
           it "deletes the webhooks belonging to the consumer version" do
-            expect { subject }.to change{ TriggeredWebhook.count }.by (-1)
+            expect { subject }.to change{ TriggeredWebhook.count }.by(-1)
           end
         end
       end