pact_broker 2.85.1 → 2.86.0

data/spec/lib/pact_broker/api/contracts/webhook_contract_spec.rb

@@ -85,6 +85,31 @@ module PactBroker
             end
           end
 
+          context "with a consumer label" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["consumer"].delete("name")
+                hash["consumer"]["label"] = "my_label"
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a consumer label and name provided" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["consumer"]["label"] = "my_label"
+              end
+            end
+
+            it "contains consumer.label error" do
+              expect(subject.errors.messages).to eq({:'consumer.label' => ["cannot be provided"]})
+            end
+          end
+
           context "with a nil provider name" do
             let(:json) do
               valid_webhook_with do |hash|
@@ -131,6 +156,31 @@ module PactBroker
             end
           end
 
+          context "with provider label" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["provider"].delete("name")
+                hash["provider"]["label"] = "my_label"
+              end
+            end
+
+            it "contains no errors" do
+              expect(subject.errors).to be_empty
+            end
+          end
+
+          context "with a provider label and name" do
+            let(:json) do
+              valid_webhook_with do |hash|
+                hash["provider"]["label"] = "my_label"
+              end
+            end
+
+            it "contains provider.label error" do
+              expect(subject.errors.messages).to eq({:'provider.label' => ["cannot be provided"]})
+            end
+          end
+
           context "with no request defined" do
             let(:json) { {}.to_json }
 

data/spec/lib/pact_broker/api/decorators/verification_decorator_spec.rb

@@ -20,7 +20,9 @@ module PactBroker
             pact_version_sha: "1234",
             latest_pact_publication: pact_publication,
             execution_date: DateTime.now,
-            provider_version_tags: provider_version_tags)
+            provider_version_tags: provider_version_tags,
+            verified_by_implementation: "Ruby",
+            verified_by_version: "1234")
         end
 
         let(:pact_publication) do
@@ -67,6 +69,11 @@ module PactBroker
         it "includes a link to the triggered webhooks" do
           expect(subject[:_links][:'pb:triggered-webhooks'][:href]).to eq "http://triggered-webhooks"
         end
+
+        it "includes the framework that did the verification" do
+          expect(subject[:verifiedBy][:implementation]).to eq "Ruby"
+          expect(subject[:verifiedBy][:version]).to eq "1234"
+        end
       end
     end
   end

data/spec/lib/pact_broker/api/decorators/verification_summary_decorator_spec.rb

@@ -21,7 +21,9 @@ module PactBroker
             latest_pact_publication: pact,
             test_results: nil,
             execution_date: DateTime.now,
-            provider_version_tags: provider_version_tags)
+            provider_version_tags: provider_version_tags,
+            verified_by_implementation: "Ruby",
+            verified_by_version: "1234")
         end
 
         let(:pact_version) do

data/spec/lib/pact_broker/api/decorators/webhook_decorator_spec.rb

@@ -20,8 +20,8 @@ module PactBroker
           Webhooks::WebhookRequestTemplate.new(request)
         end
 
-        let(:consumer) { Domain::Pacticipant.new(name: "Consumer") }
-        let(:provider) { Domain::Pacticipant.new(name: "Provider") }
+        let(:consumer) { Domain::WebhookPacticipant.new(name: "Consumer") }
+        let(:provider) { Domain::WebhookPacticipant.new(name: "Provider") }
         let(:event)    { Webhooks::WebhookEvent.new(name: "something_happened") }
         let(:created_at) { DateTime.now }
         let(:updated_at) { created_at + 1 }
@@ -193,8 +193,8 @@ module PactBroker
           context "when the decorated object has a consumer/provider but the incoming JSON does not" do
             let(:webhook) do
               Domain::Webhook.new(
-                consumer: Domain::Pacticipant.new(name: "consumer"),
-                provider: Domain::Pacticipant.new(name: "provider")
+                consumer: Domain::WebhookPacticipant.new(name: "consumer"),
+                provider: Domain::WebhookPacticipant.new(name: "provider")
               )
             end
 

data/spec/lib/pact_broker/config/runtime_configuration_documentation_spec.rb

@@ -0,0 +1,30 @@
+require "pact_broker/config/runtime_configuration"
+
+module PactBroker
+  module Config
+    describe RuntimeConfiguration do
+      ATTRIBUTES = RuntimeConfiguration.config_attributes
+      DOCUMENTATION = File.read("docs/configuration.yml")
+      DOCUMENTED_ATTRIBUTES = YAML.load(DOCUMENTATION)["groups"].flat_map{ | group | group["vars"].keys.collect(&:to_sym) }
+      DELIBERATELY_UNDOCUMENTED_ATTRIBUTES = [
+        :warning_error_class_names,
+        :log_configuration_on_startup,
+        :use_hal_browser,
+        :use_rack_protection,
+        :use_case_sensitive_resource_names,
+        :order_versions_by_date,
+        :base_equality_only_on_content_that_affects_verification_results,
+        :semver_formats,
+        :seed_example_data,
+        :use_first_tag_as_branch_time_limit,
+        :validate_database_connection_config
+      ]
+
+      (ATTRIBUTES - DELIBERATELY_UNDOCUMENTED_ATTRIBUTES).each do | attribute_name |
+        it "has documentation for #{attribute_name}" do
+          expect(DOCUMENTED_ATTRIBUTES & [attribute_name]).to include(attribute_name)
+        end
+      end
+    end
+  end
+end

data/spec/lib/pact_broker/deployments/environment_service_spec.rb

@@ -2,7 +2,7 @@ require "pact_broker/deployments/environment_service"
 
 module PactBroker
   module Deployments
-    module EnvironmentService
+    describe EnvironmentService do
       describe ".create" do
         let(:environment) do
           Environment.new(

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/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_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/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

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