pact_broker 2.76.1 → 2.79.0

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

@@ -23,6 +23,8 @@ module PactBroker
         it "sets the properties" do
           expect(subject.name).to eq "prod"
           expect(subject.version.id).to eq td.version.id
+          expect(subject.version_order).to eq td.version.order
+          expect(subject.pacticipant_id).to eq td.version.pacticipant_id
         end
 
         context "when the tag already exists" do

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

@@ -22,6 +22,8 @@ module PactBroker
         end
 
         let(:options) { { webhook_execution_configuration: webhook_execution_configuration } }
+        let(:event_context) { { some: "data" } }
+        let(:expected_event_context) { { some: "data", provider_version_tags: ["dev"] } }
         let(:webhook_execution_configuration) { instance_double(PactBroker::Webhooks::ExecutionConfiguration) }
         let(:params) { { 'success' => true, 'providerApplicationVersion' => '4.5.6', 'wip' => true, 'testResults' => { 'some' => 'results' }} }
         let(:pact) do
@@ -30,7 +32,7 @@ module PactBroker
             .create_provider_version_tag('dev')
             .and_return(:pact)
         end
-        let(:create_verification) { subject.create 3, params, pact, options }
+        let(:create_verification) { subject.create 3, params, pact, event_context, options }
 
         it "logs the creation" do
           expect(logger).to receive(:info).with(/.*verification.*3/, payload: {"providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true})
@@ -67,6 +69,7 @@ module PactBroker
           expect(PactBroker::Webhooks::TriggerService).to have_received(:trigger_webhooks_for_verification_results_publication).with(
             pact,
             verification,
+            expected_event_context,
             options
           )
         end

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

@@ -122,6 +122,60 @@ module PactBroker
           end
         end
       end
+
+      describe "#create_or_overwrite" do
+        before do
+          td.subtract_day
+            .create_consumer("Foo")
+            .create_consumer_version(version_number, branch: "original-branch", build_url: "original-build-url")
+            .create_consumer_version_tag("dev")
+        end
+
+        let(:pacticipant) { td.and_return(:consumer) }
+        let(:version_number) { "1234" }
+        let(:tags) { nil }
+        let(:open_struct_version) { OpenStruct.new(branch: "new-branch", tags: tags) }
+
+        subject { Repository.new.create_or_overwrite(pacticipant, version_number, open_struct_version) }
+
+        it "overwrites the values" do
+          expect(subject.branch).to eq "new-branch"
+          expect(subject.build_url).to eq nil
+        end
+
+        it "does not change the tags" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").tags }
+        end
+
+        context "when there are tags specified" do
+          let(:tags) { [ OpenStruct.new(name: "main")] }
+
+          it "overwrites the tags" do
+            expect(subject.tags.count).to eq 1
+            expect(subject.tags.first.name).to eq "main"
+          end
+        end
+
+        it "does not change the created date" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").created_at }
+        end
+
+        it "does change the updated date" do
+          expect { subject }.to change { PactBroker::Domain::Version.for("Foo", "1234").updated_at }
+        end
+
+        it "maintains the order" do
+          expect { subject }.to_not change { PactBroker::Domain::Version.for("Foo", "1234").order }
+        end
+
+        context "when the version does not already exist" do
+          let(:version) { OpenStruct.new(number: "555", branch: "new-branch") }
+
+          it "sets the order" do
+            expect(subject.order).to_not be nil
+          end
+        end
+      end
     end
   end
 end

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

@@ -94,7 +94,7 @@ module PactBroker
           [ double("label", name: "foo"), double("label", name: "bar") ]
         end
 
-        let(:webhook_context) { { base_url: base_url } }
+        let(:webhook_context) { { base_url: base_url, event_name: "something" } }
 
         let(:nil_pact) { nil }
         let(:nil_verification) { nil }
@@ -158,7 +158,8 @@ module PactBroker
             {
               consumer_version_number: "webhook-version-number",
               consumer_version_tags: %w[webhook tags],
-              base_url: base_url
+              base_url: base_url,
+              event_name: "something"
 
             }
           end
@@ -186,16 +187,16 @@ module PactBroker
         let(:base_url) { "http://broker" }
 
         let(:template_parameters) do
-          PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+          PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url, event_name: "something" }).to_hash
         end
 
         it "does not blow up with a placeholder pact" do
-          template_parameters = PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url }).to_hash
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, nil, { base_url: base_url, event_name: "something" }).to_hash
           Render.call("", template_parameters)
         end
 
         it "does not blow up with a placeholder verification" do
-          template_parameters = PactAndVerificationParameters.new(placeholder_pact, placeholder_verification, { base_url: base_url }).to_hash
+          template_parameters = PactAndVerificationParameters.new(placeholder_pact, placeholder_verification, { base_url: base_url, event_name: "something" }).to_hash
           Render.call("", template_parameters)
         end
       end

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

@@ -181,7 +181,9 @@ module PactBroker
         let(:webhooks) { [instance_double(PactBroker::Domain::Webhook, description: 'description', uuid: '1244')]}
         let(:triggered_webhook) { instance_double(PactBroker::Webhooks::TriggeredWebhook) }
         let(:webhook_execution_configuration) { double('webhook_execution_configuration', webhook_context: webhook_context) }
-        let(:webhook_context) { double('webhook_context') }
+        let(:webhook_context) { { base_url: "http://example.org" } }
+        let(:event_context) { { some: "data" } }
+        let(:expected_event_context) { { some: "data", event_name: PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, base_url: "http://example.org" } }
         let(:options) do
           { database_connector: double('database_connector'),
             webhook_execution_configuration: webhook_execution_configuration,
@@ -196,7 +198,7 @@ module PactBroker
           allow(Job).to receive(:perform_in)
         end
 
-        subject { Service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options }
+        subject { Service.trigger_webhooks(pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, options) }
 
         it "finds the webhooks" do
           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)
@@ -205,7 +207,7 @@ module PactBroker
 
         context "when webhooks are found" do
           it "executes the webhook" do
-            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options)
+            expect(Service).to receive(:run_later).with(webhooks, pact, verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, expected_event_context, options)
             subject
           end
 
@@ -258,6 +260,7 @@ module PactBroker
           instance_double(PactBroker::Webhooks::ExecutionConfiguration, to_hash: execution_configuration_hash)
         end
         let(:execution_configuration_hash) { { the: 'options' } }
+        let(:event_context) { { some: "data" } }
 
         before do
           allow(PactBroker::Pacts::Service).to receive(:search_for_latest_pact).and_return(pact)
@@ -266,7 +269,7 @@ module PactBroker
           allow(execution_configuration).to receive(:with_failure_log_message).and_return(execution_configuration)
         end
 
-        subject { Service.test_execution(webhook, execution_configuration) }
+        subject { Service.test_execution(webhook, event_context, 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')
@@ -279,7 +282,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, execution_configuration_hash)
+            expect(webhook).to receive(:execute).with(pact, nil, event_context.merge(event_name: "test"), execution_configuration_hash)
             subject
           end
         end
@@ -288,7 +291,7 @@ module PactBroker
           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)
+            expect(webhook).to receive(:execute).with(an_instance_of(PactBroker::Pacts::PlaceholderPact), anything, anything, anything)
             subject
           end
         end
@@ -302,7 +305,7 @@ module PactBroker
           end
 
           it "executes the webhook with the pact and the verification" do
-            expect(webhook).to receive(:execute).with(pact, verification, execution_configuration_hash)
+            expect(webhook).to receive(:execute).with(pact, verification, event_context.merge(event_name: "test"), execution_configuration_hash)
             subject
           end
 
@@ -310,7 +313,7 @@ module PactBroker
             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)
+              expect(webhook).to receive(:execute).with(anything, an_instance_of(PactBroker::Verifications::PlaceholderVerification), anything, anything)
               subject
             end
           end
@@ -329,6 +332,7 @@ module PactBroker
             .with_webhook_context(base_url: 'http://example.org')
             .with_show_response(true)
         end
+        let(:event_context) { { some: "data", base_url: "http://example.org" }}
         let(:options) do
           {
             database_connector: database_connector,
@@ -347,7 +351,7 @@ module PactBroker
             .and_return(:pact)
         end
 
-        subject { PactBroker::Webhooks::Service.trigger_webhooks pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, options }
+        subject { PactBroker::Webhooks::Service.trigger_webhooks(pact, td.verification, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, options) }
 
         it "executes the HTTP request of the webhook" do
           subject

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

@@ -11,6 +11,7 @@ module PactBroker
       let(:previous_pact_version_sha) { "111" }
       let(:previous_pacts) { { untagged: previous_pact } }
       let(:logger) { double('logger').as_null_object }
+      let(:event_context) { { some: "data" } }
       let(:webhook_options) { { the: 'options'} }
 
       before do
@@ -21,27 +22,27 @@ module PactBroker
 
       shared_examples_for "triggering a contract_published event" do
         it "triggers a contract_published webhook" do
-          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, webhook_options)
+          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options)
           subject
         end
       end
 
       shared_examples_for "triggering a contract_content_changed event" do
         it "triggers a contract_content_changed webhook" do
-          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, webhook_options)
+          expect(webhook_service).to receive(:trigger_webhooks).with(pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options)
           subject
         end
       end
 
       shared_examples_for "not triggering a contract_content_changed event" do
         it "does not trigger a contract_content_changed webhook" do
-          expect(webhook_service).to_not receive(:trigger_webhooks).with(anything, anything, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, anything)
+          expect(webhook_service).to_not receive(:trigger_webhooks).with(anything, anything, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, anything)
           subject
         end
       end
 
       describe "#trigger_webhooks_for_new_pact" do
-        subject { TriggerService.trigger_webhooks_for_new_pact(pact, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_new_pact(pact, event_context, webhook_options) }
 
         context "when no previous untagged pact exists" do
           let(:previous_pact) { nil }
@@ -117,7 +118,7 @@ module PactBroker
         end
         let(:existing_pact_version_sha) { pact_version_sha }
 
-        subject { TriggerService.trigger_webhooks_for_updated_pact(existing_pact, pact, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_updated_pact(existing_pact, pact, event_context, webhook_options) }
 
         context "when the pact version sha of the previous revision is different" do
           let(:existing_pact_version_sha) { "456" }
@@ -140,32 +141,73 @@ module PactBroker
       describe "#trigger_webhooks_for_verification_results_publication" do
         let(:verification) { double("verification", success: success) }
         let(:success) { true }
+        # See lib/pact_broker/pacts/metadata.rb build_metadata_for_pact_for_verification
+        let(:selector_1) { { latest: true, consumer_version_number: "1", tag: "prod" } }
+        let(:selector_2) { { latest: true, consumer_version_number: "1", tag: "main" } }
+        let(:selector_3) { { latest: true, consumer_version_number: "2", tag: "feat/2" } }
+        let(:event_context) do
+          {
+            consumer_version_selectors: [selector_1, selector_2, selector_3],
+            other: "foo"
+          }
+        end
+        let(:expected_event_context_1) { { consumer_version_number: "1", consumer_version_tags: ["prod", "main"], other: "foo" } }
+        let(:expected_event_context_2) { { consumer_version_number: "2", consumer_version_tags: ["feat/2"], other: "foo" } }
 
-        subject { TriggerService.trigger_webhooks_for_verification_results_publication(pact, verification, webhook_options) }
+        subject { TriggerService.trigger_webhooks_for_verification_results_publication(pact, verification, event_context, webhook_options) }
 
         context "when the verification is successful" do
-          it "triggers a provider_verification_succeeded webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, webhook_options)
-            subject
+
+          context "when there are consumer_version_selectors in the event_context" do
+            it "triggers a provider_verification_succeeded webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, expected_event_context_2, webhook_options)
+              subject
+            end
+
+            it "triggers a provider_verification_published webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_2, webhook_options)
+              subject
+            end
           end
 
-          it "triggers a provider_verification_published webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, webhook_options)
-            subject
+          context "when there are no consumer_version_selectors" do
+            let(:event_context) { { some: "data" } }
+
+            it "passes through the event context" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED, event_context, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, event_context, webhook_options)
+              subject
+            end
           end
         end
 
         context "when the verification is not successful" do
           let(:success) { false }
 
-          it "triggers a provider_verification_failed webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, webhook_options)
-            subject
+          context "when there are consumer_version_selectors in the event_context" do
+            it "triggers a provider_verification_failed webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, expected_event_context_2, webhook_options)
+              subject
+            end
+
+            it "triggeres a provider_verification_published webhook for each consumer version (ie. commit)" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_1, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, expected_event_context_2, webhook_options)
+              subject
+            end
           end
 
-          it "triggeres a provider_verification_published webhook" do
-            expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, webhook_options)
-            subject
+          context "when there are no consumer_version_selectors" do
+            let(:event_context) { { some: "data" } }
+
+            it "passes through the event context" do
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED, event_context, webhook_options)
+              expect(webhook_service).to receive(:trigger_webhooks).with(pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED, event_context, webhook_options)
+              subject
+            end
           end
         end
       end

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

@@ -129,6 +129,14 @@ module PactBroker
           end
         end
 
+        context "when the response code '100' is not in 'webhook_http_code_success'" do
+          let(:status) { 100 }
+
+          it "not successful, code '100' not in 'webhook_http_code_success'" do
+            expect(logs).to include "oops"
+          end
+        end
+
         context "when the response code is not successful" do
           let(:status) { 400 }
 

data/spec/lib/rack/pact_broker/set_base_url_spec.rb

@@ -0,0 +1,86 @@
+require 'rack/pact_broker/set_base_url'
+
+module Rack
+  module PactBroker
+    describe SetBaseUrl do
+      let(:base_urls) { ["http://pact-broker"] }
+      let(:rack_env) { {} }
+      let(:target_app) { double('app', call: [200, {}, []]) }
+      let(:app) { SetBaseUrl.new(target_app, base_urls) }
+
+      subject { get("/", {}, rack_env) }
+
+      describe "#call" do
+        context "when the base_url is already set" do
+          let(:rack_env) { { "pactbroker.base_url" => "http://foo"} }
+
+          it "does not overwrite it" do
+            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://foo"))
+            subject
+          end
+        end
+
+        context "when there is one base URL" do
+          it "sets that base_url" do
+            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://pact-broker"))
+            subject
+          end
+        end
+
+        context "when there are no base URLs" do
+          let(:base_urls) { [] }
+
+          it "sets the base URL to nil" do
+            expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => nil))
+            subject
+          end
+        end
+
+        context "when there are multiple base URLs" do
+          let(:base_urls) { ["https://foo", "https://pact-broker-external", "http://pact-broker-internal"] }
+
+          let(:host) { "pact-broker-internal" }
+          let(:scheme) { "http" }
+          let(:forwarded_host) { "pact-broker-external" }
+          let(:forwarded_scheme) { "https" }
+          let(:rack_env) do
+            {
+              Rack::HTTP_HOST => host,
+              Rack::RACK_URL_SCHEME => scheme,
+              "HTTP_X_FORWARDED_HOST" => forwarded_host,
+              "HTTP_X_FORWARDED_SCHEME" => forwarded_scheme
+            }
+          end
+
+          context "when the base URL created taking any X-Forwarded headers into account matches one of the base URLs" do
+            it "uses that base URL" do
+              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "https://pact-broker-external"))
+              subject
+            end
+          end
+
+          context "when the base URL created NOT taking the X-Forwarded headers into account matches one of the base URLs (potential cache poisoning)" do
+            let(:forwarded_host) { "pact-broker-external-wrong" }
+
+            it "uses that base URL" do
+              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "http://pact-broker-internal"))
+              subject
+            end
+          end
+
+          context "when neither base URL matches the base URLs (potential cache poisoning)" do
+            before do
+              rack_env["HTTP_HOST"] = "silly-buggers-1"
+              rack_env["HTTP_X_FORWARDED_HOST"] = "silly-buggers-1"
+            end
+
+            it "uses the first base URL" do
+              expect(target_app).to receive(:call).with(hash_including("pactbroker.base_url" => "https://foo"))
+              subject
+            end
+          end
+        end
+      end
+    end
+  end
+end