pact_broker 2.31.0 → 2.32.0

data/lib/pact_broker/index/service.rb

@@ -19,6 +19,9 @@ module PactBroker
           .eager(:latest_triggered_webhooks)
           .eager(:webhooks)
 
+        rows = rows.consumer(options[:consumer_name]) if options[:consumer_name]
+        rows = rows.provider(options[:provider_name]) if options[:provider_name]
+
         if !options[:tags]
           rows = rows.where(consumer_version_tag_name: nil)
         else

data/lib/pact_broker/integrations/integration.rb

@@ -0,0 +1,10 @@
+require 'pact_broker/db'
+
+module PactBroker
+  module Integrations
+    class Integration < Sequel::Model
+      associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
+      associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
+    end
+  end
+end

data/lib/pact_broker/integrations/service.rb

@@ -1,6 +1,7 @@
 require 'pact_broker/services'
 require 'pact_broker/repositories'
 require 'pact_broker/logging'
+require 'pact_broker/integrations/integration'
 
 module PactBroker
   module Integrations
@@ -9,6 +10,10 @@ module PactBroker
       extend PactBroker::Services
       include PactBroker::Logging
 
+      def self.find_all
+        PactBroker::Integrations::Integration.eager(:consumer).eager(:provider).all
+      end
+
       def self.delete(consumer_name, provider_name)
         consumer = pacticipant_service.find_pacticipant_by_name(consumer_name)
         provider = pacticipant_service.find_pacticipant_by_name(provider_name)

data/lib/pact_broker/matrix/parse_query.rb

@@ -27,6 +27,8 @@ module PactBroker
         end
         if params.key?('limit') && params['limit'] != ''
           options[:limit] = params['limit']
+        else
+          options[:limit] = "100"
         end
         if params.key?('latest') && params['latest'] != ''
           options[:latest] = params['latest'] == 'true'

data/lib/pact_broker/matrix/row.rb

@@ -25,6 +25,14 @@ module PactBroker
         include PactBroker::Repositories::Helpers
         include PactBroker::Logging
 
+        def consumer consumer_name
+          where(name_like(:consumer_name, consumer_name))
+        end
+
+        def provider provider_name
+          where(name_like(:provider_name, provider_name))
+        end
+
         def matching_selectors selectors
           if selectors.size == 1
             where_consumer_or_provider_is(selectors.first)

data/lib/pact_broker/matrix/service.rb

@@ -16,9 +16,8 @@ module PactBroker
         QueryResultsWithDeploymentStatusSummary.new(query_results.rows, query_results.selectors, query_results.options, query_results.resolved_selectors, query_results.integrations, deployment_status_summary)
       end
 
-      def find_for_consumer_and_provider params
+      def find_for_consumer_and_provider params, options = {}
         selectors = [{ pacticipant_name: params[:consumer_name] }, { pacticipant_name: params[:provider_name] }]
-        options = { latestby: 'cvpv' }
         find(selectors, options)
       end
 

data/lib/pact_broker/pacts/service.rb

@@ -40,20 +40,20 @@ module PactBroker
         pact_repository.delete(params)
       end
 
-      def create_or_update_pact params
+      def create_or_update_pact params, webhook_options
         provider = pacticipant_repository.find_by_name_or_create params[:provider_name]
         consumer = pacticipant_repository.find_by_name_or_create params[:consumer_name]
         consumer_version = version_repository.find_by_pacticipant_id_and_number_or_create consumer.id, params[:consumer_version_number]
         existing_pact = pact_repository.find_by_version_and_provider(consumer_version.id, provider.id)
 
         if existing_pact
-          update_pact params, existing_pact
+          update_pact params, existing_pact, webhook_options
         else
-          create_pact params, consumer_version, provider
+          create_pact params, consumer_version, provider, webhook_options
         end
       end
 
-      def merge_pact params
+      def merge_pact params, webhook_options
         provider = pacticipant_repository.find_by_name_or_create params[:provider_name]
         consumer = pacticipant_repository.find_by_name_or_create params[:consumer_name]
         consumer_version = version_repository.find_by_pacticipant_id_and_number_or_create consumer.id, params[:consumer_version_number]
@@ -61,7 +61,7 @@ module PactBroker
 
         params.merge!(json_content: Merger.merge_pacts(existing_pact.json_content, params[:json_content]))
 
-        update_pact params, existing_pact
+        update_pact params, existing_pact, webhook_options
       end
 
       def find_all_pact_versions_between consumer, options
@@ -113,7 +113,7 @@ module PactBroker
       private
 
       # Overwriting an existing pact with the same consumer/provider/consumer version number
-      def update_pact params, existing_pact
+      def update_pact params, existing_pact, webhook_options
         logger.info "Updating existing pact publication with params #{params.reject{ |k, v| k == :json_content}}"
         logger.debug "Content #{params[:json_content]}"
         pact_version_sha = generate_sha(params[:json_content])
@@ -121,13 +121,13 @@ module PactBroker
         update_params = { pact_version_sha: pact_version_sha, json_content: json_content }
         updated_pact = pact_repository.update(existing_pact.id, update_params)
 
-        webhook_trigger_service.trigger_webhooks_for_updated_pact(existing_pact, updated_pact)
+        webhook_trigger_service.trigger_webhooks_for_updated_pact(existing_pact, updated_pact, merge_consumer_version_info(webhook_options, updated_pact))
 
         updated_pact
       end
 
       # When no publication for the given consumer/provider/consumer version number exists
-      def create_pact params, version, provider
+      def create_pact params, version, provider, webhook_options
         logger.info "Creating new pact publication with params #{params.reject{ |k, v| k == :json_content}}"
         logger.debug "Content #{params[:json_content]}"
         pact_version_sha = generate_sha(params[:json_content])
@@ -139,7 +139,7 @@ module PactBroker
           pact_version_sha: pact_version_sha,
           json_content: json_content
         )
-        webhook_trigger_service.trigger_webhooks_for_new_pact pact
+        webhook_trigger_service.trigger_webhooks_for_new_pact(pact, merge_consumer_version_info(webhook_options, pact))
         pact
       end
 
@@ -150,6 +150,13 @@ module PactBroker
       def add_interaction_ids(json_content)
         Content.from_json(json_content).with_ids.to_json
       end
+
+      def merge_consumer_version_info(webhook_options, pact)
+        webhook_context = webhook_options.fetch(:webhook_context, {}).merge(
+          consumer_version_tags: pact.consumer_version_tag_names
+        )
+        webhook_options.merge(webhook_context: webhook_context)
+      end
     end
   end
 end

data/lib/pact_broker/test/test_data_builder.rb

@@ -228,8 +228,8 @@ module PactBroker
           params[:events] || [{ name: PactBroker::Webhooks::WebhookEvent::DEFAULT_EVENT_NAME }]
         end
         events = event_params.collect{ |e| PactBroker::Webhooks::WebhookEvent.new(e) }
-        default_params = { method: 'POST', url: 'http://example.org', headers: {'Content-Type' => 'application/json'}, username: params[:username], password: params[:password]}
-        request = PactBroker::Webhooks::WebhookRequestTemplate.new(default_params.merge(params))
+        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), consumer, provider
         self
       end
@@ -242,6 +242,10 @@ module PactBroker
         create_webhook(parameters.merge(consumer: nil, provider: nil))
       end
 
+      def create_global_verification_webhook parameters = {}
+        create_webhook(parameters.merge(consumer: nil, provider: nil, event_names: [PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED]))
+      end
+
       def create_provider_webhook parameters = {}
         create_webhook(parameters.merge(consumer: nil))
       end

data/lib/pact_broker/verifications/sequence.rb

@@ -1,10 +1,8 @@
-
 require 'sequel'
 
 module PactBroker
   module Verifications
     class Sequence < Sequel::Model(:verification_sequence_number)
-
       dataset_module do
         # The easiest way to implement a cross database compatible sequence.
         # Sad, I know.

data/lib/pact_broker/verifications/service.rb

@@ -18,14 +18,22 @@ module PactBroker
         verification_repository.next_number
       end
 
-      def create next_verification_number, params, pact
+      def create next_verification_number, params, pact, webhook_options
         logger.info "Creating verification #{next_verification_number} for pact_id=#{pact.id} from params #{params}"
         verification = PactBroker::Domain::Verification.new
         provider_version_number = params.fetch('providerApplicationVersion')
         PactBroker::Api::Decorators::VerificationDecorator.new(verification).from_hash(params)
         verification.number = next_verification_number
         verification = verification_repository.create(verification, provider_version_number, pact)
-        webhook_service.trigger_webhooks pact, verification, PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED
+        webhook_context = webhook_options[:webhook_context].merge(
+          provider_version_tags: verification.provider_version_tag_names
+        )
+
+        webhook_service.trigger_webhooks(pact,
+          verification,
+          PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED,
+          webhook_options.merge(webhook_context: webhook_context)
+        )
         verification
       end
 

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.31.0'
+  VERSION = '2.32.0'
 end

data/lib/pact_broker/versions/sequence.rb

@@ -0,0 +1,38 @@
+require 'sequel'
+
+module PactBroker
+  module Versions
+    class Sequence < Sequel::Model(:version_sequence_number)
+
+      dataset_module do
+        # The easiest way to implement a cross database compatible sequence.
+        # Sad, I know.
+        def next_val
+          db.transaction do
+            for_update.first
+            select_all.update(value: Sequel[:value]+1)
+            row = first
+            if row
+              row.value
+            else
+              # The first row should have been created in the migration, so this code
+              # should only ever be executed in a test context, after we've truncated all the
+              # tables after a test.
+              # There would be a risk of a race condition creating two rows if this
+              # code executed in prod, as I don't think you can lock an empty table
+              # to prevent another record being inserted.
+              max_version_order = PactBroker::Domain::Version.max(:order)
+              value = max_version_order ? max_version_order + 100 : 1
+              insert(value: value)
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Table: version_sequence_number
+# Columns:
+#  value | integer | NOT NULL

data/lib/pact_broker/webhooks/job.rb

@@ -18,14 +18,23 @@ module PactBroker
 
       private
 
-      attr_reader :triggered_webhook, :error_count
+      attr_reader :triggered_webhook, :error_count, :data
 
       def perform_with_connection(data)
         @data = data
-        @triggered_webhook = PactBroker::Webhooks::TriggeredWebhook.find(id: data[:triggered_webhook].id)
+        triggered_webhook_id = data[:triggered_webhook].id
+        @triggered_webhook = PactBroker::Webhooks::TriggeredWebhook.find(id: triggered_webhook_id)
+        if triggered_webhook
+          perform_with_triggered_webhook
+        else
+          logger.info "Could not find webhook with id: #{triggered_webhook_id}"
+        end
+      end
+
+      def perform_with_triggered_webhook
         @error_count = data[:error_count] || 0
         begin
-          webhook_execution_result = PactBroker::Webhooks::Service.execute_triggered_webhook_now triggered_webhook, execution_options(data)
+          webhook_execution_result = PactBroker::Webhooks::Service.execute_triggered_webhook_now(triggered_webhook, webhook_options(data))
           if webhook_execution_result.success?
             handle_success
           else
@@ -36,11 +45,14 @@ module PactBroker
         end
       end
 
-      def execution_options(data)
-        {
+      def webhook_options(data)
+        execution_options = data[:execution_options].merge(
           success_log_message: "Successfully executed webhook",
-          failure_log_message: failure_log_message,
-          base_url: data.fetch(:base_url)
+          failure_log_message: failure_log_message
+        )
+        {
+          execution_options: execution_options,
+          webhook_context: data[:webhook_context]
         }
       end
 

data/lib/pact_broker/webhooks/render.rb

@@ -4,15 +4,16 @@ module PactBroker
 
       TEMPLATE_PARAMETER_REGEXP = /\$\{pactbroker\.[^\}]+\}/
 
-      def self.call(template, pact, trigger_verification, base_url, &escaper)
+      def self.call(template, pact, trigger_verification, webhook_context, &escaper)
+        base_url = webhook_context[:base_url]
         verification = trigger_verification || (pact && pact.latest_verification)
         params = {
-          '${pactbroker.pactUrl}' => pact ? PactBroker::Api::PactBrokerUrls.pact_url(base_url, pact) : "",
+          '${pactbroker.pactUrl}' => pact ? PactBroker::Api::PactBrokerUrls.pact_version_url_with_metadata(pact, base_url) : "",
           '${pactbroker.verificationResultUrl}' => verification_url(verification, base_url),
-          '${pactbroker.consumerVersionNumber}' => pact ? pact.consumer_version_number : "",
+          '${pactbroker.consumerVersionNumber}' => consumer_version_number(pact, webhook_context),
           '${pactbroker.providerVersionNumber}' => verification ? verification.provider_version_number : "",
-          '${pactbroker.providerVersionTags}' => provider_version_tags(verification),
-          '${pactbroker.consumerVersionTags}' => consumer_version_tags(pact),
+          '${pactbroker.providerVersionTags}' => provider_version_tags(verification, webhook_context),
+          '${pactbroker.consumerVersionTags}' => consumer_version_tags(pact, webhook_context),
           '${pactbroker.consumerName}' => pact ? pact.consumer_name : "",
           '${pactbroker.providerName}' => pact ? pact.provider_name : "",
           '${pactbroker.githubVerificationStatus}' => github_verification_status(verification),
@@ -47,19 +48,35 @@ module PactBroker
         end
       end
 
-      def self.consumer_version_tags pact
-        if pact
-          pact.consumer_version.tags.collect(&:name).join(", ")
+      def self.consumer_version_number(pact, webhook_context)
+        if webhook_context[:consumer_version_number]
+          webhook_context[:consumer_version_number]
         else
-          ""
+          pact ? pact.consumer_version_number : ""
         end
       end
 
-      def self.provider_version_tags verification
-        if verification
-          verification.provider_version.tags.collect(&:name).join(", ")
+      def self.consumer_version_tags pact, webhook_context
+        if webhook_context[:consumer_version_tags]
+          webhook_context[:consumer_version_tags].join(", ")
         else
-          ""
+          if pact
+            pact.consumer_version.tags.collect(&:name).join(", ")
+          else
+            ""
+          end
+        end
+      end
+
+      def self.provider_version_tags verification, webhook_context
+        if webhook_context[:provider_version_tags]
+          webhook_context[:provider_version_tags].join(", ")
+        else
+          if verification
+            verification.provider_version.tags.collect(&:name).join(", ")
+          else
+            ""
+          end
         end
       end
 

data/lib/pact_broker/webhooks/repository.rb

@@ -34,6 +34,8 @@ module PactBroker
 
       def update_by_uuid uuid, webhook
         existing_webhook = Webhook.find(uuid: uuid)
+        existing_webhook.consumer_id = pacticipant_repository.find_by_name(webhook.consumer.name).id if webhook.consumer
+        existing_webhook.provider_id = pacticipant_repository.find_by_name(webhook.provider.name).id if webhook.provider
         existing_webhook.update_from_domain(webhook).save
         existing_webhook.headers.collect(&:delete)
         existing_webhook.events.collect(&:delete)
@@ -82,10 +84,6 @@ module PactBroker
         Webhook.where(consumer: consumer, provider: provider).destroy
       end
 
-      def find_for_pact_and_event_name pact, event_name
-        find_by_consumer_and_or_provider_and_event_name(pact.consumer, pact.provider, event_name)
-      end
-
       def find_by_consumer_and_or_provider_and_event_name consumer, provider, event_name
         find_by_consumer_and_provider_and_event_name(consumer, provider, event_name) +
           find_by_consumer_and_provider_and_event_name(nil, provider, event_name) +
@@ -100,6 +98,7 @@ module PactBroker
         }
         Webhook
           .select_all_qualified
+          .enabled
           .where(criteria)
           .join(:webhook_events, { webhook_id: :id })
           .where(Sequel[:webhook_events][:name] => event_name)

data/lib/pact_broker/webhooks/service.rb

@@ -9,6 +9,7 @@ require 'pact_broker/webhooks/status'
 require 'pact_broker/webhooks/webhook_event'
 require 'pact_broker/verifications/placeholder_verification'
 require 'pact_broker/pacts/placeholder_pact'
+require 'pact_broker/api/decorators/webhook_decorator'
 
 module PactBroker
 
@@ -40,7 +41,10 @@ module PactBroker
         webhook_repository.find_by_uuid uuid
       end
 
-      def self.update_by_uuid uuid, webhook
+      def self.update_by_uuid uuid, params
+        webhook = webhook_repository.find_by_uuid(uuid)
+        maintain_redacted_params(webhook, params)
+        PactBroker::Api::Decorators::WebhookDecorator.new(webhook).from_hash(params)
         webhook_repository.update_by_uuid uuid, webhook
       end
 
@@ -63,31 +67,35 @@ module PactBroker
         webhook_repository.find_all
       end
 
-      def self.test_execution webhook
-        options = { failure_log_message: "Webhook execution failed", show_response: PactBroker.configuration.show_webhook_response?, base_url: base_url}
+      def self.test_execution webhook, options
+        execution_options = options[:execution_options].merge(
+          failure_log_message: "Webhook execution failed",
+        )
+        merged_options = options.merge(execution_options: execution_options)
         verification = nil
         if webhook.trigger_on_provider_verification_published?
           verification = verification_service.search_for_latest(webhook.consumer_name, webhook.provider_name) || PactBroker::Verifications::PlaceholderVerification.new
         end
 
         pact = pact_service.search_for_latest_pact(consumer_name: webhook.consumer_name, provider_name: webhook.provider_name) || PactBroker::Pacts::PlaceholderPact.new
-        webhook.execute(pact, verification, options)
-      end
-
-      def self.execute_webhook_now webhook, pact, verification = nil
-        triggered_webhook = webhook_repository.create_triggered_webhook(next_uuid, webhook, pact, verification, USER)
-        options = { failure_log_message: "Webhook execution failed"}
-        webhook_execution_result = execute_triggered_webhook_now triggered_webhook, options
-        if webhook_execution_result.success?
-          webhook_repository.update_triggered_webhook_status triggered_webhook, TriggeredWebhook::STATUS_SUCCESS
-        else
-          webhook_repository.update_triggered_webhook_status triggered_webhook, TriggeredWebhook::STATUS_FAILURE
-        end
-        webhook_execution_result
-      end
-
-      def self.execute_triggered_webhook_now triggered_webhook, options
-        webhook_execution_result = triggered_webhook.execute options.merge(show_response: PactBroker.configuration.show_webhook_response?)
+        webhook.execute(pact, verification, merged_options)
+      end
+
+      # # TODO delete?
+      # def self.execute_webhook_now webhook, pact, verification = nil
+      #   triggered_webhook = webhook_repository.create_triggered_webhook(next_uuid, webhook, pact, verification, USER)
+      #   execution_options = { failure_log_message: "Webhook execution failed"}
+      #   webhook_execution_result = execute_triggered_webhook_now triggered_webhook, execution_options
+      #   if webhook_execution_result.success?
+      #     webhook_repository.update_triggered_webhook_status triggered_webhook, TriggeredWebhook::STATUS_SUCCESS
+      #   else
+      #     webhook_repository.update_triggered_webhook_status triggered_webhook, TriggeredWebhook::STATUS_FAILURE
+      #   end
+      #   webhook_execution_result
+      # end
+
+      def self.execute_triggered_webhook_now triggered_webhook, webhook_options
+        webhook_execution_result = triggered_webhook.execute webhook_options
         webhook_repository.create_execution triggered_webhook, webhook_execution_result
         webhook_execution_result
       end
@@ -108,17 +116,17 @@ module PactBroker
         webhook_repository.find_by_consumer_and_provider consumer, provider
       end
 
-      def self.trigger_webhooks pact, verification, event_name
+      def self.trigger_webhooks pact, verification, event_name, options
         webhooks = webhook_repository.find_by_consumer_and_or_provider_and_event_name pact.consumer, pact.provider, event_name
 
         if webhooks.any?
-          run_later(webhooks, pact, verification, event_name)
+          run_later(webhooks, pact, verification, event_name, options)
         else
-          logger.debug "No webhook found for consumer \"#{pact.consumer.name}\" and provider \"#{pact.provider.name}\""
+          logger.debug "No enabled webhooks found for consumer \"#{pact.consumer.name}\" and provider \"#{pact.provider.name}\" and event #{event_name}"
         end
       end
 
-      def self.run_later webhooks, pact, verification, event_name
+      def self.run_later webhooks, pact, verification, event_name, options
         trigger_uuid = next_uuid
         webhooks.each do | webhook |
           begin
@@ -126,8 +134,9 @@ module PactBroker
             logger.info "Scheduling job for #{webhook.description} with uuid #{webhook.uuid}"
             job_data = {
               triggered_webhook: triggered_webhook,
-              database_connector: job_database_connector,
-              base_url: base_url
+              webhook_context: options.fetch(:webhook_context),
+              execution_options: options.fetch(:execution_options),
+              database_connector: options.fetch(:database_connector)
             }
             # Delay slightly to make sure the request transaction has finished before we execute the webhook
             Job.perform_in(5, job_data)
@@ -137,14 +146,6 @@ module PactBroker
         end
       end
 
-      def self.job_database_connector
-        Thread.current[:pact_broker_thread_data].database_connector
-      end
-
-      def self.base_url
-        Thread.current[:pact_broker_thread_data].base_url
-      end
-
       def self.find_latest_triggered_webhooks_for_pact pact
         webhook_repository.find_latest_triggered_webhooks_for_pact pact
       end
@@ -164,6 +165,31 @@ module PactBroker
       def self.find_triggered_webhooks_for_verification verification
         webhook_repository.find_triggered_webhooks_for_verification(verification)
       end
+
+      private
+
+      # Dirty hack to maintain existing password or Authorization header if it is submitted with value ****
+      # This is required because the password and Authorization header is **** out in the API response
+      # for security purposes, so it would need to be re-entered with every response.
+      # TODO implement proper 'secrets' management.
+      def self.maintain_redacted_params(webhook, params)
+        if webhook.request.password && password_key_does_not_exist_or_is_starred?(params)
+          params['request']['password'] = webhook.request.password
+        end
+
+        new_headers = params['request']['headers'] ||= {}
+        existing_headers = webhook.request.headers
+        starred_new_headers = new_headers.select { |key, value| value =~ /^\**$/ }
+        starred_new_headers.each do | (key, value) |
+          new_headers[key] = existing_headers[key]
+        end
+        params['request']['headers'] = new_headers
+        params
+      end
+
+      def self.password_key_does_not_exist_or_is_starred?(params)
+        !params['request'].key?('password') || params.dig('request','password') =~ /^\**$/
+      end
     end
   end
 end