pact_broker 2.32.0 → 2.33.0

data/spec/lib/pact_broker/pacts/pact_publication_spec.rb

@@ -3,6 +3,66 @@ require 'pact_broker/pacts/pact_publication'
 module PactBroker
   module Pacts
     describe PactPublication do
+      describe "save and upsert" do
+        before do
+          td.create_consumer
+            .create_provider
+            .create_consumer_version
+            .create_pact
+        end
+
+        let(:params) do
+          {
+            consumer_id: td.consumer.id,
+            provider_id: td.provider.id,
+            consumer_version_id: td.consumer_version.id,
+            pact_version_id: PactVersion.first.id,
+            revision_number: 1
+          }
+        end
+
+        let(:pact_publication) do
+          PactPublication.new(params)
+        end
+
+        context "when using a PactPublication with the same provider/consumer version/revision number as an existing PactPublication" do
+          describe "save" do
+            it "raises a constraint exception" do
+              expect { pact_publication.save }.to raise_error Sequel::UniqueConstraintViolation
+            end
+          end
+
+          describe "upsert" do
+            it "does not raise an error" do
+              pact_publication.upsert
+            end
+
+            it "sets the relationship objects" do
+              pact_publication.upsert
+              expect(pact_publication.id).to_not be nil
+              expect(pact_publication.consumer.id).to eq td.consumer.id
+              expect(pact_publication.consumer.name).to eq td.consumer.name
+            end
+
+            context "with objects instead of ids" do
+              let(:params) do
+                {
+                  consumer: td.consumer,
+                  provider: td.provider,
+                  consumer_version: td.consumer_version,
+                  pact_version: PactVersion.first,
+                  revision_number: 1
+                }
+              end
+
+              it "also works" do
+                pact_publication.upsert
+                expect(pact_publication.consumer_id).to eq td.consumer.id
+              end
+            end
+          end
+        end
+      end
 
       describe "#latest_tag_names" do
         before do

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

@@ -23,7 +23,7 @@ module PactBroker
           triggered_webhook: triggered_webhook,
           database_connector: database_connector,
           webhook_context: webhook_context,
-          execution_options: { the: 'options' }
+          logging_options: { the: 'options' }
         }
       end
 
@@ -84,7 +84,7 @@ module PactBroker
         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, {
-              execution_options: {
+              logging_options: {
                 failure_log_message: "Retrying webhook in 10 seconds",
                 success_log_message: "Successfully executed webhook",
                 the: 'options'
@@ -132,7 +132,7 @@ module PactBroker
         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, hash_including(
-              execution_options: hash_including(
+              logging_options: hash_including(
                 failure_log_message: "Webhook execution failed after 7 attempts",
                 success_log_message: "Successfully executed webhook")
             )

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

@@ -1,6 +1,8 @@
 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'
 
 module PactBroker
@@ -124,7 +126,8 @@ module PactBroker
             it "replaces #{template} with #{expected_output.inspect}" do
               the_pact = send(pact_var_name)
               the_verification = send(verification_var_name)
-              output = Render.call(template, the_pact, the_verification, webhook_context)
+              template_parameters = PactAndVerificationParameters.new(the_pact, the_verification, webhook_context).to_hash
+              output = Render.call(template, template_parameters)
               expect(output).to eq expected_output
             end
           end
@@ -132,7 +135,8 @@ module PactBroker
 
         context "with an escaper" do
           subject do
-            Render.call(template, pact, verification, webhook_context) do | value |
+            template_parameters = PactAndVerificationParameters.new(pact, verification, webhook_context).to_hash
+            Render.call(template, template_parameters) do | value |
               CGI.escape(value)
             end
           end
@@ -147,19 +151,24 @@ module PactBroker
           let(:webhook_context) do
             {
               consumer_version_number: "webhook-version-number",
-              consumer_version_tags: %w[webhook tags]
+              consumer_version_tags: %w[webhook tags],
+              base_url: base_url
+
             }
           end
+          let(:template_parameters) do
+            PactAndVerificationParameters.new(pact, verification, webhook_context).to_hash
+          end
 
           it "uses the consumer_version_number in preference to the field on the domain models" do
             template = "${pactbroker.consumerVersionNumber}"
-            output = Render.call(template, pact, verification, webhook_context)
+            output = Render.call(template, template_parameters)
             expect(output).to eq "webhook-version-number"
           end
 
           it "uses the consumer_version_tags in preference to the field on the domain models" do
             template = "${pactbroker.consumerVersionTags}"
-            output = Render.call(template, pact, verification, webhook_context)
+            output = Render.call(template, template_parameters)
             expect(output).to eq "webhook, tags"
           end
         end
@@ -170,12 +179,18 @@ module PactBroker
         let(:placeholder_verification) { PactBroker::Verifications::PlaceholderVerification.new }
         let(:base_url) { "http://broker" }
 
+        let(:template_parameters) do
+          PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+        end
+
         it "does not blow up with a placeholder pact" do
-          Render.call("", placeholder_pact, nil, {})
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+          Render.call("", template_parameters)
         end
 
         it "does not blow up with a placeholder verification" do
-          Render.call("", placeholder_pact, placeholder_verification, {})
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, placeholder_verification, { base_url: base_url }).to_hash
+          Render.call("", template_parameters)
         end
       end
     end

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

@@ -27,7 +27,6 @@ module PactBroker
       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 }
       let(:created_events) { ::DB::PACT_BROKER_DB[:webhook_events].where(webhook_id: created_webhook_record[:id]).order(:name).all }
       let(:expected_webhook_record) do
         {
@@ -50,19 +49,14 @@ module PactBroker
           expect(created_webhook_record).to include expected_webhook_record
         end
 
-        it "saves the headers" do
+        it "saves the webhook headers as JSON" do
           subject
-          expect(created_headers.size).to eq 2
-          expect(created_headers.first[:name]).to eq "Accept"
-          expect(created_headers.first[:value]).to eq "application/json"
-          expect(created_headers.last[:name]).to eq "Content-Type"
-          expect(created_headers.last[:value]).to eq "application/json"
+          expect(JSON.parse(created_webhook_record[:headers])).to eq headers
         end
 
         it "saves the webhook events" do
           expect(subject.events.first[:name]).to eq "something_happened"
         end
-
       end
 
       describe "delete_by_uuid" do
@@ -74,12 +68,6 @@ module PactBroker
 
         subject { Repository.new.delete_by_uuid(uuid) }
 
-        it "deletes the webhook headers" do
-          expect { subject }.to change {
-            ::DB::PACT_BROKER_DB[:webhook_headers].count
-            }.by(-2)
-        end
-
         it "deletes the webhook" do
           expect { subject }.to change {
             ::DB::PACT_BROKER_DB[:webhooks].where(uuid: uuid).count
@@ -240,16 +228,28 @@ module PactBroker
         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
-          expect(updated_webhook.events.first.name).to eq 'something_else'
-          expect(updated_webhook.consumer.name).to eq "Foo2"
+          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.username).to eq nil
+          expect(subject.request.password).to eq nil
+          expect(subject.events.first.name).to eq 'something_else'
+          expect(subject.consumer.name).to eq "Foo2"
+        end
+
+        context "when the updated params do not contain a consumer or provider" do
+          let(:new_webhook) do
+            PactBroker::Domain::Webhook.new(
+              events: [new_event],
+              request: new_request
+            )
+          end
+
+          it "removes the existing consumer or provider" do
+            expect(subject.consumer).to be nil
+          end
         end
       end
 

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

@@ -154,7 +154,7 @@ module PactBroker
         let(:options) do
           { database_connector: double('database_connector'),
             webhook_context: {},
-            execution_options: {}
+            logging_options: {}
           }
         end
 
@@ -219,7 +219,7 @@ module PactBroker
         let(:result) { double('result') }
         let(:options) do
           {
-            execution_options: {
+            logging_options: {
               failure_log_message: "Webhook execution failed",
               show_response: 'foo',
             },
@@ -346,10 +346,10 @@ module PactBroker
           {
             database_connector: database_connector,
             webhook_context: { base_url: 'http://example.org' },
-            execution_options: execution_options
+            logging_options: logging_options
           }
         end
-        let(:execution_options) { { show_response: true } }
+        let(:logging_options) { { show_response: true } }
         let(:database_connector) { ->(&block) { block.call } }
         let(:pact) do
           td.create_consumer
@@ -369,7 +369,7 @@ module PactBroker
         end
 
         it "executes the webhook with the correct options" do
-          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).with(hash_including(execution_options)).and_call_original
+          expect_any_instance_of(PactBroker::Domain::WebhookRequest).to receive(:execute).and_call_original
           subject
         end
 

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

@@ -0,0 +1,197 @@
+require 'pact_broker/webhooks/webhook_request_logger'
+require 'pact_broker/domain/webhook_request'
+
+module PactBroker
+  module Webhooks
+    describe WebhookRequestLogger do
+      before do
+        if response
+          response_headers.each do | key, value |
+            allow(response).to receive(:each_header).and_yield(key, value)
+          end
+        end
+        allow(webhook_request_logger).to receive(:logger).and_return(logger)
+        subject
+      end
+
+      let(:logger) { double('logger').as_null_object }
+      let(:uuid) { "uuid" }
+      let(:options) { { failure_log_message: 'oops', show_response: show_response } }
+      let(:show_response) { true }
+      let(:username) { nil }
+      let(:password) { nil }
+      let(:url) { 'http://example.org/hook' }
+      let(:headers) { {'Content-Type' => 'text/plain', 'Authorization' => 'foo'} }
+      let(:body) { 'reqbody' }
+      let(:webhook_request) do
+        PactBroker::Domain::WebhookRequest.new(
+          method: 'post',
+          url: url,
+          headers: headers,
+          username: username,
+          password: password,
+          body: body)
+      end
+      let(:error) { nil }
+      let(:status) { 200 }
+      let(:response) do
+        double('response',
+          http_version: "1.0",
+          message: "OK",
+          code: status,
+          body: response_body,
+          to_hash: response_headers
+        )
+      end
+      let(:response_body) { "respbod" }
+      let(:response_headers) do
+        {
+          'content-type' => 'text/foo, blah'
+        }
+      end
+
+      let(:webhook_request_logger) { WebhookRequestLogger.new(options) }
+
+      subject(:logs) { webhook_request_logger.log(uuid, webhook_request, response, error) }
+
+      describe "application logs" do
+        it "logs the request" do
+          expect(logger).to have_received(:info).with(/POST.*example/)
+          expect(logger).to have_received(:debug).with(/.*text\/plain/)
+          expect(logger).to have_received(:debug).with(/.*reqbody/)
+        end
+
+        it "logs the response" do
+          expect(logger).to have_received(:info).with(/response.*200/)
+          expect(logger).to have_received(:debug).with(/text\/foo/)
+          expect(logger).to have_received(:debug).with(/respbod/)
+        end
+      end
+
+      describe "execution logs" do
+
+        it "logs the request method and path" do
+          expect(logs).to include "POST http://example.org/hook"
+        end
+
+        it "logs the request headers" do
+          expect(logs).to include "content-type: text/plain"
+        end
+
+        it "logs the request body" do
+          expect(logs).to include body
+        end
+
+        context "when show_response is true" do
+          it "logs the response status" do
+            expect(logs).to include "HTTP/1.0 200"
+          end
+
+          it "logs the response headers" do
+            expect(logs).to include "content-type: text/foo, blah"
+          end
+
+          it "logs the response body" do
+            expect(logs).to include "respbod"
+          end
+        end
+
+        context "when show_response is false" do
+          let(:show_response) { false }
+
+          it "does not log the response status" do
+            expect(logs).to_not include "HTTP/1.0 200"
+          end
+
+          it "does not log the response headers" do
+            expect(logs).to_not include "content-type: text/foo, blah"
+          end
+
+          it "does not log the response body" do
+            expect(logs).to_not include "respbod"
+          end
+
+          it "logs a message about why the response is hidden" do
+            expect(logs).to include "security purposes"
+          end
+        end
+
+        context "when the response code is a success" do
+          it "does not log the failure_log_message" do
+            expect(logs).to_not include "oops"
+          end
+        end
+
+        context "when the response code is not successful" do
+          let(:status) { 400 }
+
+          it "logs the failure_log_message" do
+            expect(logs).to include "oops"
+          end
+        end
+
+        context "with basic auth" do
+          let(:headers) { { 'authorization' => 'foo' } }
+
+          it "logs the Authorization header with a starred value" do
+            expect(logs).to include "authorization: **********"
+          end
+        end
+
+        context "when the response body contains a non UTF-8 character" do
+          let(:response_body) { "This has some \xC2 invalid chars" }
+
+          it "logs the safe body so it doesn't blow up the database" do
+            expect(logs).to include "This has some  invalid chars"
+          end
+
+          it "logs that it has cleaned the string to the execution logger" do
+            expect(logs).to include("Note that invalid UTF-8 byte sequences were removed")
+          end
+        end
+
+        context "when an error occurs executing the request" do
+
+          class WebhookTestError < StandardError; end
+
+          before do
+            allow(error).to receive(:backtrace).and_return([])
+          end
+
+          let(:response) { nil }
+          let(:error) do
+            err = WebhookTestError.new("blah")
+            allow(err).to receive(:backtrace).and_return([])
+            err
+          end
+
+          it "logs the error" do
+            expect(logger).to have_received(:info).with(/Error.*WebhookTestError.*blah/)
+          end
+
+          it "logs the failure_log_message" do
+            expect(logs).to include "oops"
+          end
+
+          context "when show_response is true" do
+            it "logs the exception information" do
+              expect(logs).to include "blah"
+            end
+          end
+
+          context "when show_response is false" do
+            let(:show_response) { false }
+
+            it "does not logs the exception information" do
+              expect(logs).to_not include "blah"
+            end
+
+            it "logs a message about why the response is hidden" do
+              expect(logs).to include "security purposes"
+            end
+          end
+        end
+      end
+    end
+  end
+end