pact_broker 2.22.0 → 2.23.0

data/lib/pact_broker/domain/pact.rb

@@ -49,6 +49,10 @@ module PactBroker
       def content_hash
         JSON.parse(json_content, PACT_PARSING_OPTIONS)
       end
+
+      def pact_publication_id
+        id
+      end
     end
 
   end

data/lib/pact_broker/domain/webhook.rb

@@ -25,7 +25,15 @@ module PactBroker
       end
 
       def description
-        "A webhook for the pact between #{consumer.name} and #{provider.name}"
+        if consumer && provider
+          "A webhook for the pact between #{consumer.name} and #{provider.name}"
+        elsif provider
+          "A webhook for all pacts with provider #{provider.name}"
+        elsif consumer
+          "A webhook for all pacts with consumer #{consumer.name}"
+        else
+          "A webhook for all pacts"
+        end
       end
 
       def request_description
@@ -34,11 +42,11 @@ module PactBroker
 
       def execute pact, verification, options
         logger.info "Executing #{self}"
-        request.execute pact, verification, options
+        request.build(pact: pact, verification: verification).execute(options)
       end
 
       def to_s
-        "webhook for consumer=#{consumer_name} provider=#{provider_name} uuid=#{uuid} request=#{request}"
+        "webhook for consumer=#{consumer_name} provider=#{provider_name} uuid=#{uuid}"
       end
 
       def consumer_name
@@ -48,6 +56,14 @@ module PactBroker
       def provider_name
         provider && provider.name
       end
+
+      def trigger_on_contract_content_changed?
+        events.any?(&:contract_content_changed?)
+      end
+
+      def trigger_on_provider_verification_published?
+        events.any?(&:provider_verification_published?)
+      end
     end
   end
 end

data/lib/pact_broker/domain/webhook_execution_result.rb

@@ -4,7 +4,8 @@ module PactBroker
 
     class WebhookExecutionResult
 
-      def initialize response, logs, error = nil
+      def initialize request, response, logs, error = nil
+        @request = request
         @response = response
         @logs = logs
         @error = error
@@ -14,6 +15,10 @@ module PactBroker
         !@response.nil? && @response.code.to_i < 300
       end
 
+      def request
+        @request
+      end
+
       def response
         @response
       end

data/lib/pact_broker/domain/webhook_request.rb

@@ -8,18 +8,47 @@ require 'pact_broker/webhooks/render'
 require 'pact_broker/api/pact_broker_urls'
 require 'pact_broker/build_http_options'
 require 'cgi'
+require 'delegate'
 
 module PactBroker
 
   module Domain
 
     class WebhookRequestError < StandardError
-
       def initialize message, response
         super message
         @response = response
       end
+    end
+
+    class WebhookResponseWithUtf8SafeBody < SimpleDelegator
+      def body
+        if unsafe_body
+          unsafe_body.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+        else
+          unsafe_body
+        end
+      end
+
+      def unsafe_body
+        __getobj__().body
+      end
 
+      def unsafe_body?
+        unsafe_body != body
+      end
+    end
+
+    class WebhookRequestWithRedactedHeaders < SimpleDelegator
+      def to_hash
+        __getobj__().to_hash.each_with_object({}) do | (key, values), new_hash |
+          new_hash[key] = redact?(key) ? ["**********"] : values
+        end
+      end
+
+      def redact? name
+        WebhookRequest::HEADERS_TO_REDACT.any?{ | pattern | name =~ pattern }
+      end
     end
 
     class WebhookRequest
@@ -45,7 +74,7 @@ module PactBroker
       end
 
       def description
-        "#{method.upcase} #{URI(url.gsub(PactBroker::Webhooks::Render::TEMPLATE_PARAMETER_REGEXP, 'placeholder')).host}"
+        "#{method.upcase} #{URI(url).host}"
       end
 
       def display_password
@@ -59,66 +88,72 @@ module PactBroker
         end
       end
 
-      def execute pact, verification, options = {}
-        logs = StringIO.new
-        execution_logger = Logger.new(logs)
+      def execute options = {}
+        @options = options
+        @logs = StringIO.new
+        @execution_logger = Logger.new(logs)
         begin
-          execute_and_build_result(pact, verification, options, logs, execution_logger)
+          execute_and_build_result
         rescue StandardError => e
-          handle_error_and_build_result(e, options, logs, execution_logger)
+          handle_error_and_build_result(e)
         end
       end
 
       private
 
-      def execute_and_build_result pact, verification, options, logs, execution_logger
-        uri = build_uri(pact, verification)
-        req = build_request(uri, pact, verification, execution_logger)
-        response = do_request(uri, req)
-        log_response(response, execution_logger, options)
-        result = WebhookExecutionResult.new(response, logs.string)
-        log_completion_message(options, execution_logger, result.success?)
+      attr_reader :options, :execution_logger, :logs
+
+      def execute_and_build_result
+        log_request
+        response = do_request
+        log_response(response)
+        result = WebhookExecutionResult.new(WebhookRequestWithRedactedHeaders.new(http_request), response, logs.string)
+        log_completion_message(result.success?)
         result
       end
 
-      def handle_error_and_build_result e, options, logs, execution_logger
-        log_error(e, execution_logger, options)
-        log_completion_message(options, execution_logger, false)
-        WebhookExecutionResult.new(nil, logs.string, e)
+      def handle_error_and_build_result e
+        log_error(e)
+        log_completion_message(false)
+        WebhookExecutionResult.new(WebhookRequestWithRedactedHeaders.new(http_request), nil, logs.string, e)
       end
 
-      def build_request uri, pact, verification, execution_logger
-        req = http_request(uri)
-        execution_logger.info "HTTP/1.1 #{method.upcase} #{url_with_credentials(pact, verification)}"
-
-        headers_to_log = redacted_headers
-        headers.each_pair do | name, value |
-          execution_logger.info "#{name}: #{headers_to_log[name]}"
-          req[name] = value
-        end
-
-        req.basic_auth(username, password) if username
-
-        unless body.nil?
-          req.body = PactBroker::Webhooks::Render.call(String === body ? body : body.to_json, pact, verification)
+      def http_request
+        @http_request ||= begin
+          req = Net::HTTP.const_get(method.capitalize).new(url)
+          headers.each_pair { | name, value | req[name] = value }
+          req.basic_auth(username, password) if username
+          req.body = body unless body.nil?
+          req
         end
-
-        execution_logger.info(req.body) if req.body
-        req
       end
 
-      def do_request uri, req
-        logger.info "Making webhook #{uuid} request #{to_s}"
+      def do_request
         options = PactBroker::BuildHttpOptions.call(uri)
-        Net::HTTP.start(uri.hostname, uri.port, :ENV, options) do |http|
+        req = http_request
+        response = Net::HTTP.start(uri.hostname, uri.port, :ENV, options) do |http|
           http.request req
         end
+        WebhookResponseWithUtf8SafeBody.new(response)
       end
 
-      def log_response response, execution_logger, options
+      def log_request
+        redacted_request = WebhookRequestWithRedactedHeaders.new(http_request)
+        logger.info "Making webhook #{uuid} request #{http_method.upcase} URI=#{uri} (headers and body in debug logs)"
+        logger.debug "Webhook #{uuid} request headers=#{redacted_request.to_hash}"
+        logger.debug "Webhook #{uuid} request body=#{redacted_request.body}"
+
+        execution_logger.info "HTTP/1.1 #{http_method.upcase} #{url}"
+        redacted_request.to_hash.each do | name, value |
+          execution_logger.info "#{name}: #{value.join(", ")}"
+        end
+        execution_logger.info(body) if body
+      end
+
+      def log_response response
         log_response_to_application_logger(response)
         if options[:show_response]
-          log_response_to_execution_logger(response, execution_logger)
+          log_response_to_execution_logger(response)
         else
           execution_logger.info response_body_hidden_message
         end
@@ -129,29 +164,26 @@ module PactBroker
       end
 
       def log_response_to_application_logger response
-        logger.info "Received response for webhook #{uuid} status=#{response.code}"
-        logger.debug "headers=#{response.to_hash}"
-        logger.debug "body=#{response.body}"
+        logger.info "Received response for webhook #{uuid} status=#{response.code} (headers and body in debug logs)"
+        logger.debug "Webhook #{uuid} response headers=#{response.to_hash} "
+        logger.debug "Webhook #{uuid} response body=#{response.unsafe_body}"
       end
 
-      def log_response_to_execution_logger response, execution_logger
+      def log_response_to_execution_logger response
         execution_logger.info "HTTP/#{response.http_version} #{response.code} #{response.message}"
-        response.each_header do | header |
-          execution_logger.info "#{header.split("-").collect(&:capitalize).join('-')}: #{response[header]}"
+        response.each_header do | name, value |
+          execution_logger.info "#{name}: #{value}"
         end
 
-        safe_body = nil
-
         if response.body
-          safe_body = response.body.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
-          if response.body != safe_body
+          if response.unsafe_body?
             execution_logger.debug "Note that invalid UTF-8 byte sequences were removed from response body before saving the logs"
           end
+          execution_logger.info response.body
         end
-        execution_logger.info safe_body
       end
 
-      def log_completion_message options, execution_logger, success
+      def log_completion_message success
         if options[:success_log_message] && success
           execution_logger.info(options[:success_log_message])
           logger.info(options[:success_log_message])
@@ -163,7 +195,7 @@ module PactBroker
         end
       end
 
-      def log_error e, execution_logger, options
+      def log_error e
         logger.error "Error executing webhook #{uuid} #{e.class.name} - #{e.message} #{e.backtrace.join("\n")}"
 
         if options[:show_response]
@@ -177,18 +209,8 @@ module PactBroker
         "#{method.upcase} #{url}, username=#{username}, password=#{display_password}, headers=#{redacted_headers}, body=#{body}"
       end
 
-      def http_request(uri)
-        Net::HTTP.const_get(method.capitalize).new(uri)
-      end
-
-      def build_uri(pact, verification)
-        URI(PactBroker::Webhooks::Render.call(url, pact, verification){ | value | CGI::escape(value)} )
-      end
-
-      def url_with_credentials pact, verification
-        u = build_uri(pact, verification)
-        u.userinfo = "#{CGI::escape username}:#{display_password}" if username
-        u
+      def uri
+        @uri ||= URI(url)
       end
     end
   end

data/lib/pact_broker/locale/en.yml

@@ -8,6 +8,7 @@ en:
     name_in_path_matches_name_in_pact?: "does not match %{left} name in path ('%{right}')."
     valid_consumer_version_number?: "Consumer version number '%{value}' cannot be parsed to a version number. The expected format (unless this configuration has been overridden) is a semantic version. eg. 1.3.0 or 2.0.4.rc1"
     non_templated_host?: "cannot have a template parameter in the host"
+    pacticipant_exists?: "does not match an existing pacticipant"
 
   pact_broker:
     messages:

data/lib/pact_broker/matrix/repository.rb

@@ -144,7 +144,7 @@ module PactBroker
         selectors.collect do | selector |
           if selector[:tag] && selector[:latest]
             version = version_repository.find_by_pacticipant_name_and_latest_tag(selector[:pacticipant_name], selector[:tag])
-            raise Error.new("Could not find version with tag #{selector[:tag].inspect} for #{selector[:pacticipant_name]}") unless version
+            raise Error.new("No version of #{selector[:pacticipant_name]} found with tag #{selector[:tag]}") unless version
             # validation in resource should ensure we always have a version
             {
               pacticipant_name: selector[:pacticipant_name],
@@ -152,6 +152,7 @@ module PactBroker
             }
           elsif selector[:latest]
             version = version_repository.find_latest_by_pacticpant_name(selector[:pacticipant_name])
+            raise Error.new("No version of #{selector[:pacticipant_name]} found") unless version
             {
               pacticipant_name: selector[:pacticipant_name],
               pacticipant_version_number: version.number
@@ -159,6 +160,7 @@ module PactBroker
           elsif selector[:tag]
             # validation in resource should ensure we always have at least one version
             versions = version_repository.find_by_pacticipant_name_and_tag(selector[:pacticipant_name], selector[:tag])
+            raise Error.new("No version of #{selector[:pacticipant_name]} found with tag #{selector[:tag]}") unless versions.any?
             versions.collect do | version |
               {
                 pacticipant_name: selector[:pacticipant_name],

data/lib/pact_broker/pacts/placeholder_pact.rb

@@ -0,0 +1,17 @@
+require 'pact_broker/domain/pact'
+
+module PactBroker
+  module Pacts
+    class PlaceholderPact < PactBroker::Domain::Pact
+      def initialize
+        consumer = OpenStruct.new(name: "placeholder-consumer")
+        @provider = OpenStruct.new(name: "placeholder-provider")
+        @consumer_version = OpenStruct.new(number: "gggghhhhjjjjkkkkllll66667777888899990000", pacticipant: consumer, tags: [OpenStruct.new(name: "master")])
+        @consumer_version_number = @consumer_version.number
+        @created_at = DateTime.now
+        @revision_number = 1
+        @pact_version_sha = "5d445a4612743728dfd99ccd4210423c052bb9db"
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/repository.rb

@@ -121,6 +121,20 @@ module PactBroker
         query.latest.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 = LatestPactPublicationsByConsumerVersion.select_all_qualified
+        query = query.consumer(consumer_name) if consumer_name
+        query = query.provider(provider_name) if provider_name
+
+        if tag == :untagged
+          query = query.untagged
+        elsif tag
+          query = query.tag(tag)
+        end
+        query.latest.all.collect(&:to_domain_with_content)[0]
+      end
+
       def find_pact consumer_name, consumer_version, provider_name, pact_version_sha = nil
         query = if pact_version_sha
           AllPactPublications

data/lib/pact_broker/pacts/service.rb

@@ -17,6 +17,10 @@ module PactBroker
         pact_repository.find_latest_pact(params[:consumer_name], params[:provider_name], params[:tag])
       end
 
+      def search_for_latest_pact params
+        pact_repository.search_for_latest_pact(params[:consumer_name], params[:provider_name], params[:tag])
+      end
+
       def find_latest_pacts
         pact_repository.find_latest_pacts
       end
@@ -108,7 +112,7 @@ module PactBroker
         updated_pact = pact_repository.update existing_pact.id, params
 
         if existing_pact.json_content != updated_pact.json_content
-          webhook_service.execute_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+          webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
         else
           logger.debug "Pact has not changed since previous revision, not triggering webhooks"
         end
@@ -127,7 +131,7 @@ module PactBroker
       def trigger_webhooks pact
         # TODO add tests for this
         if pact_is_new_or_pact_has_changed_since_previous_version?(pact)
-          webhook_service.execute_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
+          webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED
         else
           logger.debug "Pact has not changed since previous version, not triggering webhooks"
         end

data/lib/pact_broker/ui/view_models/index_item.rb

@@ -93,7 +93,7 @@ module PactBroker
         def webhook_url
           url = case @relationship.webhook_status
             when :none
-              PactBroker::Api::PactBrokerUrls.webhooks_for_pact_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider
+              PactBroker::Api::PactBrokerUrls.webhooks_for_consumer_and_provider_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider
             else
               PactBroker::Api::PactBrokerUrls.webhooks_status_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider
           end

data/lib/pact_broker/verifications/placeholder_verification.rb

@@ -0,0 +1,23 @@
+module PactBroker
+  module Verifications
+    class PlaceholderVerification
+      attr_accessor :id, :number, :success,
+        :consumer_name, :provider_name, :provider_version,
+        :provider_version_number, :build_url,
+        :execution_date, :created_at, :pact_version_sha
+
+      def initialize
+        @provider_name = "placeholder-provider"
+        @consumer_name = "placeholder-consumer"
+        @number = 1
+        @success = true
+        @pact_version_sha = "5d445a4612743728dfd99ccd4210423c052bb9db"
+        tags = [OpenStruct.new(name: "master")]
+        @provider_version = OpenStruct.new(number: "aaaabbbbccccddddeeeeffff1111222233334444", tags: tags)
+        @provider_version_number = @provider_version.number
+        @execution_date = DateTime.now
+        @created_at = DateTime.now
+      end
+    end
+  end
+end