pact_broker 2.75.0 → 2.78.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/sequel/plugins/upsert_spec.rb

@@ -24,6 +24,12 @@ module Sequel
         plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
       end
 
+      describe PacticipantNoUpsert do
+        it "has an _insert_dataset method" do
+          expect(PacticipantNoUpsert.private_instance_methods).to include (:_insert_dataset)
+        end
+      end
+
       describe "LatestPactPublicationIdForConsumerVersion" do
         before do
           td.create_pact_with_hierarchy("Foo", "1", "Bar")
@@ -102,10 +108,20 @@ module Sequel
 
       context "when a duplicate Version is inserted with upsert" do
         let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
-        let!(:original_version) { Version.new(number: "1", pacticipant_id: pacticipant.id).upsert }
+        let!(:original_version) do
+          version = Version.new(
+            number: "1",
+            pacticipant_id: pacticipant.id,
+            branch: "original-branch",
+            build_url: "original-url"
+          ).upsert
+          Version.where(id: version.id).update(created_at: yesterday, updated_at: yesterday)
+          version
+        end
+        let(:yesterday) { DateTime.now - 2 }
 
         subject do
-          Version.new(number: "1", pacticipant_id: pacticipant.id).upsert
+          Version.new(number: "1", pacticipant_id: pacticipant.id, branch: "new-branch").upsert
         end
 
         it "does not raise an error" do
@@ -113,12 +129,24 @@ module Sequel
         end
 
         it "sets the values on the object" do
-          expect(subject.id).to eq original_version.id
+          expect(subject.branch).to eq "new-branch"
+        end
+
+        it "nils out values that weren't set on the second model" do
+          expect(subject.build_url).to eq nil
         end
 
         it "does not insert another row" do
           expect { subject }.to_not change { Version.count }
         end
+
+        it "does not change the created_at" do
+          expect { subject }.to_not change { Version.where(number: "1").first.created_at }
+        end
+
+        it "does change the updated_at" do
+          expect { subject }.to change { Version.where(number: "1").first.updated_at }
+        end
       end
     end
   end

data/spec/service_consumers/hal_relation_proxy_app.rb

@@ -9,7 +9,9 @@ class HalRelationProxyApp
     '/HAL-REL-PLACEHOLDER-INDEX-PB-LATEST-VERSION-Condor' =>
       '/pacticipants/Condor/latest-version',
     '/HAL-REL-PLACEHOLDER-PB-WEBHOOKS' =>
-      '/webhooks'
+      '/webhooks',
+    '/HAL-REL-PLACEHOLDER-INDEX-PB-PACTICIPANT-VERSION-Foo-26f353580936ad3b9baddb17b00e84f33c69e7cb' =>
+      '/pacticipants/Foo/versions/26f353580936ad3b9baddb17b00e84f33c69e7cb'
   }
 
   RESPONSE_BODY_REPLACEMENTS = {