pact_broker 2.22.0 → 2.23.0

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

@@ -1,4 +1,6 @@
 require 'pact_broker/webhooks/render'
+require 'pact_broker/pacts/placeholder_pact'
+require 'pact_broker/verifications/placeholder_verification'
 require 'cgi'
 
 module PactBroker
@@ -115,6 +117,19 @@ module PactBroker
           it { is_expected.to eq "http%3A%2F%2Ffoo" }
         end
       end
+
+      describe "#call with placeholder domain objects" do
+        let(:placeholder_pact) { PactBroker::Pacts::PlaceholderPact.new }
+        let(:placeholder_verification) { PactBroker::Verifications::PlaceholderVerification.new }
+
+        it "does not blow up with a placeholder pact" do
+          Render.call("", placeholder_pact)
+        end
+
+        it "does not blow up with a placeholder verification" do
+          Render.call("", placeholder_pact, placeholder_verification)
+        end
+      end
     end
   end
 end

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

@@ -10,7 +10,7 @@ module PactBroker
       let(:body) { {'some' => 'json' } }
       let(:headers) { {'Content-Type' => 'application/json', 'Accept' => 'application/json'} }
       let(:request) do
-        Domain::WebhookRequest.new(
+        Webhooks::WebhookRequestTemplate.new(
           method: 'post',
           url: url,
           headers: headers,
@@ -23,9 +23,8 @@ module PactBroker
       end
       let(:events) { [event]}
       let(:webhook) { Domain::Webhook.new(request: request, events: events)}
-      let(:test_data_builder) { TestDataBuilder.new }
-      let(:consumer) { test_data_builder.create_pacticipant 'Consumer'; test_data_builder.pacticipant}
-      let(:provider) { test_data_builder.create_pacticipant 'Provider'; test_data_builder.pacticipant}
+      let(:consumer) { td.create_pacticipant 'Consumer'; td.pacticipant}
+      let(:provider) { td.create_pacticipant 'Provider'; td.pacticipant}
       let(:uuid) { 'the-uuid' }
       let(:created_webhook_record) { ::DB::PACT_BROKER_DB[:webhooks].order(:id).last }
       let(:created_headers) { ::DB::PACT_BROKER_DB[:webhook_headers].where(webhook_id: created_webhook_record[:id]).order(:name).all }
@@ -44,8 +43,7 @@ module PactBroker
       end
 
       describe "#create" do
-
-        subject { Repository.new.create uuid, webhook, consumer, provider }
+        subject { Repository.new.create(uuid, webhook, consumer, provider) }
 
         it "saves webhook" do
           subject
@@ -74,7 +72,7 @@ module PactBroker
           Repository.new.create 'another-uuid', webhook, consumer, provider
         end
 
-        subject { Repository.new.delete_by_uuid uuid }
+        subject { Repository.new.delete_by_uuid(uuid) }
 
         it "deletes the webhook headers" do
           expect { subject }.to change {
@@ -93,7 +91,7 @@ module PactBroker
 
         before do
           allow(SecureRandom).to receive(:urlsafe_base64).and_return(uuid, 'another-uuid')
-          Repository.new.create uuid, webhook, consumer, provider
+          Repository.new.create(uuid, webhook, consumer, provider)
         end
 
         context "when the pacticipant is the consumer" do
@@ -121,9 +119,7 @@ module PactBroker
       end
 
       describe "find_by_uuid" do
-
-
-        subject { Repository.new.find_by_uuid uuid }
+        subject { Repository.new.find_by_uuid(uuid) }
 
         context "when a webhook is found" do
           before do
@@ -152,7 +148,6 @@ module PactBroker
             expect(subject.request.headers).to eq headers
           end
 
-
           it "returns a webhook with the username set" do
             expect(subject.request.username).to eq 'username'
           end
@@ -202,7 +197,6 @@ module PactBroker
 
       describe "update_by_uuid" do
         let(:uuid) { '1234' }
-        let(:td) { TestDataBuilder.new }
         let(:old_webhook_params) do
           {
             events: [{ name: 'something' }],
@@ -235,7 +229,7 @@ module PactBroker
           PactBroker::Domain::Webhook.new(events: [new_event], request: PactBroker::Domain::WebhookRequest.new(new_webhook_params))
         end
 
-        subject { Repository.new.update_by_uuid uuid, new_webhook }
+        subject { Repository.new.update_by_uuid(uuid, new_webhook) }
 
         it "updates the webhook" do
           updated_webhook = subject
@@ -265,32 +259,29 @@ module PactBroker
       end
 
       describe "find_by_consumer_and_provider" do
-        let(:test_data_builder) { TestDataBuilder.new }
-        subject { Repository.new.find_by_consumer_and_provider test_data_builder.consumer, test_data_builder.provider}
+        let(:consumer) { td.consumer }
+        let(:provider) { td.provider }
 
-        context "when a webhook exists with a matching consumer and provider" do
+        subject { Repository.new.find_by_consumer_and_provider(consumer, provider) }
 
+        context "when a webhook exists with a matching consumer and provider" do
           before do
-            allow(SecureRandom).to receive(:urlsafe_base64).and_call_original
-            test_data_builder
-              .create_consumer("Consumer")
+            td.create_consumer("Consumer")
               .create_provider("Another Provider")
               .create_webhook
               .create_provider("Provider")
               .create_webhook
           end
 
-
           it "returns an array of webhooks" do
             expect(subject).to be_instance_of Array
-            expect(subject.first.uuid).to eq test_data_builder.webhook.uuid
+            expect(subject.first.uuid).to eq td.webhook.uuid
           end
         end
 
         context "when a webhook does not exist with a matching consumer and provider" do
-
           before do
-            test_data_builder
+            td
               .create_consumer("Consumer")
               .create_provider("Provider")
               .create_webhook
@@ -301,16 +292,49 @@ module PactBroker
             expect(subject).to eq []
           end
         end
+
+        context "when the consumer argument is nil" do
+          let(:consumer) { nil }
+
+          before do
+            td.create_provider("Provider")
+              .create_consumer("Consumer")
+              .create_provider_webhook
+              .create_webhook
+          end
+
+          it "returns all the webhooks where the provider matches and the consumer id is nil" do
+            expect(subject.size).to be 1
+            expect(subject.first.consumer).to be nil
+            expect(subject.first.provider).to_not be nil
+          end
+        end
+
+        context "when the provider argument is nil" do
+          let(:provider) { nil }
+
+          before do
+            td.create_consumer("Consumer")
+              .create_provider("Provider")
+              .create_consumer_webhook
+              .create_webhook
+          end
+
+          it "returns all the webhooks where the consumer matches and the provider id is nil" do
+            expect(subject.size).to be 1
+            expect(subject.first.provider).to be nil
+            expect(subject.first.consumer).to_not be nil
+          end
+        end
       end
 
       describe "find_by_consumer_and_provider_and_event_name" do
-        let(:test_data_builder) { TestDataBuilder.new }
-        subject { Repository.new.find_by_consumer_and_provider_and_event_name test_data_builder.consumer, test_data_builder.provider, 'something_happened' }
+        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
-            test_data_builder
+            td
               .create_consumer("Consumer")
               .create_provider("Another Provider")
               .create_webhook
@@ -326,6 +350,33 @@ module PactBroker
         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') }
+
+          it "returns an array of webhooks" do
+            expect(subject.collect(&:uuid).sort).to eq ['1', '2', '4', '5', '6']
+          end
+        end
+      end
+
       describe "create_triggered_webhook" do
         before do
           td.create_consumer
@@ -405,8 +456,6 @@ module PactBroker
       end
 
       describe "delete_triggered_webhooks_by_webhook_uuid" do
-        let(:td) { TestDataBuilder.new }
-
         before do
           td.create_consumer
             .create_provider
@@ -421,8 +470,8 @@ module PactBroker
             .create_deprecated_webhook_execution
             .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
@@ -553,6 +602,76 @@ module PactBroker
         end
       end
 
+      describe "find_latest_triggered_webhooks_for_pact" do
+        before do
+          td
+            .create_pact_with_hierarchy("Foo", "1.0.0", "Bar")
+            .create_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_pact_with_hierarchy
+            .create_webhook
+            .create_triggered_webhook(trigger_uuid: '256', created_at: DateTime.new(2016))
+            .create_webhook_execution
+            .create_triggered_webhook(trigger_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_webhook_execution
+            .create_triggered_webhook(trigger_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_webhook_execution
+            .create_triggered_webhook(trigger_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']
+        end
+      end
+
+      describe "find_triggered_webhooks_for_pact" do
+        before do
+          td
+            .create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_webhook
+            .create_triggered_webhook(trigger_uuid: "1")
+            .create_webhook_execution
+            .create_consumer_version("2")
+            .create_pact
+            .create_triggered_webhook(trigger_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"]
+        end
+      end
+
+      describe "find_triggered_webhooks_for_verification" do
+        before do
+          td
+            .create_pact_with_hierarchy("Foo", "1", "Bar")
+            .create_verification_webhook
+            .create_verification(provider_version: "1")
+            .create_triggered_webhook(trigger_uuid: "1")
+            .create_verification(provider_version: "2", number: 2)
+            .create_triggered_webhook(trigger_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"]
+        end
+      end
+
       describe "fail_retrying_triggered_webhooks" do
         before do
           td.create_pact_with_hierarchy

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

@@ -28,7 +28,7 @@ module PactBroker
         end
       end
 
-      describe ".execute_webhooks" do
+      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)}
@@ -39,15 +39,15 @@ module PactBroker
         let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
 
         before do
-          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_provider_and_event_name).and_return(webhooks)
+          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.execute_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
+        subject { Service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED }
 
         it "finds the webhooks" do
-          expect_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_provider_and_event_name).with(consumer, provider, PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME)
+          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
 
@@ -84,6 +84,83 @@ module PactBroker
         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(:options) do
+          {
+            failure_log_message: "Webhook execution failed",
+            show_response: 'foo'
+          }
+        end
+
+        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')
+        end
+
+        subject { Service.test_execution(webhook) }
+
+        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, options)
+            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)
+            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, options)
+            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)
+              subject
+            end
+          end
+        end
+      end
+
       describe ".execute_webhook_now integration test" do
         let(:td) { TestDataBuilder.new }
 
@@ -133,7 +210,7 @@ module PactBroker
         end
       end
 
-      describe ".execute_webhooks integration test" do
+      describe ".trigger_webhooks integration test" do
         let!(:http_request) do
           stub_request(:get, "http://example.org").
             to_return(:status => 200)
@@ -151,7 +228,7 @@ module PactBroker
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.execute_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 }
 
         it "executes the HTTP request of the webhook" do
           subject
@@ -161,7 +238,7 @@ module PactBroker
         it "executes the webhook with the correct options" do
           allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('foo')
           expected_options = {:show_response => 'foo' }
-          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).with(anything, anything, hash_including(expected_options)).and_call_original
+          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).with(hash_including(expected_options)).and_call_original
           subject
         end