pact_broker 2.85.1 → 2.86.0

data/lib/pact_broker/pacts/pact_version.rb

@@ -1,6 +1,5 @@
 require "sequel"
 require "pact_broker/repositories/helpers"
-require "pact_broker/verifications/latest_verification_for_pact_version"
 require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
 require "pact_broker/pacts/content"
 
@@ -16,6 +15,30 @@ module PactBroker
       associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
       associate(:many_to_many, :consumer_versions, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id, order: :order)
 
+      one_to_one(:latest_main_branch_verification,
+        class: "PactBroker::Domain::Verification",
+        read_only: true,
+        dataset: lambda {
+          providers_join = {
+            Sequel[:providers][:id] => Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_id]
+          }
+
+          branch_versions_join = {
+            Sequel[:latest_verification_id_for_pact_version_and_provider_version][:provider_version_id] => Sequel[:branch_versions][:version_id],
+            Sequel[:providers][:main_branch] => Sequel[:branch_versions][:branch_name]
+          }
+          max_verification_id_for_pact_version =  PactBroker::Verifications::LatestVerificationIdForPactVersionAndProviderVersion
+                                                    .join(:pacticipants, providers_join, { table_alias: :providers })
+                                                    .join(:branch_versions, branch_versions_join)
+                                                    .select(Sequel.function(:max, :verification_id))
+                                                    .where(pact_version_id: id)
+          PactBroker::Domain::Verification.where(id: max_verification_id_for_pact_version)
+        },
+        key: :pact_version_id,
+        primary_key: :id,
+        eager_block: lambda { | ds | ds.from_provider_main_branch.latest_by_pact_version }
+      )
+
       one_to_one(:latest_verification,
         class: "PactBroker::Domain::Verification",
         read_only: true,

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -154,8 +154,8 @@ module PactBroker
 
       def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
         selectors.collect do | selector |
-          query = scope_for(LatestTaggedPactPublications).provider(provider_name).where(tag_name: selector.fallback_tag)
-          query = query.consumer(selector.consumer) if selector.consumer
+          query = scope_for(PactPublication).for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
+          query = query.for_consumer_name(selector.consumer) if selector.consumer
           query.all
             .collect do | latest_tagged_pact_publication |
               pact_publication = unscoped(PactPublication).find(id: latest_tagged_pact_publication.id)

data/lib/pact_broker/pacts/repository.rb

@@ -4,10 +4,6 @@ require "pact_broker/logging"
 require "pact_broker/pacts/generate_sha"
 require "pact_broker/pacts/pact_publication"
 require "pact_broker/pacts/pact_version"
-require "pact_broker/pacts/all_pact_publications"
-require "pact_broker/pacts/latest_pact_publications_by_consumer_version"
-require "pact_broker/pacts/latest_pact_publications"
-require "pact_broker/pacts/latest_tagged_pact_publications"
 require "pact/shared/json_differ"
 require "pact_broker/domain"
 require "pact_broker/pacts/parse"
@@ -177,17 +173,19 @@ module PactBroker
 
       # Returns latest pact version for the consumer_version_number
       def find_by_consumer_version consumer_name, consumer_version_number
-        scope_for(LatestPactPublicationsByConsumerVersion)
-          .consumer(consumer_name)
-          .consumer_version_number(consumer_version_number)
+        scope_for(PactPublication)
+          .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
+          .remove_overridden_revisions_from_complete_query
           .collect(&:to_domain_with_content)
       end
 
       def find_by_version_and_provider version_id, provider_id
-        scope_for(LatestPactPublicationsByConsumerVersion)
+        scope_for(PactPublication)
           .eager(:tags)
           .where(consumer_version_id: version_id, provider_id: provider_id)
-          .limit(1).collect(&:to_domain_with_content)[0]
+          .remove_overridden_revisions_from_complete_query
+          .limit(1)
+          .collect(&:to_domain_with_content)[0]
       end
 
       def find_latest_pacts
@@ -200,30 +198,35 @@ module PactBroker
       end
 
       def find_latest_pact(consumer_name, provider_name, tag = nil)
-        query = scope_for(LatestPactPublicationsByConsumerVersion)
+        query = scope_for(PactPublication)
           .select_all_qualified
-          .consumer(consumer_name)
-          .provider(provider_name)
+          .for_consumer_name(consumer_name)
+          .for_provider_name(provider_name)
+          .remove_overridden_revisions
         if tag == :untagged
           query = query.untagged
         elsif tag
-          query = query.tag(tag)
+          query = query.for_consumer_version_tag_all_revisions(tag)
         end
-        query.latest.all.collect(&:to_domain_with_content)[0]
+        query.latest_by_consumer_version_order.all.collect(&:to_domain_with_content)[0]
       end
 
       # Allows optional consumer_name and provider_name
       def search_for_latest_pact(consumer_name, provider_name, tag = nil)
-        query = scope_for(LatestPactPublicationsByConsumerVersion).select_all_qualified
-        query = query.consumer(consumer_name) if consumer_name
-        query = query.provider(provider_name) if provider_name
+        query = scope_for(PactPublication).select_all_qualified
+        query = query.for_consumer_name(consumer_name) if consumer_name
+        query = query.for_provider_name(provider_name) if provider_name
 
         if tag == :untagged
           query = query.untagged
         elsif tag
-          query = query.tag(tag)
+          query = query.for_consumer_version_tag_all_revisions(tag)
         end
-        query.latest.all.collect(&:to_domain_with_content)[0]
+        query
+          .remove_overridden_revisions_from_complete_query
+          .latest_by_consumer_version_order
+          .all
+          .collect(&:to_domain_with_content)[0]
       end
 
       # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
@@ -279,34 +282,39 @@ module PactBroker
       end
 
       def find_previous_pact pact, tag = nil
-        query = scope_for(LatestPactPublicationsByConsumerVersion)
+        query = scope_for(PactPublication)
+            .remove_overridden_revisions
             .eager(:tags)
-            .consumer(pact.consumer.name)
-            .provider(pact.provider.name)
+            .for_consumer_name(pact.consumer.name)
+            .for_provider_name(pact.provider.name)
 
         if tag == :untagged
           query = query.untagged
         elsif tag
-          query = query.tag(tag)
+          query = query.for_consumer_version_tag_all_revisions(tag)
         end
 
-        query.consumer_version_order_before(pact.consumer_version.order)
-            .latest.collect(&:to_domain_with_content)[0]
+        query
+          .consumer_version_order_before(pact.consumer_version.order)
+          .latest_by_consumer_version_order
+          .collect(&:to_domain_with_content)[0]
       end
 
       def find_next_pact pact
-        scope_for(LatestPactPublicationsByConsumerVersion)
+        scope_for(PactPublication)
           .eager(:tags)
-          .consumer(pact.consumer.name)
-          .provider(pact.provider.name)
+          .for_consumer_name(pact.consumer.name)
+          .for_provider_name(pact.provider.name)
+          .remove_overridden_revisions
           .consumer_version_order_after(pact.consumer_version.order)
-          .earliest.collect(&:to_domain_with_content)[0]
+          .earliest
+          .collect(&:to_domain_with_content)[0]
       end
 
       def find_previous_distinct_pact pact
         previous, current = nil, pact
         loop do
-          previous = find_previous_distinct_pact_by_sha current
+          previous = find_previous_distinct_pact_by_sha(current)
           return previous if previous.nil? || different?(current, previous)
           current = previous
         end
@@ -329,20 +337,14 @@ module PactBroker
       private
 
       def find_previous_distinct_pact_by_sha pact
-        current_pact_content_sha =
-          scope_for(LatestPactPublicationsByConsumerVersion).select(:pact_version_sha)
-          .consumer(pact.consumer.name)
-          .provider(pact.provider.name)
-          .consumer_version_number(pact.consumer_version_number)
-          .limit(1)
-
-        scope_for(LatestPactPublicationsByConsumerVersion)
+        pact_version = PactVersion.for_pact_domain(pact)
+        scope_for(PactPublication)
           .eager(:tags)
-          .consumer(pact.consumer.name)
-          .provider(pact.provider.name)
+          .for_consumer_name(pact.consumer.name)
+          .for_provider_name(pact.provider.name)
           .consumer_version_order_before(pact.consumer_version.order)
-          .where(Sequel.lit("pact_version_sha != ?", current_pact_content_sha))
-          .latest
+          .exclude(pact_version_id: pact_version.id)
+          .latest_by_consumer_version_order
           .collect(&:to_domain_with_content)[0]
       end
 
@@ -367,14 +369,15 @@ module PactBroker
         ).upsert
       end
 
-      def find_all_database_versions_between(consumer_name, options, base_class = LatestPactPublicationsByConsumerVersion)
+      def find_all_database_versions_between(consumer_name, options)
         provider_name = options.fetch(:and)
 
-        query = scope_for(base_class)
-          .consumer(consumer_name)
-          .provider(provider_name)
+        query = scope_for(PactPublication)
+          .for_consumer_name(consumer_name)
+          .for_provider_name(provider_name)
+          .remove_overridden_revisions
 
-        query = query.tag(options[:tag]) if options[:tag]
+        query = query.for_consumer_version_tag_all_revisions(options[:tag]) if options[:tag]
         query
       end
 

data/lib/pact_broker/test/http_test_data_builder.rb

@@ -102,6 +102,13 @@ module PactBroker
         self
       end
 
+      def create_label(name, label)
+        puts "Creating label '#{label}' for #{name}"
+        client.put("pacticipants/#{encode(name)}/labels/#{encode(label)}", {}).tap { |response| check_for_error(response) }
+        separate
+        self
+      end
+
       def publish_contract(consumer: last_consumer_name, consumer_version:, provider: last_provider_name, content_id:, tag: nil, branch: nil)
         content = generate_content(consumer, provider, content_id)
         request_body_hash = {
@@ -206,26 +213,35 @@ module PactBroker
         self
       end
 
-      def create_global_webhook_for_event(uuid: nil, url: "https://postman-echo.com/post", body: nil, event_name: )
-        puts "Creating global webhook for contract changed event with uuid #{uuid}"
+      def create_global_webhook_for_event(**kwargs)
+        create_webhook_for_event(**kwargs)
+      end
+
+      def create_webhook_for_event(uuid: nil, url: "https://postman-echo.com/post", body: nil, provider: nil, consumer: nil, event_name:)
+        require "securerandom"
+        webhook_prefix = "global " if provider.nil? && consumer.nil?
+        puts "Creating #{webhook_prefix}webhook for contract changed event with uuid #{uuid}"
         uuid ||= SecureRandom.uuid
         default_body = {
-          "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
-          "providerVersionBranch" => "${pactbroker.providerVersionBranch}",
+          "eventName" => "${pactbroker.eventName}",
+          "consumerName" => "${pactbroker.consumerName}",
           "consumerVersionNumber" => "${pactbroker.consumerVersionNumber}",
-          "consumerVersionBranch" => "${pactbroker.consumerVersionBranch}"
+          "providerVersionBranch" => "${pactbroker.providerVersionBranch}",
+          "providerName" => "${pactbroker.providerName}",
+          "providerVersionNumber" => "${pactbroker.providerVersionNumber}",
+          "consumerVersionBranch" => "${pactbroker.consumerVersionBranch}",
         }
         request_body = {
-          "description" => "A webhook for all consumers and providers",
-          "events" => [{
-            "name" => event_name
-          }],
+          "consumer" => consumer,
+          "provider" => provider,
+          "description" => webhook_description(consumer, provider),
+          "events" => Array(event_name).map { |name| {"name" => name} },
           "request" => {
             "method" => "POST",
             "url" => url,
             "body" => body || default_body
           }
-        }
+        }.compact
         path = "webhooks/#{uuid}"
         client.put(path, request_body.to_json).tap { |response| check_for_error(response) }
         separate
@@ -333,6 +349,17 @@ module PactBroker
 
       private
 
+      def webhook_description(consumer, provider)
+        return "A webhook for all consumers and providers" if consumer.nil? && provider.nil?
+
+        suffix = {consumer: consumer, provider: provider}.compact.map do |name, pacticipant|
+          desc = pacticipant.compact.map { |k, v| "#{k}: '#{v}'"}.first
+          "#{name}s by #{desc}"
+        end
+
+        "A webhook for #{suffix.join(' and ')}"
+      end
+
       def publish_verification_results(url_of_pact_to_verify, provider, provider_version, provider_version_tag, provider_version_branch, success)
         [*provider_version_tag].each do | tag |
           create_tag(pacticipant: provider, version: provider_version, tag: tag)

data/lib/pact_broker/test/test_data_builder.rb

@@ -269,11 +269,10 @@ module PactBroker
         self
       end
 
-      # rubocop: disable Metrics/CyclomaticComplexity
       def create_webhook parameters = {}
         params = parameters.dup
-        consumer = params.key?(:consumer) ? params.delete(:consumer) : @consumer
-        provider = params.key?(:provider) ? params.delete(:provider) : @provider
+        consumer, webhook_consumer = webhook_pacticipant(:consumer, params)
+        provider, webhook_provider = webhook_pacticipant(:provider, params)
         uuid = params[:uuid] || PactBroker::Webhooks::Service.next_uuid
         enabled = params.key?(:enabled) ? params.delete(:enabled) : true
         event_params = if params[:event_names]
@@ -282,9 +281,17 @@ module PactBroker
                          params[:events] || [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }]
                        end
         events = event_params.collect{ |e| PactBroker::Webhooks::WebhookEvent.new(e) }
-        template_params = { method: "POST", url: "http://example.org", headers: {"Content-Type" => "application/json"}, username: params[:username], password: params[:password]}
+        template_params = { method: "POST", url: "http://example.org", headers: {"Content-Type" => "application/json"}, username: params[:username], password: params[:password] }
         request = PactBroker::Webhooks::WebhookRequestTemplate.new(template_params.merge(params))
-        @webhook = PactBroker::Webhooks::Repository.new.create uuid, PactBroker::Domain::Webhook.new(request: request, events: events, description: params[:description], enabled: enabled), consumer, provider
+        new_webhook = PactBroker::Domain::Webhook.new(
+          request: request,
+          events: events,
+          description: params[:description],
+          enabled: enabled,
+          consumer: webhook_consumer,
+          provider: webhook_provider
+        )
+        @webhook = PactBroker::Webhooks::Repository.new.create uuid, new_webhook, consumer, provider
         self
       end
       # rubocop: enable Metrics/CyclomaticComplexity
@@ -597,6 +604,16 @@ module PactBroker
            "random" => rand
          }.to_json
       end
+
+      def webhook_pacticipant(name, params)
+        pacticipant = params.key?(name) ? params.delete(name) : instance_variable_get(:"@#{name}")
+        label = params.delete(:"#{name}_label")
+        if pacticipant
+          [pacticipant, Domain::WebhookPacticipant.new(name: pacticipant.name)]
+        elsif label
+          [nil, Domain::WebhookPacticipant.new(label: label)]
+        end
+      end
     end
   end
 end

data/lib/pact_broker/verifications/repository.rb

@@ -1,6 +1,5 @@
 require "sequel"
 require "pact_broker/domain/verification"
-require "pact_broker/verifications/latest_verification_for_pact_version"
 require "pact_broker/verifications/sequence"
 require "pact_broker/verifications/latest_verification_id_for_pact_version_and_provider_version"
 
@@ -61,6 +60,10 @@ module PactBroker
         PactBroker::Pacts::PactPublication.where(id: pact.id).single_record.latest_verification
       end
 
+      def find_latest_from_main_branch_for_pact(pact)
+        PactBroker::Pacts::PactPublication.where(id: pact.id).single_record.latest_main_branch_verification
+      end
+
       def any_verifications?(consumer, provider)
         PactBroker::Domain::Verification.where(consumer_id: consumer.id, provider_id: provider.id).any?
       end
@@ -73,7 +76,7 @@ module PactBroker
       end
 
       def find_latest_verifications_for_consumer_version consumer_name, consumer_version_number
-        # Use LatestPactPublicationsByConsumerVersion not AllPactPublcations because we don't
+        # Use remove_verifications_for_overridden_consumer_versions because we don't
         # want verifications for shadowed revisions as it would be misleading.
         PactBroker::Domain::Verification
           .select_all_qualified

data/lib/pact_broker/verifications/service.rb

@@ -21,12 +21,13 @@ module PactBroker
       using PactBroker::HashRefinements
       extend PactBroker::Events::Publisher
 
-      delegate [:any_verifications?] => :verification_repository
+      delegate [:any_verifications?, :find_latest_from_main_branch_for_pact] => :verification_repository
 
       def next_number
         verification_repository.next_number
       end
 
+      # TODO use a decorator instead of passing in params, srsly, Beth
       # verified_pacts is an array of SelectedPact objects
       def create next_verification_number, params, verified_pacts, event_context
         first_verified_pact = verified_pacts.first
@@ -37,6 +38,8 @@ module PactBroker
         verification.wip = params.fetch("wip")
         verification.pact_pending = params.fetch("pending")
         verification.number = next_verification_number
+        verification.verified_by_implementation = params.dig("verifiedBy", "implementation")
+        verification.verified_by_version = params.dig("verifiedBy", "version")
         verification.consumer_version_selector_hashes = event_context[:consumer_version_selectors]
         pact_version = pact_repository.find_pact_version(first_verified_pact.consumer, first_verified_pact.provider, first_verified_pact.pact_version_sha)
         verification = verification_repository.create(verification, provider_version_number, pact_version)

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.85.1"
+  VERSION = "2.86.0"
 end

data/lib/pact_broker/webhooks/event_listener.rb

@@ -18,14 +18,16 @@ module PactBroker
       end
 
       def contract_published(params)
-        handle_event_for_webhook(PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, params)
+        main_branch_verification = verification_service.find_latest_from_main_branch_for_pact(params.fetch(:pact))
+        handle_event_for_webhook(PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, { verification: main_branch_verification }.compact.merge(params))
         if verification_service.calculate_required_verifications_for_pact(params.fetch(:pact)).any?
           handle_event_for_webhook(PactBroker::Webhooks::WebhookEvent::CONTRACT_REQUIRING_VERIFICATION_PUBLISHED, params)
         end
       end
 
       def contract_content_changed(params)
-        handle_event_for_webhook(PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, params)
+        main_branch_verification = verification_service.find_latest_from_main_branch_for_pact(params.fetch(:pact))
+        handle_event_for_webhook(PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, { verification: main_branch_verification }.compact.merge(params))
       end
 
       def contract_content_unchanged(params)

data/lib/pact_broker/webhooks/pact_and_verification_parameters.rb

@@ -41,6 +41,7 @@ module PactBroker
         CURRENTLY_DEPLOYED_PROVIDER_VERSION_NUMBER
       ]
 
+      # TODO change this verification to the latest main branch
       def initialize(pact, trigger_verification, webhook_context)
         @pact = pact
         @verification = trigger_verification || (pact && pact.latest_verification)

data/lib/pact_broker/webhooks/repository.rb

@@ -17,8 +17,8 @@ module PactBroker
       include Repositories
 
       def create uuid, webhook, consumer, provider
-        consumer = pacticipant_repository.find_by_name(webhook.consumer.name) if webhook.consumer
-        provider = pacticipant_repository.find_by_name(webhook.provider.name) if webhook.provider
+        consumer = find_pacticipant_by_name(webhook.consumer) || consumer
+        provider = find_pacticipant_by_name(webhook.provider) || provider
         db_webhook = Webhook.from_domain webhook, consumer, provider
         db_webhook.uuid = uuid
         db_webhook.save
@@ -36,8 +36,8 @@ module PactBroker
       # policy applied at resource level
       def update_by_uuid uuid, webhook
         existing_webhook = deliberately_unscoped(Webhook).find(uuid: uuid)
-        existing_webhook.consumer_id = webhook.consumer ? pacticipant_repository.find_by_name(webhook.consumer.name).id : nil
-        existing_webhook.provider_id = webhook.provider ? pacticipant_repository.find_by_name(webhook.provider.name).id : nil
+        existing_webhook.consumer_id = find_pacticipant_by_name(webhook.consumer)&.id
+        existing_webhook.provider_id = find_pacticipant_by_name(webhook.provider)&.id
         existing_webhook.update_from_domain(webhook).save
         existing_webhook.events.collect(&:delete)
         (webhook.events || []).each do | webhook_event |
@@ -187,6 +187,12 @@ module PactBroker
 
       private
 
+      def find_pacticipant_by_name(pacticipant)
+        return unless pacticipant&.name
+
+        pacticipant_repository.find_by_name(pacticipant.name)
+      end
+
       def deliberately_unscoped(scope)
         scope
       end