pact_broker 2.34.0 → 2.35.0

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

@@ -1,4 +1,5 @@
 require 'pact_broker/webhooks/job'
+require 'pact_broker/webhooks/execution_configuration'
 
 module PactBroker
   module Webhooks
@@ -9,11 +10,15 @@ module PactBroker
         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)
+        allow(webhook_execution_configuration).to receive(:with_success_log_message).and_return(webhook_execution_configuration)
+        allow(webhook_execution_configuration).to receive(:with_failure_log_message).and_return(webhook_execution_configuration)
       end
 
       let(:base_url) { "http://broker" }
       let(:triggered_webhook) { instance_double("PactBroker::Webhooks::TriggeredWebhook", webhook_uuid: '1234', id: 1) }
-      let(:result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: success)}
+      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(:success) { true }
       let(:logger) { double('logger').as_null_object }
       let(:database_connector) { ->(&block) { block.call } }
@@ -22,8 +27,7 @@ module PactBroker
         {
           triggered_webhook: triggered_webhook,
           database_connector: database_connector,
-          webhook_context: webhook_context,
-          logging_options: { the: 'options' }
+          webhook_execution_configuration: webhook_execution_configuration
         }
       end
 
@@ -58,11 +62,7 @@ module PactBroker
         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
-          ))
+          expect(Job).to receive(:perform_in).with(10, hash_including(job_params))
           subject
         end
 
@@ -81,16 +81,16 @@ module PactBroker
           subject
         end
 
+        it "sets the success and failure messages" do
+          expect(webhook_execution_configuration).to receive(:with_success_log_message).with("Successfully executed webhook")
+          expect(webhook_execution_configuration).to receive(:with_failure_log_message).with("Retrying webhook in 10 seconds")
+          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, {
-              logging_options: {
-                failure_log_message: "Retrying webhook in 10 seconds",
-                success_log_message: "Successfully executed webhook",
-                the: 'options'
-              },
-              webhook_context: webhook_context
-          })
+            .with(triggered_webhook, webhook_execution_configuration_hash)
           subject
         end
 
@@ -122,21 +122,18 @@ module PactBroker
       end
 
       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) }
+        let(:success) { false }
 
         it "executes the job with an log message indicating that the webhook has failed" do
+          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)
-            .with(triggered_webhook, hash_including(
-              logging_options: hash_including(
-                failure_log_message: "Webhook execution failed after 7 attempts",
-                success_log_message: "Successfully executed webhook")
-            )
-          )
+            .with(triggered_webhook, webhook_execution_configuration_hash)
           subject
         end
 

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

@@ -4,6 +4,8 @@ module PactBroker
   module Webhooks
     describe RedactLogs do
       describe ".call" do
+        let(:values) { [] }
+
         let(:string) do
           "Authorization: foo\nX-Thing: bar"
         end
@@ -25,23 +27,32 @@ module PactBroker
         end
 
         it "hides the value of the Authorization header" do
-          expect(RedactLogs.call(string)).to eq "Authorization: [REDACTED]\nX-Thing: bar"
+          expect(RedactLogs.call(string, values)).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"
+          expect(RedactLogs.call(x_auth_string, values)).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"
+          expect(RedactLogs.call(x_auth_token, values)).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"
+          expect(RedactLogs.call(x_authorization_token, values)).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"
+          expect(RedactLogs.call(string_lower, values)).to eq "authorization: [REDACTED]\nX-Thing: bar"
+        end
+
+        context "with values" do
+          let(:values) { %w[foo bar] }
+          let(:string) { "blahfoo\nbar wiffle" }
+
+          it "hides the passed in values" do
+            expect(RedactLogs.call(string, values)).to eq "blah********\n******** wiffle"
+          end
         end
       end
     end

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

@@ -430,8 +430,9 @@ module PactBroker
 
         let(:webhook_domain) { Repository.new.find_by_uuid td.webhook.uuid }
         let(:webhook_execution_result) { instance_double("PactBroker::Domain::WebhookExecutionResult", success?: true, logs: "logs") }
+        let(:repository) { Repository.new }
 
-        subject { Repository.new.create_execution td.triggered_webhook, webhook_execution_result }
+        subject { repository.create_execution td.triggered_webhook, webhook_execution_result }
 
         it "saves a new webhook execution " do
           expect { subject }.to change { Execution.count }.by(1)
@@ -444,6 +445,20 @@ module PactBroker
         it "sets the logs" do
           expect(subject.logs).to eq "logs"
         end
+
+        context "when the triggered webhook has been deleted in the meantime" do
+          before do
+            TriggeredWebhook.where(id: td.triggered_webhook.id).delete
+            allow(repository).to receive(:logger).and_return(logger)
+          end
+
+          let(:logger) { double('logger') }
+
+          it "just logs the error" do
+            expect(logger).to receive(:info).with(/triggered webhook with id #{td.triggered_webhook.id}/)
+            subject
+          end
+        end
       end
 
       describe "delete_triggered_webhooks_by_webhook_uuid" do

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

@@ -4,6 +4,7 @@ require 'pact_broker/webhooks/triggered_webhook'
 require 'pact_broker/webhooks/webhook_event'
 require 'webmock/rspec'
 require 'sucker_punch/testing/inline'
+require 'pact_broker/webhooks/execution_configuration'
 
 module PactBroker
 
@@ -217,25 +218,19 @@ module PactBroker
         let(:verification) { instance_double(PactBroker::Domain::Verification) }
         let(:trigger_on_verification) { false }
         let(:result) { double('result') }
-        let(:options) do
-          {
-            logging_options: {
-              failure_log_message: "Webhook execution failed",
-              show_response: 'foo',
-            },
-            webhook_context: {
-              base_url: 'http://broker'
-            }
-          }
+        let(:execution_configuration) do
+          instance_double(PactBroker::Webhooks::ExecutionConfiguration, to_hash: execution_configuration_hash)
         end
+        let(:execution_configuration_hash) { { the: 'options' } }
 
         before do
           allow(PactBroker::Pacts::Service).to receive(:search_for_latest_pact).and_return(pact)
           allow(PactBroker::Verifications::Service).to receive(:search_for_latest).and_return(verification)
           allow(PactBroker.configuration).to receive(:show_webhook_response?).and_return('foo')
+          allow(execution_configuration).to receive(:with_failure_log_message).and_return(execution_configuration)
         end
 
-        subject { Service.test_execution(webhook, options) }
+        subject { Service.test_execution(webhook, execution_configuration) }
 
         it "searches for the latest matching pact" do
           expect(PactBroker::Pacts::Service).to receive(:search_for_latest_pact).with(consumer_name: 'consumer', provider_name: 'provider')
@@ -248,7 +243,7 @@ module PactBroker
 
         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)
+            expect(webhook).to receive(:execute).with(pact, nil, execution_configuration_hash)
             subject
           end
         end
@@ -271,7 +266,7 @@ module PactBroker
           end
 
           it "executes the webhook with the pact and the verification" do
-            expect(webhook).to receive(:execute).with(pact, verification, options)
+            expect(webhook).to receive(:execute).with(pact, verification, execution_configuration_hash)
             subject
           end
 
@@ -286,55 +281,6 @@ 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 ".trigger_webhooks integration test", job: true do
         let!(:http_request) do
           stub_request(:get, "http://example.org").
@@ -342,11 +288,15 @@ module PactBroker
         end
 
         let(:events) { [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }] }
+        let(:webhook_execution_configuration) do
+          PactBroker::Webhooks::ExecutionConfiguration.new
+            .with_webhook_context(base_url: 'http://example.org')
+            .with_show_response(true)
+        end
         let(:options) do
           {
             database_connector: database_connector,
-            webhook_context: { base_url: 'http://example.org' },
-            logging_options: logging_options
+            webhook_execution_configuration: webhook_execution_configuration
           }
         end
         let(:logging_options) { { show_response: true } }
@@ -386,6 +336,15 @@ module PactBroker
           expect(TriggeredWebhook.first.status).to eq TriggeredWebhook::STATUS_SUCCESS
         end
       end
+
+      describe "parameters" do
+        subject { Service.parameters }
+
+        it "returns a list of parameters and their descriptions" do
+          expect(subject.first.name).to start_with "pactbroker.consumerName"
+          expect(subject.first.description).to eq "the consumer name"
+        end
+      end
     end
   end
 end

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

@@ -7,11 +7,11 @@ module PactBroker
         {
           method: 'POST',
           url: url,
-          username: "foo",
-          password: "bar",
+          username: "username",
+          password: password,
           uuid: "1234",
           body: body,
-          headers: {'Foo' => 'bar'}
+          headers: headers
         }
       end
 
@@ -19,14 +19,16 @@ module PactBroker
         {
           method: 'POST',
           url: built_url,
-          username: "foo",
-          password: "bar",
+          username: "usernameBUILT",
+          password: "passwordBUILT",
           uuid: "1234",
           body: built_body,
-          headers: {'Foo' => 'bar'}
+          headers: {'headername' => 'headervalueBUILT'}
         }
       end
 
+      let(:password) { "password" }
+      let(:headers) { {'headername' => 'headervalue'} }
       let(:url) { "http://example.org/hook?foo=bar" }
       let(:base_url) { "http://broker" }
       let(:built_url) { "http://example.org/hook?foo=barBUILT" }
@@ -38,28 +40,11 @@ module PactBroker
           allow(PactBroker::Webhooks::Render).to receive(:call) do | content, pact, verification, &block |
             content + "BUILT"
           end
-
-          allow(PactAndVerificationParameters).to receive(:new).and_return(pact_and_verification_parameters)
         end
 
-        let(:pact_and_verification_parameters) { instance_double(PactAndVerificationParameters, to_hash: params_hash)}
         let(:params_hash) { double('params hash') }
-        let(:pact) { double('pact') }
-        let(:verification) { double('verification') }
-        let(:webhook_context) { { some: "context", base_url: base_url } }
-        let(:template_context) do
-          {
-            pact: pact,
-            verification: verification,
-            webhook_context: webhook_context
-          }
-        end
-        subject { WebhookRequestTemplate.new(attributes).build(template_context) }
 
-        it "creates the template parameters" do
-          expect(PactAndVerificationParameters).to receive(:new).with(pact, verification, webhook_context)
-          subject
-        end
+        subject { WebhookRequestTemplate.new(attributes).build(params_hash) }
 
         it "renders the url template" do
           expect(PactBroker::Webhooks::Render).to receive(:call).with(url, params_hash) do | content, pact, verification, &block |
@@ -90,10 +75,109 @@ module PactBroker
           end
         end
 
+        it "renders each header value" do
+          expect(PactBroker::Webhooks::Render).to receive(:call).with('headervalue', params_hash)
+          subject
+        end
+
+        it "renders the username" do
+          expect(PactBroker::Webhooks::Render).to receive(:call).with('username', params_hash)
+          subject
+        end
+
+        it "renders the password" do
+          expect(PactBroker::Webhooks::Render).to receive(:call).with('password', params_hash)
+          subject
+        end
+
         it "creates a new PactBroker::Domain::WebhookRequest" do
           expect(PactBroker::Domain::WebhookRequest).to receive(:new).with(new_attributes)
           subject
         end
+
+        context "when optional attributes are missing" do
+          let(:attributes) do
+            {
+              method: 'POST',
+              url: url,
+              uuid: "1234",
+            }
+          end
+
+          it "does not blow up" do
+            subject
+          end
+        end
+      end
+
+      describe "redacted_headers" do
+        subject { WebhookRequestTemplate.new(attributes) }
+
+        let(:headers) do
+          {
+            'Authorization' => 'foo',
+            'X-authorization' => 'bar',
+            'Token' => 'bar',
+            'X-Auth-Token' => 'bar',
+            'X-Authorization-Token' => 'bar',
+            'OK' => 'ok'
+          }
+        end
+
+        let(:expected_headers) do
+          {
+            'Authorization' => '**********',
+            'X-authorization' => '**********',
+            'Token' => '**********',
+            'X-Auth-Token' => '**********',
+            'X-Authorization-Token' => '**********',
+            'OK' => 'ok'
+          }
+        end
+
+        it "redacts sensitive headers" do
+          expect(subject.redacted_headers).to eq expected_headers
+        end
+
+        context "when there is a parameter in the value" do
+          let(:headers) do
+            {
+              'Authorization' => '${pactbroker.secret}'
+            }
+          end
+
+          let(:expected_headers) do
+            {
+              'Authorization' => '${pactbroker.secret}'
+            }
+          end
+
+          it "does not redact it" do
+            expect(subject.redacted_headers).to eq expected_headers
+          end
+        end
+      end
+
+      describe "display_password" do
+        subject { WebhookRequestTemplate.new(attributes) }
+
+        context "when it is nil" do
+          let(:password) { nil }
+
+          its(:display_password) { is_expected.to be nil }
+        end
+
+        context "when the password contains a parameter" do
+          let(:password) { "${pactbroker.foo}" }
+
+          its(:display_password) { is_expected.to eq password }
+        end
+
+        context "when the password does not contains a parameter" do
+          let(:password) { "foo" }
+
+          its(:display_password) { is_expected.to eq "**********" }
+        end
       end
     end
   end

data/spec/migrations/23_pact_versions_spec.rb

@@ -1,3 +1,5 @@
+require 'pact_broker/webhooks/execution_configuration'
+
 describe 'migrate to pact versions (migrate 22-31)', migration: true do
   before do
     PactBroker::Database.migrate(22)
@@ -13,7 +15,6 @@ describe 'migrate to pact versions (migrate 22-31)', migration: true do
   let!(:pact_1) { create(:pacts, {version_id: consumer_version_1[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
   let!(:pact_2) { create(:pacts, {version_id: consumer_version_2[:id], provider_id: provider[:id], pact_version_content_sha: '1234', created_at: now, updated_at: pact_updated_at}) }
 
-
   subject { PactBroker::Database.migrate }
 
   it "keeps the same number of pacts" do
@@ -71,6 +72,7 @@ describe 'migrate to pact versions (migrate 22-31)', migration: true do
         consumer_version_number: '1.2.3',
         json_content: load_fixture('a_consumer-a_provider.json')
       },{
+        webhook_execution_configuration: PactBroker::Webhooks::ExecutionConfiguration.new
       }
     )
   end

data/spec/spec_helper.rb

@@ -52,5 +52,7 @@ RSpec.configure do | config |
   end
 end
 
-# SemanticLogger.add_appender(io: $stdout)
-# SemanticLogger.default_level = :info
+if ENV["DEBUG"] == "true"
+  SemanticLogger.add_appender(io: $stdout)
+  SemanticLogger.default_level = :info
+end

data/spec/support/database_cleaner.rb

@@ -20,7 +20,6 @@ RSpec.configure do |config|
     PactBroker::Database.drop_objects
   end
 
-
   config.after :each, migration: true do
     PactBroker::Database.migrate
     PactBroker::Database.truncate