pact_broker 2.4.2 → 2.5.0

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

@@ -5,50 +5,107 @@ module PactBroker
     describe Job do
 
       before do
-        allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now)
+        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::Service).to receive(:update_triggered_webhook_status)
       end
 
-      let(:webhook) { double("webhook", uuid: '1234') }
+      let(:triggered_webhook) { instance_double("PactBroker::Webhooks::TriggeredWebhook", webhook_uuid: '1234') }
+      let(:result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: success)}
+      let(:success) { true }
+
+      context "when the job succeeds" do
+        subject { Job.new.perform(triggered_webhook: triggered_webhook) }
+
+        it "does not reschedule the job" do
+          expect(Job).to_not receive(:perform_in)
+          subject
+        end
+
+        it "updates the triggered_webhook status to 'success'" do
+          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
+            .with(triggered_webhook, TriggeredWebhook::STATUS_SUCCESS)
+          subject
+        end
+      end
 
       context "when an error occurs for the first time" do
         before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).and_raise("an error")
+          allow(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now).and_raise("an error")
         end
 
+        subject { Job.new.perform(triggered_webhook: triggered_webhook) }
+
         it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, {webhook: webhook, error_count: 1})
-          Job.new.perform(webhook: webhook)
+          expect(Job).to receive(:perform_in).with(10, {triggered_webhook: triggered_webhook, error_count: 1})
+          subject
+        end
+
+        it "updates the triggered_webhook status to 'retrying'" do
+          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
+            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
+          subject
         end
       end
 
       context "when the webhook execution result is not successful for the first time" do
-        before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).and_return(instance_double("PactBroker::Domain::WebhookExecutionResult", success?: false))
-        end
+        let(:success) { false }
+
+        subject { Job.new.perform(triggered_webhook: triggered_webhook) }
 
         it "reschedules the job in 10 seconds" do
-          expect(Job).to receive(:perform_in).with(10, {webhook: webhook, error_count: 1})
-          Job.new.perform(webhook: webhook)
+          expect(Job).to receive(:perform_in).with(10, {triggered_webhook: triggered_webhook, 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"
+          })
+          subject
+        end
+
+        it "updates the triggered_webhook status to 'retrying'" do
+          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
+            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
+          subject
         end
       end
 
       context "when an error occurs for the second time" do
         before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).and_raise("an error")
+          allow(PactBroker::Webhooks::Service).to receive(:execute_triggered_webhook_now).and_raise("an error")
         end
 
+        subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 1) }
+
         it "reschedules the job in 60 seconds" do
-          expect(Job).to receive(:perform_in).with(60, {webhook: webhook, error_count: 2  })
-          Job.new.perform(webhook: webhook, error_count: 1)
+          expect(Job).to receive(:perform_in).with(60, {triggered_webhook: triggered_webhook, error_count: 2})
+          subject
         end
-      end
 
-      context "when an error occurs for the last time" do
-        before do
-          allow(PactBroker::Webhooks::Service).to receive(:execute_webhook_now).and_raise("an error")
+        it "updates the triggered_webhook status to 'retrying'" do
+          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status)
+            .with(triggered_webhook, TriggeredWebhook::STATUS_RETRYING)
+          subject
         end
+      end
+
+      context "when the job is not successful for the last time" do
+        let(:success) { false }
+
+        subject { Job.new.perform(triggered_webhook: triggered_webhook, error_count: 6) }
 
-        subject { Job.new.perform(webhook: webhook, error_count: 6) }
+        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"
+          })
+          subject
+        end
 
         it "does not reschedule the job" do
           expect(Job).to_not receive(:perform_in)
@@ -60,8 +117,12 @@ module PactBroker
           expect(Job.logger).to receive(:error).with(/Failed to execute/)
           subject
         end
-      end
 
+        it "updates the triggered_webhook status to 'failed'" do
+          expect(PactBroker::Webhooks::Service).to receive(:update_triggered_webhook_status).with(triggered_webhook, TriggeredWebhook::STATUS_FAILURE)
+          subject
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+require 'pact_broker/webhooks/redact_logs'
+
+module PactBroker
+  module Webhooks
+    describe RedactLogs do
+      describe ".call" do
+        let(:string) do
+          "Authorization: foo\nX-Thing: bar"
+        end
+
+        let(:x_auth_string) do
+          "X-Authorization: bar foo\nX-Thing: bar"
+        end
+
+        let(:x_auth_token) do
+          "X-Auth-Token: bar foo\nX-Thing: bar"
+        end
+
+        let(:x_authorization_token) do
+          "X-Authorization-Token: bar foo\nX-Thing: bar"
+        end
+
+        let(:string_lower) do
+          "authorization: foo\nX-Thing: bar"
+        end
+
+        it "hides the value of the Authorization header" do
+          expect(RedactLogs.call(string)).to eq "Authorization: [REDACTED]\nX-Thing: bar"
+        end
+
+        it "hides the value of the X-Authorization header" do
+          expect(RedactLogs.call(x_auth_string)).to eq "X-Authorization: [REDACTED]\nX-Thing: bar"
+        end
+
+        it "hides the value of the X-Auth-Token header" do
+          expect(RedactLogs.call(x_auth_token)).to eq "X-Auth-Token: [REDACTED]\nX-Thing: bar"
+        end
+
+        it "hides the value of the X-Authorization-Token header" do
+          expect(RedactLogs.call(x_authorization_token)).to eq "X-Authorization-Token: [REDACTED]\nX-Thing: bar"
+        end
+
+        it "hides the value of the authorization header" do
+          expect(RedactLogs.call(string_lower)).to eq "authorization: [REDACTED]\nX-Thing: bar"
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ module PactBroker
   module Webhooks
     describe Repository do
 
+      let(:td) { TestDataBuilder.new }
       let(:url) { 'http://example.org' }
       let(:body) { {'some' => 'json' } }
       let(:headers) { {'Content-Type' => 'application/json', 'Accept' => 'application/json'} }
@@ -187,6 +188,51 @@ module PactBroker
 
       end
 
+      describe "update_by_uuid" do
+        let(:uuid) { '1234' }
+        let(:td) { TestDataBuilder.new }
+        let(:old_webhook_params) do
+          {
+            uuid: uuid,
+            method: 'POST',
+            url: 'http://example.org',
+            body: '{"foo":1}',
+            headers: {'Content-Type' => 'application/json'},
+            username: 'username',
+            password: 'password'
+          }
+        end
+        let(:new_webhook_params) do
+          {
+            method: 'GET',
+            url: 'http://example.com',
+            body: 'foo',
+            headers: {'Content-Type' => 'text/plain'}
+          }
+        end
+        before do
+          td.create_consumer
+            .create_provider
+            .create_webhook(old_webhook_params)
+        end
+        let(:new_webhook) do
+          PactBroker::Domain::Webhook.new(request: PactBroker::Domain::WebhookRequest.new(new_webhook_params))
+        end
+
+        subject { Repository.new.update_by_uuid uuid, new_webhook }
+
+        it "updates the webhook" do
+          updated_webhook = subject
+          expect(updated_webhook.uuid).to eq uuid
+          expect(updated_webhook.request.method).to eq 'GET'
+          expect(updated_webhook.request.url).to eq 'http://example.com'
+          expect(updated_webhook.request.body).to eq 'foo'
+          expect(updated_webhook.request.headers).to eq 'Content-Type' => 'text/plain'
+          expect(updated_webhook.request.username).to eq nil
+          expect(updated_webhook.request.password).to eq nil
+        end
+      end
+
       describe "find_all" do
         before do
           Repository.new.create uuid, webhook, consumer, provider
@@ -240,20 +286,65 @@ module PactBroker
         end
       end
 
+      describe "create_triggered_webhook" do
+        before do
+          td.create_consumer
+            .create_provider
+            .create_webhook
+            .create_consumer_version
+            .create_pact
+        end
+
+        subject { Repository.new.create_triggered_webhook '1234', td.webhook, td.pact, 'pact_publication' }
+
+        it "creates a TriggeredWebhook" do
+          expect(subject.webhook_uuid ).to eq td.webhook.uuid
+          expect(subject.consumer).to eq td.consumer
+          expect(subject.provider).to eq td.provider
+          expect(subject.trigger_uuid).to eq '1234'
+          expect(subject.trigger_type).to eq 'pact_publication'
+        end
+
+        it "sets the webhook" do
+          expect(subject.webhook.uuid).to eq td.webhook.uuid
+        end
+
+        it "sets the webhook_uuid" do
+          expect(subject.webhook_uuid).to eq td.webhook.uuid
+        end
+
+        it "sets the consumer" do
+          expect(subject.consumer).to eq td.consumer
+        end
+
+        it "sets the provider" do
+          expect(subject.provider).to eq td.provider
+        end
+
+        it "sets the PactPublication" do
+          expect(subject.pact_publication.id).to eq td.pact.id
+        end
+      end
+
       describe "create_execution" do
-        let(:webhook_domain) { Repository.new.create uuid, webhook, consumer, provider }
+        before do
+          td.create_consumer
+            .create_provider
+            .create_consumer_version
+            .create_pact
+            .create_webhook
+            .create_triggered_webhook
+        end
+
+        let(:webhook_domain) { Repository.new.find_by_uuid td.webhook.uuid }
         let(:webhook_execution_result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: true, logs: "logs") }
 
-        subject { Repository.new.create_execution webhook_domain, webhook_execution_result }
+        subject { Repository.new.create_execution td.triggered_webhook, webhook_execution_result }
 
         it "saves a new webhook execution " do
           expect { subject }.to change { Execution.count }.by(1)
         end
 
-        it "sets the webhook" do
-          expect(subject.webhook.uuid).to eq webhook_domain.uuid
-        end
-
         it "sets the success" do
           expect(subject.success).to be true
         end
@@ -261,32 +352,191 @@ module PactBroker
         it "sets the logs" do
           expect(subject.logs).to eq "logs"
         end
+      end
 
-        it "sets the consumer" do
-          expect(subject.consumer).to eq consumer
+      describe "unlink_triggered_webhooks_by_webhook_uuid" do
+        let(:td) { TestDataBuilder.new }
+
+        before do
+          td.create_consumer
+            .create_provider
+            .create_consumer_version
+            .create_pact
+            .create_webhook
+            .create_triggered_webhook
+            .create_deprecated_webhook_execution
         end
 
-        it "sets the provider" do
-          expect(subject.provider).to eq provider
+        subject { Repository.new.unlink_triggered_webhooks_by_webhook_uuid td.webhook.uuid }
+
+        it "sets the webhook id to nil" do
+          webhook_id = Webhook.find(uuid: td.webhook.uuid).id
+          expect { subject }.to change {
+              TriggeredWebhook.find(id: td.triggered_webhook.id).webhook_id
+            }.from(webhook_id).to(nil)
         end
 
-        it "sets the PactPublication" do
-          expect(subject.pact_publication)
+        it "sets the webhook id to nil for the deprecated webhook execution field" do
+          webhook_id = Webhook.find(uuid: td.webhook.uuid).id
+          expect { subject }.to change {
+              DeprecatedExecution.find(id: td.webhook_execution.id).webhook_id
+            }.from(webhook_id).to(nil)
         end
       end
 
-      describe "unlink_executions_by_webhook_uuid" do
-        let!(:webhook_domain) { Repository.new.create uuid, webhook, consumer, provider }
-        let!(:webhook_execution_result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: true, logs: "logs") }
-        let!(:webhook_execution) { Repository.new.create_execution webhook_domain, webhook_execution_result }
+      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
 
-        subject { Repository.new.unlink_executions_by_webhook_uuid uuid }
+        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 "sets the webhook id to nil" do
-          webhook_id = Webhook.find(uuid: uuid).id
+          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
+
+        context "with deprecated executions (before the triggered webhook table was introduced)" do
+          before do
+            Sequel::Model.db[:webhook_executions].update(triggered_webhook_id: nil, consumer_id: td.consumer.id, provider_id: td.provider.id)
+            TriggeredWebhook.select_all.delete
+          end
+
+          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
+            .create_pact_with_hierarchy("Foo", "1.0.0", "Bar")
+            .create_webhook
+            .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_execution
+            .create_triggered_webhook(trigger_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_execution
+            .create_triggered_webhook(trigger_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']
+        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))
+              .create_webhook_execution
+          end
+
+          it "returns the one with the bigger ID" do
+            expect(subject.collect(&:trigger_uuid).sort).to eq ['332', '888']
+          end
+        end
+
+        context "when there are no triggered webhooks for the given consumer and provider" do
+          before do
+            td.create_consumer
+              .create_provider
+          end
+
+          it "returns an empty list" do
+            expect(subject).to be_empty
+          end
+        end
+      end
+
+      describe "fail_retrying_triggered_webhooks" do
+        before do
+          td.create_pact_with_hierarchy
+            .create_webhook
+            .create_triggered_webhook(status: TriggeredWebhook::STATUS_RETRYING)
+            .create_triggered_webhook(status: TriggeredWebhook::STATUS_SUCCESS)
+            .create_triggered_webhook(status: TriggeredWebhook::STATUS_NOT_RUN)
+            .create_triggered_webhook(status: TriggeredWebhook::STATUS_FAILURE)
+        end
+
+        it "sets the triggered_webhooks with retrying status to failed" do
+          Repository.new.fail_retrying_triggered_webhooks
+          expect(TriggeredWebhook.failed.count).to eq 2
+          expect(TriggeredWebhook.retrying.count).to eq 0
+          expect(TriggeredWebhook.successful.count).to eq 1
+          expect(TriggeredWebhook.not_run.count).to eq 1
+        end
+      end
+
+      describe "delete_triggered_webhooks_by_pact_publication_id" do
+        before do
+          td.create_pact_with_hierarchy
+            .create_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_pact_with_hierarchy("A Consumer", "1.2.3", "A Provider")
+            .create_webhook
+            .create_triggered_webhook
+            .create_webhook_execution
+            .create_deprecated_webhook_execution
+        end
+
+        subject { Repository.new.delete_triggered_webhooks_by_pact_publication_ids [td.pact.id] }
+
+        it "deletes the triggered webhook" do
           expect { subject }.to change {
-              Execution.find(id: webhook_execution.id).webhook_id
-            }.from(webhook_id).to(nil)
+            TriggeredWebhook.count
+          }.by(-1)
+        end
+
+        it "deletes the webhook_execution" do
+          expect { subject }.to change {
+            Execution.exclude(triggered_webhook_id: nil).count
+          }.by(-1)
+        end
+
+        it "deletes the deprecated webhook_execution" do
+          expect { subject }.to change {
+            Execution.exclude(consumer_id: nil).count
+          }.by(-1)
         end
       end
     end

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

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'pact_broker/webhooks/service'
+require 'pact_broker/webhooks/triggered_webhook'
 require 'webmock/rspec'
 require 'sucker_punch/testing/inline'
 
@@ -7,6 +8,24 @@ module PactBroker
 
   module Webhooks
     describe Service do
+      let(:td) { TestDataBuilder.new }
+
+      describe ".delete_by_uuid" do
+        before do
+          td.create_pact_with_hierarchy
+            .create_webhook
+            .create_triggered_webhook
+            .create_deprecated_webhook_execution
+        end
+
+        subject { Service.delete_by_uuid td.webhook.uuid }
+
+        it "deletes the webhook" do
+          expect { subject }.to change {
+            Webhook.count
+          }.by(-1)
+        end
+      end
 
       describe ".execute_webhooks" do
 
@@ -15,9 +34,11 @@ module PactBroker
         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) }
 
         before do
           allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:find_by_consumer_and_provider).and_return(webhooks)
+          allow_any_instance_of(PactBroker::Webhooks::Repository).to receive(:create_triggered_webhook).and_return(triggered_webhook)
           allow(Job).to receive(:perform_async)
         end
 
@@ -30,7 +51,7 @@ module PactBroker
 
         context "when webhooks are found" do
           it "executes the webhook" do
-            expect(Service).to receive(:run_later).with(webhooks)
+            expect(Service).to receive(:run_later).with(webhooks, pact)
             subject
           end
         end
@@ -61,6 +82,44 @@ module PactBroker
         end
       end
 
+      describe ".execute_webhook_now integration test" 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')
+            .and_return(:pact)
+        end
+
+        subject { PactBroker::Webhooks::Service.execute_webhook_now td.webhook, pact }
+
+        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 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_webhooks integration test" do
         let!(:http_request) do
           stub_request(:get, "http://example.org").
@@ -68,8 +127,7 @@ module PactBroker
         end
 
         let(:pact) do
-          TestDataBuilder.new
-            .create_consumer
+          td.create_consumer
             .create_provider
             .create_consumer_version
             .create_pact
@@ -84,9 +142,18 @@ module PactBroker
           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 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
   end