pact_broker 2.85.0 → 2.88.0

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

@@ -32,18 +32,53 @@ module PactBroker
 
         context "with a consumer and provider" do
           it { is_expected.to eq "A webhook for the pact between Consumer and Provider" }
+
+          context "when provider is specified by a label" do
+            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
+
+            it { is_expected.to eq "A webhook for the pact between Consumer and providers labeled 'provider-label'" }
+          end
+
+          context "when consumer is specified by a label" do
+            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
+
+            it { is_expected.to eq "A webhook for the pact between consumers labeled 'consumer-label' and Provider" }
+          end
+
+          context "when both are specified by labels" do
+            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
+            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
+
+            it do
+              is_expected.to eq(
+                "A webhook for the pact between consumers labeled 'consumer-label' and providers labeled 'provider-label'"
+              )
+            end
+          end
         end
 
         context "with a consumer only" do
           let(:provider) { nil }
 
           it { is_expected.to eq "A webhook for all pacts with consumer Consumer" }
+
+          context "when specified by a label" do
+            let(:consumer) { WebhookPacticipant.new(label: "consumer-label")}
+
+            it { is_expected.to eq "A webhook for all pacts with consumer labeled 'consumer-label'" }
+          end
         end
 
         context "with a provider only" do
           let(:consumer) { nil }
 
           it { is_expected.to eq "A webhook for all pacts with provider Provider" }
+
+          context "when specified by a label" do
+            let(:provider) { WebhookPacticipant.new(label: "provider-label")}
+
+            it { is_expected.to eq "A webhook for all pacts with provider labeled 'provider-label'" }
+          end
         end
 
         context "with neither a consumer nor a provider" do

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

@@ -13,18 +13,22 @@ module PactBroker
             .create_provider("Bar")
             .create_consumer_version
             .create_pact
-            .create_global_webhook
-            .create_consumer_webhook
-            .create_provider_webhook
+            .create_global_webhook(description: "global")
+            .create_consumer_webhook(description: "consumer")
+            .create_provider_webhook(description: "provider")
             .create_provider("Wiffle")
-            .create_provider_webhook
+            .create_provider_webhook(description: "wiffle")
         end
 
         let(:row) { HeadRow.where(consumer_name: "Foo", provider_name: "Bar").single_record }
 
         it "returns all the webhooks" do
           rows = HeadRow.eager(:webhooks).all
-          expect(rows.first.webhooks.count).to eq 3
+          expect(rows.first.webhooks).to contain_exactly(
+            have_attributes(description: "global"),
+            have_attributes(description: "provider"),
+            have_attributes(description: "consumer")
+          )
         end
       end
 

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

@@ -38,6 +38,19 @@ module PactBroker
             end
           end
 
+          context "with pacticipant selectors to ignore" do
+            before do
+              params[:ignore] = [{ pacticipant: "foo" }, { pacticipant: "bar", version: "2" }]
+            end
+
+            its([:ignore_selectors]) do
+              is_expected.to eq [
+                PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "foo"),
+                PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "bar", pacticipant_version_number: "2")
+              ]
+            end
+          end
+
           context "with a tag" do
             let(:params) do
               {

data/spec/lib/pact_broker/pacts/{latest_tagged_pact_publications_spec.rb → pact_publication_clean_selector_dataset_module_spec.rb}

@@ -1,9 +1,7 @@
-require "pact_broker/pacts/latest_tagged_pact_publications"
-
 module PactBroker
   module Pacts
-    describe LatestTaggedPactPublications do
-      subject { LatestTaggedPactPublications.for_selector(selector).order(:consumer_name, :consumer_version_order) }
+    describe PactPublicationCleanSelectorDatasetModule do
+      subject { PactPublication.latest_by_consumer_tag_for_clean_selector(selector).all.sort_by{ | pp | [pp.consumer_name, pp.consumer_version_number]} }
 
       context "for latest for a specified tag" do
         before do
@@ -15,7 +13,7 @@ module PactBroker
             .create_consumer_version_tag("prod")
         end
 
-        let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true) }
+        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev", latest: true) }
 
         it "returns matching rows" do
           expect(subject.count).to eq 1
@@ -33,7 +31,7 @@ module PactBroker
             .create_consumer_version_tag("dev")
         end
 
-        let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev", latest: true, pacticipant_name: "Foo") }
+        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev", latest: true, pacticipant_name: "Foo") }
 
         it "returns matching rows" do
           expect(subject.count).to eq 1
@@ -51,7 +49,7 @@ module PactBroker
             .create_consumer_version_tag("prod")
         end
 
-        let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: "dev") }
+        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: "dev") }
 
         it "returns matching rows (which are only the latest)" do
           expect(subject.count).to eq 1
@@ -69,7 +67,7 @@ module PactBroker
             .create_consumer_version_tag("prod")
         end
 
-        let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: true, latest: true) }
+        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: true, latest: true) }
 
         it "returns matching rows" do
           expect(subject.count).to eq 2
@@ -87,7 +85,7 @@ module PactBroker
             .create_consumer_version_tag("dev")
         end
 
-        let(:selector) { PactBroker::Matrix::UnresolvedSelector.new(tag: true, latest: true, max_age: 5) }
+        let(:selector) { PactBroker::DB::Clean::Selector.new(tag: true, latest: true, max_age: 5) }
 
         it "returns matching rows" do
           expect(subject.count).to eq 1

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

@@ -65,6 +65,38 @@ module PactBroker
         end
       end
 
+      describe "#latest_main_branch_verification" do
+        before do
+          td.create_pact_with_verification("Foo", "1", "Bar", "2")
+            .create_verification(provider_version: "3", number: 2, branch: "main")
+            .create_verification(provider_version: "3", number: 3)
+            .create_verification(provider_version: "3", number: 4)
+            .create_pact_with_verification("NotFoo", "1", "Bar", "4")
+            .create_verification(provider_version: "5", number: 5)
+            .create_pact_with_verification("NotFoo2", "1", "NotBar", "4")
+            .create_verification(provider_version: "6", number: 6)
+            .create_pact_with_verification("NotFoo3", "2", "NotBar", "5")
+            .create_verification(provider_version: "7", number: 7)
+        end
+
+        context "lazy loading" do
+          it "lazy loads" do
+            expect(PactPublication.order(:id).all.first.pact_version.latest_main_branch_verification).to have_attributes(provider_version_number: "3", number: 4)
+            expect(PactPublication.order(:id).all.last.pact_version.latest_main_branch_verification).to be_nil
+          end
+        end
+
+        context "eager loading" do
+          let(:pact_version_1) { PactVersion.eager(:latest_main_branch_verification).order(:id).all.first }
+          let(:pact_version_2) { PactVersion.eager(:latest_main_branch_verification).order(:id).all.last }
+
+          it "eager loads" do
+            expect(PactPublication.order(:id).all.first.pact_version.latest_main_branch_verification).to have_attributes(provider_version_number: "3", number: 4)
+            expect(pact_version_2.associations[:latest_main_branch_verification]).to be_nil
+          end
+        end
+      end
+
       describe "latest_consumer_version" do
         before do
           td.create_consumer("consumer")

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

@@ -15,14 +15,13 @@ module PactBroker
         subject { Repository.new.find_for_verification("Bar", consumer_version_selectors) }
 
         context "when there are no selectors" do
-
           let(:foo_main_branch) { nil }
 
           let(:consumer_version_selectors) { Selectors.new }
 
           context "when there is no main branch version" do
             before do
-              td.create_consumer("Foo")
+              td.create_consumer("Foo", main_branch: "main")
                 .create_pact_with_hierarchy("Foo", "foo-latest-prod-version", "Bar")
                 .create_consumer_version_tag("prod")
                 .create_consumer_version("not-latest-dev-version", tag_names: ["dev"])
@@ -31,14 +30,14 @@ module PactBroker
                 .create_consumer_version("foo-latest-dev-version", tag_names: ["dev"])
                 .create_pact
                 .create_consumer("Baz")
-                .create_consumer_version("baz-latest-dev-version", tag_names: ["dev"])
+                .create_consumer_version("baz-latest-dev-version", tag_names: ["dev", "main"])
                 .create_pact
             end
 
             it "returns the latest pact for each consumer" do
               expect(subject.size).to eq 2
-              expect(find_by_consumer_name_and_consumer_version_number("Foo", "foo-latest-dev-version")).to_not be nil
-              expect(find_by_consumer_name_and_consumer_version_number("Baz", "baz-latest-dev-version")).to_not be nil
+              expect(subject).to include(have_attributes(consumer_name: "Foo", consumer_version_number: "foo-latest-dev-version"))
+              expect(subject).to include(have_attributes(consumer_name: "Baz", consumer_version_number: "baz-latest-dev-version"))
               expect(subject.all?(&:overall_latest?)).to be true
             end
           end

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

@@ -967,6 +967,9 @@ module PactBroker
           before do
             td.create_consumer("Consumer")
               .create_provider("Provider")
+              .create_consumer_version("0")
+              .create_consumer_version_tag("main")
+              .create_pact
               .create_consumer_version("1")
               .create_pact
               .create_provider("Another Provider")
@@ -997,6 +1000,36 @@ module PactBroker
               expect(pact.consumer_version.number).to eq("2")
             end
           end
+
+          context "with a tag" do
+            let(:pact) { Repository.new.search_for_latest_pact("Consumer", "Provider", "main") }
+
+            it "returns the latest" do
+              expect(pact.consumer_version.number).to eq("0")
+            end
+          end
+
+          context "untagged" do
+            before do
+              td.create_consumer("Foo")
+                .create_provider("Bar")
+                .create_consumer_version("0")
+                .create_consumer_version_tag("main")
+                .create_pact
+                .create_consumer_version("1")
+                .create_pact
+                .create_consumer_version("2")
+                .create_consumer_version_tag("main")
+                .create_pact
+
+            end
+
+            let(:pact) { Repository.new.search_for_latest_pact("Foo", "Bar", :untagged) }
+
+            it "returns the latest" do
+              expect(pact.consumer_version.number).to eq("1")
+            end
+          end
         end
       end
 

data/spec/lib/pact_broker/ui/view_models/index_item_spec.rb

@@ -26,7 +26,7 @@ module PactBroker
         its(:provider_name) { should eq "Provider Name"}
         its(:latest_pact_url) { should eq "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/latest" }
         its(:pact_url) { should eq "/pacts/provider/Provider%20Name/consumer/Consumer%20Name/version/1.2.3" }
-        its(:pact_matrix_url) { should eq "/matrix/provider/Provider%20Name/consumer/Consumer%20Name" }
+        its(:pact_matrix_url) { should eq "/matrix?q[][pacticipant]=Consumer+Name&q[][version]=1.2.3&q[][pacticipant]=Provider+Name&latestby=cvpv" }
         its(:consumer_group_url) { should eq "/pacticipants/Consumer%20Name" }
         its(:provider_group_url) { should eq "/pacticipants/Provider%20Name" }
 

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

@@ -21,7 +21,19 @@ module PactBroker
 
         let(:event_context) { { some: "data", consumer_version_selectors: [{ foo: "bar" }] } }
         let(:expected_event_context) { { some: "data", provider_version_tags: ["dev"] } }
-        let(:params) { { "success" => success, "providerApplicationVersion" => "4.5.6", "wip" => true, "pending" => is_pending, "testResults" => { "some" => "results" }} }
+        let(:params) do
+          {
+            "success" => success,
+            "providerApplicationVersion" => "4.5.6",
+            "wip" => true,
+            "pending" => is_pending,
+            "testResults" => { "some" => "results" },
+            "verifiedBy" => {
+              "implementation" => "Ruby",
+              "version" => "1234"
+            }
+          }
+        end
         let(:is_pending) { true }
         let(:success) { true }
         let(:pact) do
@@ -34,7 +46,7 @@ module PactBroker
         let(:create_verification) { subject.create 3, params, selected_pacts, event_context }
 
         it "logs the creation" do
-          expect(logger).to receive(:info).with(/.*verification.*3/, payload: {"providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true, "pending" => is_pending})
+          expect(logger).to receive(:info).with(/.*verification.*3/, payload: hash_including("providerApplicationVersion"=>"4.5.6", "success"=>true, "wip"=>true, "pending" => is_pending))
           create_verification
         end
 
@@ -47,6 +59,8 @@ module PactBroker
           expect(verification.test_results).to eq "some" => "results"
           expect(verification.consumer_version_selector_hashes).to eq [{ foo: "bar" }]
           expect(verification.tag_names).to eq ["dev"]
+          expect(verification.verified_by_implementation).to eq "Ruby"
+          expect(verification.verified_by_version).to eq "1234"
         end
 
         it "sets the pact content for the verification" do
@@ -101,7 +115,7 @@ module PactBroker
             expect(subject).to eq [
               RequiredVerification.new(
                 provider_version: td.find_version("Bar", "1"),
-                provider_version_descriptions: ["latest version from main branch"]
+                provider_version_descriptions: ["latest from main branch"]
               )
             ]
           end
@@ -139,7 +153,7 @@ module PactBroker
             expect(subject).to eq [
               RequiredVerification.new(
                 provider_version: td.find_version("Bar", "1"),
-                provider_version_descriptions: ["currently deployed version (test)"]
+                provider_version_descriptions: ["deployed in test"]
               )
             ]
           end
@@ -179,7 +193,7 @@ module PactBroker
             expect(subject).to eq [
               RequiredVerification.new(
                 provider_version: td.find_version("Bar", "1"),
-                provider_version_descriptions: ["currently released version (test)"]
+                provider_version_descriptions: ["released in test"]
               )
             ]
           end
@@ -221,9 +235,9 @@ module PactBroker
               RequiredVerification.new(
               provider_version: td.find_version("Bar", "1"),
               provider_version_descriptions: [
-                "latest version from main branch",
-                "currently deployed version (test)",
-                "currently released version (test)"
+                "latest from main branch",
+                "deployed in test",
+                "released in test"
               ])
             ]
           end

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

@@ -8,7 +8,8 @@ module PactBroker
           ["202326572516dea6998a7f311fcaa161c0768fc2", "2023265"],
           ["1.2.3+areallyreallyreallylongexplanation", "1.2.3+areallyreallyreallylongexplanation"],
           ["2516dea6998a7f", "2516dea6998a7f"],
-          ["1.2.3+202326572516dea6998a7f311fcaa161c0768fc2", "1.2.3+2023265"]
+          ["1.2.3+202326572516dea6998a7f311fcaa161c0768fc2", "1.2.3+2023265"],
+          ["this-is-very-long-text-this-is-very-long-text-this-is-very-long-text-this-is-very-long-text", "this-is-very-long-text-this-is-very-lon…-long-text"]
         ]
 
         TEST_CASES.each do |(input, output)|

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

@@ -75,7 +75,7 @@ module PactBroker
         end
 
         let(:consumer_version) do
-          double("version", tags: consumer_tags, branch: "consumer-branch")
+          double("version", tags: consumer_tags, branch_names: ["foo-branch","consumer-branch"])
         end
 
         let(:provider_tags) do
@@ -94,7 +94,7 @@ module PactBroker
           [ double("label", name: "foo"), double("label", name: "bar") ]
         end
 
-        let(:webhook_context) { { base_url: base_url, event_name: "something" } }
+        let(:webhook_context) { { base_url: base_url, event_name: "something", build_url: "http://build"} }
 
         let(:nil_pact) { nil }
         let(:nil_verification) { nil }
@@ -140,6 +140,7 @@ module PactBroker
           ["${pactbroker.consumerVersionBranch}", "consumer-branch", :pact_with_successful_verification, :verification],
           ["${pactbroker.consumerLabels}", "foo, bar", :pact_with_successful_verification, :verification],
           ["${pactbroker.providerLabels}", "finance, IT", :pact, :nil_verification],
+          ["${pactbroker.buildUrl}", "http://build", :nil_pact, :nil_verification]
         ]
 
         TEST_CASES.each do | (template, expected_output, pact_var_name, verification_var_name) |

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

@@ -23,6 +23,8 @@ module PactBroker
       let(:webhook) { Domain::Webhook.new(request: request, events: events) }
       let(:consumer) { td.create_pacticipant("Consumer").and_return(:pacticipant) }
       let(:provider) { td.create_pacticipant("Provider").and_return(:pacticipant) }
+      let(:webhook_consumer) { Domain::WebhookPacticipant.new(name: consumer.name) }
+      let(:webhook_provider) { Domain::WebhookPacticipant.new(name: provider.name) }
       let(:uuid) { "the-uuid" }
       let(:created_webhook_record) { ::DB::PACT_BROKER_DB[:webhooks].order(:id).last }
       let(:created_events) { ::DB::PACT_BROKER_DB[:webhook_events].where(webhook_id: created_webhook_record[:id]).order(:name).all }
@@ -57,13 +59,13 @@ module PactBroker
         end
 
         context "when consumer and provider domain objects are set on the object rather than passed in" do
-          let(:webhook) { Domain::Webhook.new(request: request, events: events, consumer: consumer, provider: provider) }
+          let(:webhook) { Domain::Webhook.new(request: request, events: events, consumer: webhook_consumer, provider: webhook_provider) }
 
           subject { Repository.new.create(uuid, webhook, nil, nil) }
 
           it "sets the consumer and provider relationships" do
-            expect(subject.consumer.id).to eq consumer.id
-            expect(subject.provider.id).to eq provider.id
+            expect(subject.consumer.name).to eq consumer.name
+            expect(subject.provider.name).to eq provider.name
           end
         end
       end
@@ -185,12 +187,10 @@ module PactBroker
           end
 
           it "returns a webhook with the consumer set" do
-            expect(subject.consumer.id).to eq consumer.id
             expect(subject.consumer.name).to eq consumer.name
           end
 
           it "returns a webhook with the provider set" do
-            expect(subject.provider.id).to eq provider.id
             expect(subject.provider.name).to eq provider.name
           end
 
@@ -286,7 +286,7 @@ module PactBroker
         let(:new_event) do
           PactBroker::Webhooks::WebhookEvent.new(name: "something_else")
         end
-        let(:new_consumer) { PactBroker::Domain::Pacticipant.new(name: "Foo2") }
+        let(:new_consumer) { Domain::WebhookPacticipant.new(name: "Foo2") }
         let(:new_webhook) do
           PactBroker::Domain::Webhook.new(
             consumer: new_consumer,
@@ -423,11 +423,13 @@ module PactBroker
         subject { Repository.new.find_webhooks_to_trigger(consumer: td.consumer, provider: td.provider, event_name: "contract_published") }
 
         it "does not use a policy" do
-          td.create_webhook(event_names: ["contract_published"], enabled: enabled)
+          td.create_webhook(event_names: ["contract_published"], enabled: enabled, description: "Enabled webhook")
             .create_consumer("Foo")
             .create_provider("Bar")
           expect(PactBroker).to_not receive(:policy_scope!)
-          expect(subject.size).to eq 1
+          is_expected.to contain_exactly(
+            have_attributes(description: "Enabled webhook")
+          )
         end
 
         context "when the webhook is disabled" do
@@ -437,21 +439,25 @@ module PactBroker
               .create_provider("Bar")
           end
           let(:enabled) { false }
-          its(:size) { is_expected.to eq 0 }
+
+          it "finds no webhooks to trigger" do
+            is_expected.to be_empty
+          end
         end
 
         context "when the webhook is specified for a consumer and all providers" do
           before do
             td.create_consumer("Foo1")
               .create_provider("Bar1")
-              .create_webhook(provider: nil, event_names: ["contract_published"])
+              .create_webhook(provider: nil, event_names: ["contract_published"], description: "Right webhook")
           end
 
-          its(:size) { is_expected.to eq 1 }
+          let(:webhook_consumer) { Domain::WebhookPacticipant.new(name: td.consumer.name) }
 
-          it "returns the right webhook" do
-            expect(subject.first.consumer).to eq td.consumer
-            expect(subject.first.provider).to be nil
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Right webhook")
+            )
           end
         end
 
@@ -463,7 +469,144 @@ module PactBroker
               .create_provider("Bar3")
           end
 
-          its(:size) { is_expected.to eq 0 }
+          it "finds no webhooks to trigger" do
+            is_expected.to be_empty
+          end
+        end
+
+        context "when the webhook is specified for matching consumer label" do
+          before do
+            td.create_webhook(
+                event_names: ["contract_published"],
+                consumer_label: "my_label",
+                description: "Labeled webhook"
+              )
+              .create_consumer("Consumer")
+              .create_label("my_label")
+              .create_provider("Provider")
+          end
+
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Labeled webhook")
+            )
+          end
+        end
+
+        context "when the webhook is specified for matching consumer label and specific provider" do
+          before do
+            td.create_provider("Provider")
+              .create_webhook(
+                event_names: ["contract_published"],
+                consumer_label: "my_label",
+                description: "Labeled webhook"
+              )
+              .create_consumer("Consumer")
+              .create_label("my_label")
+          end
+
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Labeled webhook")
+            )
+          end
+        end
+
+        context "when the webhook is specified for consumer label that does not match" do
+          before do
+            td.create_webhook(event_names: ["contract_published"], consumer_label: "my_label")
+              .create_consumer("Consumer")
+              .create_label("other_label")
+              .create_provider("Provider")
+          end
+
+          it "finds no webhooks to trigger" do
+            is_expected.to be_empty
+          end
+        end
+
+        context "when the webhook is specified for matching provider label" do
+          before do
+            td.create_webhook(
+                event_names: ["contract_published"],
+                provider_label: "my_label",
+                description: "Labeled webhook"
+              )
+              .create_consumer("Consumer")
+              .create_provider("Provider")
+              .create_label("my_label")
+          end
+
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Labeled webhook")
+            )
+          end
+        end
+
+        context "when the webhook is specified for matching provider label and specific consumer" do
+          before do
+            td.create_consumer("Consumer")
+              .create_webhook(
+                event_names: ["contract_published"],
+                provider_label: "my_label",
+                description: "Labeled webhook"
+              )
+              .create_provider("Provider")
+              .create_label("my_label")
+          end
+
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Labeled webhook")
+            )
+          end
+        end
+
+        context "when the webhook is specified for provider label that does not match" do
+          before do
+            td.create_webhook(event_names: ["contract_published"], provider_label: "my_label")
+              .create_consumer("Consumer")
+              .create_provider("Provider")
+              .create_label("other_label")
+          end
+
+          it "find no webhooks to trigger" do
+            is_expected.to be_empty
+          end
+        end
+
+        context "when the webhook is specified for consumer and provider label" do
+          before do
+            td.create_webhook(
+                event_names: ["contract_published"],
+                consumer_label: "clabel",
+                provider_label: "plabel",
+                description: "Labeled webhook"
+              )
+              .create_webhook(
+                event_names: ["contract_published"],
+                consumer_label: "clabel",
+                provider_label: "plabel2",
+                description: "Labeled consumer webhook"
+              )
+              .create_webhook(
+                event_names: ["contract_published"],
+                consumer_label: "clabel2",
+                provider_label: "plabel",
+                description: "Labeled provider webhook"
+              )
+              .create_consumer("Consumer")
+              .create_label("clabel")
+              .create_provider("Provider")
+              .create_label("plabel")
+          end
+
+          it "finds one webhook to trigger" do
+            is_expected.to contain_exactly(
+              have_attributes(description: "Labeled webhook")
+            )
+          end
         end
       end