pact_broker 2.32.0 → 2.33.0

data/spec/lib/pact_broker/db/data_migrations/migrate_webhook_headers_spec.rb

@@ -0,0 +1,78 @@
+require 'pact_broker/db/data_migrations/migrate_webhook_headers'
+
+module PactBroker
+  module DB
+    module DataMigrations
+      describe MigrateWebhookHeaders, migration: true do
+        describe ".call" do
+          before do
+            PactBroker::Database.migrate(20190602)
+            webhook_header_1
+            webhook_header_2
+            webhook_header_3
+          end
+
+          let(:now) { DateTime.new(2018, 2, 2) }
+
+          let(:webhook_1) do
+            create(:webhooks, {
+              uuid: "1",
+              method: "POST",
+              url: "http://example.org",
+              body: nil,
+              is_json_request_body: false,
+              enabled: true,
+              created_at: now,
+              updated_at: now
+            })
+          end
+          let(:webhook_header_1) do
+            create(:webhook_headers, {
+              name: "Foo",
+              value: "bar",
+              webhook_id: webhook_1[:id]
+            }, nil)
+          end
+
+          let(:webhook_header_2) do
+            create(:webhook_headers, {
+              name: "Wiffle",
+              value: "meep",
+              webhook_id: webhook_1[:id]
+            }, nil)
+          end
+
+          let(:webhook_2) do
+            create(:webhooks, {
+              uuid: "2",
+              method: "POST",
+              url: "http://example.org",
+              body: nil,
+              is_json_request_body: false,
+              enabled: true,
+              created_at: now,
+              updated_at: now
+            })
+          end
+
+          let(:webhook_header_3) do
+            create(:webhook_headers, {
+              name: "Foo2",
+              value: "bar2",
+              webhook_id: webhook_2[:id]
+            }, nil)
+          end
+
+          subject { MigrateWebhookHeaders.call(database) }
+
+          it "migrates the webhook headers from individual rows to json on the webhook row" do
+            subject
+            expect(JSON.parse(database[:webhooks].first[:headers])).to eq "Foo" => "bar", "Wiffle" => "meep"
+            expect(JSON.parse(database[:webhooks].order(:id).last[:headers])).to eq "Foo2" => "bar2"
+            expect(database[:webhook_headers].count).to eq 0
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/domain/webhook_request_spec.rb

@@ -10,12 +10,7 @@ module PactBroker
       let(:url) { 'http://example.org/hook' }
       let(:headers) { {'Content-Type' => 'text/plain', 'Authorization' => 'foo'} }
       let(:body) { 'reqbody' }
-      let(:logs) { StringIO.new }
       let(:logger) { double('logger').as_null_object }
-      let(:execution_logger) { Logger.new(logs) }
-      let(:options) { {failure_log_message: 'oops', show_response: show_response} }
-      let(:show_response) { true }
-      let(:logs) { execute.logs }
 
       subject do
         WebhookRequest.new(
@@ -27,7 +22,7 @@ module PactBroker
           body: body)
       end
 
-      let(:execute) { subject.execute(options) }
+      let(:execute) { subject.execute }
 
       describe "description" do
         it "returns a brief description of the HTTP request" do
@@ -83,7 +78,7 @@ module PactBroker
         let!(:http_request) do
           stub_request(:post, "http://example.org/hook").
             with(:headers => {'Content-Type'=>'text/plain'}, :body => request_body).
-            to_return(:status => 200, :body => "respbod", :headers => {'Content-Type' => 'text/foo, blah'})
+            to_return(:status => status, :body => "respbod", :headers => {'Content-Type' => 'text/foo, blah'})
         end
 
         before do
@@ -92,6 +87,7 @@ module PactBroker
           allow(WebhookRequest.logger).to receive(:debug)
         end
 
+        let(:status) { 200 }
         let(:request_body) { 'reqbody' }
 
         it "executes the configured request" do
@@ -99,98 +95,6 @@ module PactBroker
           expect(http_request).to have_been_made
         end
 
-        it "logs the request" do
-          expect(logger).to receive(:info).with(/POST.*example/)
-          expect(logger).to receive(:debug).with(/.*text\/plain/)
-          expect(logger).to receive(:debug).with(/.*reqbody/)
-          execute
-        end
-
-        it "logs the response" do
-          allow(logger).to receive(:info)
-          allow(logger).to receive(:debug)
-          expect(logger).to receive(:info).with(/response.*200/)
-          expect(logger).to receive(:debug).with(/text\/foo/)
-          expect(logger).to receive(:debug).with(/respbod/)
-          execute
-        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 "redacts potentially sensitive headers" do
-            expect(logs).to include "authorization: **********"
-          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
-              allow_any_instance_of(WebhookExecutionResult).to receive(:success?).and_return(true)
-              expect(logs).to_not include "oops"
-            end
-          end
-
-          context "when the response code is not successful" do
-            it "logs the failure_log_message" do
-              allow_any_instance_of(WebhookExecutionResult).to receive(:success?).and_return(false)
-              expect(logs).to include "oops"
-            end
-          end
-
-          context "with basic auth" do
-            let(:username) { 'username' }
-            let(:password) { 'password' }
-
-            it "logs the Authorization header with a starred value" do
-              expect(logs).to include "authorization: **********"
-            end
-          end
-        end
-
         describe "when a username and password are specified" do
 
           let!(:http_request_with_basic_auth) do
@@ -255,12 +159,8 @@ module PactBroker
         end
 
         context "when the request is successful" do
-          it "returns a WebhookExecutionResult with success=true" do
-            expect(execute.success?).to be true
-          end
-
-          it "sets the response on the result" do
-            expect(execute.response).to be_instance_of(WebhookResponseWithUtf8SafeBody)
+          it "returns the response" do
+            expect(execute.response).to be_instance_of(Net::HTTPOK)
           end
         end
 
@@ -272,36 +172,12 @@ module PactBroker
               to_return(:status => 500, :body => "An error")
           end
 
-          it "returns a WebhookExecutionResult with success=false" do
-            expect(execute.success?).to be false
-          end
-
-          it "sets the response on the result" do
-            expect(execute.response).to be_instance_of(WebhookResponseWithUtf8SafeBody)
-          end
-        end
-
-        context "when the response body contains a non UTF-8 character" do
-          let!(:http_request) do
-            stub_request(:post, "http://example.org/hook").
-              to_return(:status => 200, :body => "This has some \xC2 invalid chars")
-          end
-
-          it "removes the non UTF-8 characters before saving the logs so they don't blow up the database" do
-            result = execute
-            expect(result.logs).to include "This has some  invalid chars"
-          end
-
-          it "logs that it has cleaned the string to the execution logger" do
-            logger = double("logger").as_null_object
-            allow(Logger).to receive(:new).and_return(logger)
-            expect(logger).to receive(:debug).with(/Note that invalid UTF-8 byte sequences were removed/)
-            execute
+          it "returns the response" do
+            expect(execute.response).to be_instance_of(Net::HTTPInternalServerError)
           end
         end
 
         context "when an error occurs executing the request" do
-
           class WebhookTestError < StandardError; end
 
           before do
@@ -309,39 +185,8 @@ module PactBroker
             allow(logger).to receive(:error)
           end
 
-          it "logs the error" do
-            expect(logger).to receive(:info).with(/Error.*WebhookTestError.*blah/)
-            execute
-          end
-
-          it "returns a WebhookExecutionResult with success=false" do
-            expect(execute.success?).to be false
-          end
-
           it "returns a WebhookExecutionResult with an error" do
-            expect(execute.error).to be_instance_of WebhookTestError
-          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
+            expect { execute }.to raise_error WebhookTestError
           end
         end
       end

data/spec/lib/pact_broker/domain/webhook_spec.rb

@@ -3,14 +3,16 @@ require 'pact_broker/domain/webhook'
 module PactBroker
   module Domain
     describe Webhook do
+      let(:uuid) { "uuid" }
       let(:consumer) { Pacticipant.new(name: 'Consumer')}
       let(:provider) { Pacticipant.new(name: 'Provider')}
-      let(:request_template) { instance_double(PactBroker::Webhooks::WebhookRequestTemplate, build: request)}
-      let(:request) { instance_double(PactBroker::Domain::WebhookRequest, execute: result) }
-      let(:result) { double('result') }
+      let(:request_template) { instance_double(PactBroker::Webhooks::WebhookRequestTemplate, build: webhook_request)}
+      let(:webhook_request) { instance_double(PactBroker::Domain::WebhookRequest, execute: http_response, http_request: http_request) }
+      let(:http_request) { double('http request') }
+      let(:http_response) { double('http response') }
       let(:webhook_context) { { some: 'things' } }
-      let(:execution_options) { { other: 'options' } }
-      let(:options) { { webhook_context: webhook_context, execution_options: execution_options } }
+      let(:logging_options) { { other: 'options' } }
+      let(:options) { { webhook_context: webhook_context, logging_options: logging_options } }
       let(:pact) { double('pact') }
       let(:verification) { double('verification') }
       let(:logger) { double('logger').as_null_object }
@@ -19,7 +21,7 @@ module PactBroker
         allow(webhook).to receive(:logger).and_return(logger)
       end
 
-      subject(:webhook) { Webhook.new(request: request_template, consumer: consumer, provider: provider) }
+      subject(:webhook) { Webhook.new(uuid: uuid, request: request_template, consumer: consumer, provider: provider) }
 
       describe "scope_description" do
         subject { webhook.scope_description }
@@ -50,9 +52,12 @@ module PactBroker
 
       describe "execute" do
         before do
-          allow(request_template).to receive(:build).and_return(request)
+          allow(request_template).to receive(:build).and_return(webhook_request)
+          allow(PactBroker::Webhooks::WebhookRequestLogger).to receive(:new).and_return(webhook_request_logger)
         end
 
+        let(:webhook_request_logger) { instance_double(PactBroker::Webhooks::WebhookRequestLogger, log: "logs") }
+
         let(:execute) { subject.execute pact, verification, options }
 
         it "builds the request" do
@@ -64,15 +69,47 @@ module PactBroker
         end
 
         it "executes the request" do
-          expect(request).to receive(:execute).with(execution_options)
+          expect(webhook_request).to receive(:execute)
+          execute
+        end
+
+        it "generates the execution logs" do
+          expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, http_response, nil)
           execute
         end
 
+        it "returns a WebhookExecutionResult" do
+          expect(execute.request).to_not be nil
+          expect(execute.response).to_not be nil
+          expect(execute.logs).to eq "logs"
+          expect(execute.error).to be nil
+        end
+
         it "logs before and after" do
           allow(logger).to receive(:info)
           expect(logger).to receive(:info).with(/Executing/)
           execute
         end
+
+        context "when an error is thrown" do
+          let(:error_class) { Class.new(StandardError) }
+
+          before do
+            allow(webhook_request).to receive(:execute).and_raise(error_class)
+          end
+
+          it "generates the execution logs" do
+            expect(webhook_request_logger).to receive(:log).with(uuid, webhook_request, nil, instance_of(error_class))
+            execute
+          end
+
+          it "returns a WebhookExecutionResult with an error" do
+            expect(execute.request).to_not be nil
+            expect(execute.response).to be nil
+            expect(execute.logs).to eq "logs"
+            expect(execute.error).to_not be nil
+          end
+        end
       end
     end
   end

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

@@ -1035,6 +1035,30 @@ module PactBroker
           expect(subject.rows.first.consumer_version_number).to eq "2"
         end
       end
+
+      describe "deploying a provider when there is a three way dependency between 3 pacticipants" do
+        before do
+          # A->B, A->C, B->C, deploying C
+          td.create_pact_with_hierarchy("B", "1", "C")
+            .create_verification(provider_version: "10")
+            .create_consumer("A")
+            .create_consumer_version("2")
+            .create_pact
+            .create_verification(provider_version: "10")
+            .use_provider("B")
+            .create_pact
+        end
+
+        let(:selectors) { [ { pacticipant_name: "C", pacticipant_version_number: "10" } ] }
+        let(:options) { { latestby: "cvp", limit: "100", latest: true} }
+        let(:rows) { Repository.new.find(selectors, options) }
+
+        subject { shorten_rows(rows) }
+
+        it "only includes rows that involve the specified pacticipant" do
+          expect(subject.all?{ | row | row.include?("C") } ).to be true
+        end
+      end
     end
   end
 end

data/spec/lib/pact_broker/pacticipants/find_potential_duplicate_pacticipant_names_spec.rb

@@ -8,7 +8,7 @@ module PactBroker
     describe FindPotentialDuplicatePacticipantNames do
 
       describe "split" do
-        TEST_CASES = [
+        SPLIT_TEST_CASES = [
           ["a-foo-service", ["a", "foo", "service"]],
           ["a_foo_service", ["a", "foo", "service"]],
           ["FooAService", ["foo", "a", "service"]],
@@ -19,7 +19,7 @@ module PactBroker
           ["S3_Bucket_Service", ["s3", "bucket", "service"]],
         ]
 
-        TEST_CASES.each do | input, output |
+        SPLIT_TEST_CASES.each do | input, output |
           it "splits #{input} into #{output.inspect}" do
             expect(FindPotentialDuplicatePacticipantNames.split(input)).to eq output
           end
@@ -31,7 +31,7 @@ module PactBroker
         subject { FindPotentialDuplicatePacticipantNames.call(new_name, existing_names) }
 
 
-        TEST_CASES = [
+        CALL_TEST_CASES = [
           ["accounts", ["accounts-receivable"], []],
           ["Accounts", ["Accounts Receivable"], []],
           ["The Accounts", ["Accounts"], []],
@@ -47,7 +47,7 @@ module PactBroker
           ['Contract_Service', ['ContractsService', 'Contracts Service', 'contracts-service', 'Contacts', 'Something'], ['ContractsService', 'Contracts Service', 'contracts-service']]
         ]
 
-        TEST_CASES.each do | the_new_name, the_existing_names, the_expected_duplicates |
+        CALL_TEST_CASES.each do | the_new_name, the_existing_names, the_expected_duplicates |
           context "when the new name is #{the_new_name} and the existing names are #{the_existing_names.inspect}" do
             let(:new_name) { the_new_name }
             let(:existing_names) { the_existing_names }