pact_broker 2.107.1 → 2.109.0

data/lib/pact_broker/api/middleware/configuration.rb

@@ -1,5 +1,7 @@
 require "pact_broker/logging"
 
+# Allows the load-time configuration to be overridden on a per-request basis (for Pactflow)
+
 module PactBroker
   module Api
     module Middleware

data/lib/pact_broker/api/pact_broker_urls.rb

@@ -227,8 +227,24 @@ module PactBroker
         "#{tags_url(base_url, tag.version)}/#{url_encode(tag.name)}"
       end
 
+      def branch_url(branch, base_url = "")
+        "#{pacticipant_branches_url(branch.pacticipant, base_url)}/#{url_encode(branch.name)}"
+      end
+
+      def pacticipant_branches_url(pacticipant, base_url = "")
+        "#{pacticipant_url(base_url, pacticipant)}/branches"
+      end
+
+      def branch_versions_url(branch, base_url = "")
+        "#{branch_url(branch, base_url)}/versions"
+      end
+
       def branch_version_url(branch_version, base_url = "")
-        "#{pacticipant_url(base_url, branch_version.pacticipant)}/branches/#{url_encode(branch_version.branch_name)}/versions/#{url_encode(branch_version.version_number)}"
+        "#{branch_versions_url(branch_version.branch, base_url)}/#{url_encode(branch_version.version_number)}"
+      end
+
+      def latest_version_for_branch_url(branch, base_url = "")
+        "#{branch_url(branch, base_url)}/latest-version"
       end
 
       def templated_tag_url_for_pacticipant pacticipant_name, base_url = ""
@@ -271,7 +287,7 @@ module PactBroker
         "#{base_url}/webhooks"
       end
 
-      def webhook_url uuid, base_url
+      def webhook_url uuid, base_url = ""
         "#{base_url}/webhooks/#{uuid}"
       end
 

data/lib/pact_broker/api/resources/after_reply.rb

@@ -0,0 +1,15 @@
+require "pact_broker/async/after_reply"
+
+module PactBroker
+  module Api
+    module Resources
+      module AfterReply
+
+        # @param [Callable] block the block to execute after the response has been sent to the user.
+        def after_reply(&block)
+          PactBroker::Async::AfterReply.new(request.env).execute(&block)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/resources/all_webhooks.rb

@@ -38,7 +38,7 @@ module PactBroker
         end
 
         def from_json
-          saved_webhook = webhook_service.create(next_uuid, webhook, consumer, provider)
+          saved_webhook = webhook_service.create(next_uuid, webhook, webhook_consumer, webhook_provider)
           response.body = decorator_class(:webhook_decorator).new(saved_webhook).to_json(**decorator_options)
         end
 
@@ -60,11 +60,11 @@ module PactBroker
           api_contract_class(:webhook_contract)
         end
 
-        def consumer
+        def webhook_consumer
           webhook.consumer&.name ? pacticipant_service.find_pacticipant_by_name(webhook.consumer.name) : nil
         end
 
-        def provider
+        def webhook_provider
           webhook.provider&.name ? pacticipant_service.find_pacticipant_by_name(webhook.provider.name) : nil
         end
 

data/lib/pact_broker/api/resources/badge_methods.rb

@@ -37,7 +37,8 @@ module PactBroker
             badge_url
           rescue StandardError => e
             # Want to render a badge, even if there's an error
-            badge_service.error_badge_url("error", ErrorResponseGenerator.display_message(e, "reference: #{PactBroker::Errors.generate_error_reference}"))
+            error_reference = log_and_report_error(e)
+            badge_service.error_badge_url("error", "reference: #{error_reference}")
           end
         end
 

data/lib/pact_broker/api/resources/base_resource.rb

@@ -10,6 +10,7 @@ require "pact_broker/pacts/pact_params"
 require "pact_broker/api/resources/authentication"
 require "pact_broker/api/resources/authorization"
 require "pact_broker/errors"
+require "pact_broker/messages"
 require "pact_broker/api/resources/error_handling_methods"
 require "pact_broker/api/contracts/utf_8_validation"
 
@@ -26,7 +27,7 @@ module PactBroker
         include PactBroker::Api::Resources::Authorization
         include PactBroker::Api::Resources::ErrorHandlingMethods
         include PactBroker::Api::Contracts::UTF8Validation
-
+        include PactBroker::Messages
         include PactBroker::Logging
 
         attr_accessor :user
@@ -206,7 +207,7 @@ module PactBroker
         def find_pacticipant name, role
           pacticipant_service.find_pacticipant_by_name(name).tap do | pacticipant |
             if pacticipant.nil?
-              set_json_error_message("No #{role} with name '#{name}' found", title: "Not found", type: "not_found", status: 404)
+              set_json_error_message("No #{role} with name '#{name}' found", title: "Not found", type: "not-found", status: 404)
             end
           end
         end
@@ -257,8 +258,9 @@ module PactBroker
         end
 
         def validation_errors_for_schema?(schema_to_use = schema, params_to_validate = params)
-          if (errors = schema_to_use.call(params_to_validate)).any?
-            set_json_validation_error_messages(errors)
+          result = schema_to_use.call(params_to_validate)
+          if result.errors.any?
+            set_json_validation_error_messages(result.errors)
             true
           else
             false

data/lib/pact_broker/api/resources/branch.rb

@@ -0,0 +1,40 @@
+require "pact_broker/api/resources/base_resource"
+
+module PactBroker
+  module Api
+    module Resources
+      class Branch < BaseResource
+        def content_types_provided
+          [["application/hal+json", :to_json]]
+        end
+
+        def allowed_methods
+          ["GET", "DELETE", "OPTIONS"]
+        end
+
+        def resource_exists?
+          !!branch
+        end
+
+        def to_json
+          decorator_class(:branch_decorator).new(branch).to_json(**decorator_options)
+        end
+
+        def delete_resource
+          branch_service.delete_branch(branch)
+          true
+        end
+
+        def policy_name
+          :'versions::branch'
+        end
+
+        private
+
+        def branch
+          @branch_version ||= branch_service.find_branch(**identifier_from_path.slice(:pacticipant_name, :branch_name))
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/resources/branch_versions.rb

@@ -0,0 +1,59 @@
+require "pact_broker/api/resources/base_resource"
+require "pact_broker/configuration"
+require "pact_broker/api/decorators/versions_decorator"
+require "pact_broker/api/resources/pagination_methods"
+
+
+module PactBroker
+  module Api
+    module Resources
+      class BranchVersions < BaseResource
+        include PaginationMethods
+
+        def content_types_provided
+          [["application/hal+json", :to_json]]
+        end
+
+        def allowed_methods
+          ["GET", "OPTIONS"]
+        end
+
+        def malformed_request?
+          super || request.get? && validation_errors_for_schema?(schema, request.query)
+        end
+
+        def resource_exists?
+          !!branch
+        end
+
+        def to_json
+          decorator_class(:versions_decorator).new(versions).to_json(**decorator_options(identifier_from_path.merge(resource_title: resource_title)))
+        end
+
+        def versions
+          @versions ||= version_service.find_pacticipant_versions_in_reverse_order(pacticipant_name, { branch_name: identifier_from_path[:branch_name] }, pagination_options)
+        end
+
+        def policy_name
+          :'versions::versions'
+        end
+
+        def branch
+          @branch ||= branch_service.find_branch(**identifier_from_path.slice(:pacticipant_name, :branch_name))
+        end
+
+        def resource_title
+          "Versions for branch #{branch.name} of #{branch.pacticipant.name}"
+        end
+
+        private
+
+        def schema
+          if request.get?
+            PactBroker::Api::Contracts::PaginationQueryParamsSchema
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/resources/can_i_deploy_pacticipant_version_by_branch_to_environment_badge.rb

@@ -14,7 +14,7 @@ module PactBroker
           elsif pacticipant.nil?
             badge_service.error_badge_url("pacticipant", "not found")
           elsif version.nil?
-            if branch_service.find_branch(identifier_from_path.slice(:pacticipant_name, :branch_name)).nil?
+            if branch_service.find_branch(**identifier_from_path.slice(:pacticipant_name, :branch_name)).nil?
               badge_service.error_badge_url("branch", "not found")
             else
               badge_service.error_badge_url("version", "not found")

data/lib/pact_broker/api/resources/currently_deployed_versions_for_environment.rb

@@ -21,7 +21,7 @@ module PactBroker
         end
 
         def to_json
-          decorator_class(decorator_name).new(deployed_versions).to_json(**decorator_options(title: title))
+          decorator_class(decorator_name).new(deployed_versions).to_json(**decorator_options(title: title, expand: [:pacticipant, :version]))
         end
 
         def policy_name

data/lib/pact_broker/api/resources/currently_supported_versions_for_environment.rb

@@ -21,7 +21,7 @@ module PactBroker
         end
 
         def to_json
-          decorator_class(decorator_name).new(released_versions).to_json(**decorator_options(title: title))
+          decorator_class(decorator_name).new(released_versions).to_json(**decorator_options(title: title, expand: [:pacticipant, :version]))
         end
 
         def policy_name

data/lib/pact_broker/api/resources/dashboard.rb

@@ -20,6 +20,10 @@ module PactBroker
           ["GET", "OPTIONS"]
         end
 
+        def malformed_request?
+          super || (request.get? && validation_errors_for_schema?(schema, request.query))
+        end
+
         def to_json
           decorator_class(:dashboard_decorator).new(index_items).to_json(**decorator_options)
         end
@@ -34,6 +38,12 @@ module PactBroker
 
         private
 
+        def schema
+          if request.get?
+            PactBroker::Api::Contracts::PaginationQueryParamsSchema
+          end
+        end
+
         def index_items
           index_service.find_index_items_for_api(**identifier_from_path.merge(pagination_options))
         end

data/lib/pact_broker/api/resources/deployed_versions_for_version_and_environment.rb

@@ -78,7 +78,7 @@ module PactBroker
         end
 
         def title
-          "Deployed versions for #{pacticipant_name} version #{pacticipant_version_number}"
+          "Deployed versions for #{pacticipant_name} version #{pacticipant_version_number} in environment #{environment.display_name}"
         end
       end
     end

data/lib/pact_broker/api/resources/environment.rb

@@ -42,6 +42,10 @@ module PactBroker
           :'deployments::environment'
         end
 
+        def policy_record
+          environment
+        end
+
         def to_json
           decorator_class(:environment_decorator).new(environment).to_json(**decorator_options)
         end

data/lib/pact_broker/api/resources/environments.rb

@@ -60,7 +60,7 @@ module PactBroker
 
         def environments
           @environments ||= if request.query["name"]
-                              [environment_service.find_by_name(request.query["name"])]
+                              [environment_service.find_by_name(request.query["name"])].compact
                             else
                               environment_service.find_all
                             end

data/lib/pact_broker/api/resources/error_handler.rb

@@ -1,70 +1,36 @@
 require "pact_broker/configuration"
 require "securerandom"
 
+# Logs the error
+# Reports the error
+# Generates and returns response headers and response body
+
 module PactBroker
   module Api
     module Resources
       class ErrorHandler
         include PactBroker::Logging
 
-        def self.call e, request, response
-          error_reference = generate_error_reference
-          if log_as_warning?(e)
-            logger.warn("Error reference #{error_reference}", e)
-          elsif reportable?(e)
-            log_error(e, "Error reference #{error_reference}")
-            report(e, error_reference, request)
-          else
-            logger.info("Error reference #{error_reference}", e)
-          end
-          response.body = response_body_hash(e, error_reference).to_json
+        def initialize(error_logger, error_response_generator, error_reporter)
+          @error_logger = error_logger
+          @error_response_generator = error_response_generator
+          @error_reporter = error_reporter
         end
 
-        def self.generate_error_reference
-          SecureRandom.urlsafe_base64.gsub(/[^a-z]/i, "")[0,10]
-        end
+        def call(error, env, message = nil)
+          error_reference = PactBroker::Errors.generate_error_reference
 
-        def self.reportable?(e)
-          !e.is_a?(PactBroker::Error) && !e.is_a?(JSON::JSONError)
-        end
+          # log error
+          error_logger.call(error, error_reference, env)
 
-        def self.log_as_warning?(e)
-          PactBroker.configuration.warning_error_classes.any? { |clazz| e.is_a?(clazz) || e.cause&.is_a?(clazz) }
-        end
+          # report error
+          error_reporter.call(error, error_reference, env)
 
-        def self.display_message(e, obfuscated_message)
-          if PactBroker.configuration.show_backtrace_in_error_response?
-            e.message || obfuscated_message
-          else
-            reportable?(e) ? obfuscated_message : e.message
-          end
-        end
-
-        def self.obfuscated_error_message error_reference
-          "An error has occurred. The details have been logged with the reference #{error_reference}"
-        end
-
-        def self.response_body_hash e, error_reference
-          response_body = {
-            error: {
-              message: display_message(e, obfuscated_error_message(error_reference)),
-              reference: error_reference
-            }
-          }
-          if PactBroker.configuration.show_backtrace_in_error_response?
-            response_body[:error][:backtrace] = e.backtrace
-          end
-          response_body
-        end
 
-        def self.report e, error_reference, request
-          PactBroker.configuration.api_error_reporters.each do | error_notifier |
-            begin
-              error_notifier.call(e, env: request.env, error_reference: error_reference)
-            rescue StandardError => e
-              log_error(e, "Error executing api_error_reporter")
-            end
-          end
+          # generate response
+          headers, body = error_response_generator.call(error, error_reference, env, message: message)
+          headers.each { | key, value | response.headers[key] = value }
+          return headers, body
         end
       end
     end

data/lib/pact_broker/api/resources/error_handling_methods.rb

@@ -7,29 +7,39 @@ module PactBroker
       module ErrorHandlingMethods
 
         # @override
+        # @param [StandardError] error
         def handle_exception(error)
-          error_reference = PactBroker::Errors.generate_error_reference
-          application_context.error_logger.call(error, error_reference, request.env)
-          if PactBroker::Errors.reportable_error?(error)
-            PactBroker::Errors.report(error, error_reference, request.env)
-          end
+          error_reference = log_and_report_error(error)
           headers, body = application_context.error_response_generator.call(error, error_reference, request.env)
           headers.each { | key, value | response.headers[key] = value }
           response.body = body
         end
 
-        def set_json_error_message detail, title: "Server error", type: "server_error", status: 500
+        # @param [StandardError] error
+        def log_and_report_error(error)
+          # generate reference
+          error_reference = PactBroker::Errors.generate_error_reference
+          # log error
+          application_context.error_logger.call(error, error_reference, request.env)
+          # report error
+          application_context.error_reporter.call(error, error_reference, request.env)
+          # generate response
+          error_reference
+        end
+
+        # @param [String] detail
+        # @param [String] title
+        # @param [String] type
+        # @param [Integer] status
+        def set_json_error_message(detail, title: "Server error", type: "server-error", status: 500)
           response.headers["Content-Type"] = error_response_content_type
           response.body = error_response_body(detail, title, type, status)
         end
 
-        def set_json_validation_error_messages errors
+        # @param [Hash,Dry::Validation::MessageSet] errors
+        def set_json_validation_error_messages(errors)
           response.headers["Content-Type"] = error_response_content_type
-          if problem_json_error_content_type?
-            response.body = PactBroker::Api::Decorators::ValidationErrorsProblemJSONDecorator.new(errors).to_json(**decorator_options)
-          else
-            response.body = { errors: errors }.to_json
-          end
+          response.body = validation_errors_response_body(errors)
         end
 
         def error_response_content_type
@@ -42,15 +52,31 @@ module PactBroker
 
         def error_response_body(detail, title, type, status)
           if problem_json_error_content_type?
-            PactBroker::Api::Decorators::CustomErrorProblemJSONDecorator.new(detail: detail, title: title, type: type, status: status).to_json(**decorator_options)
+            decorator_class(:custom_error_problem_json_decorator).new(detail: detail, title: title, type: type, status: status).to_json(**decorator_options_for_error)
           else
-            { error: detail }.to_json
+            decorator_class(:error_decorator).new(detail).to_json
           end
         end
 
+        # @param [Hash,Dry::Validation::MessageSet] errors
+        def validation_errors_response_body(errors)
+          validation_errors_decorator_class(errors).new(errors).to_json(**decorator_options_for_error)
+        end
+
+        # @param [Hash,Dry::Validation::MessageSet] errors
+        def validation_errors_decorator_class(errors)
+          application_context.decorator_configuration.validation_error_decorator_class_for(errors.class, request.headers["Accept"])
+        end
+
         def problem_json_error_content_type?
           request.headers["Accept"]&.include?("application/problem+json")
         end
+
+        # If we use the normal decorator options that have policy objects we can get into recursive loops in Pactflow, so just make a simple variant of the
+        # decorator options here
+        def decorator_options_for_error
+          { user_options: { base_url: base_url } }
+        end
       end
     end
   end

data/lib/pact_broker/api/resources/error_response_generator.rb

@@ -1,23 +1,36 @@
 require "pact_broker/configuration"
 require "pact_broker/api/decorators/runtime_error_problem_json_decorator"
+require "pact_broker/errors"
+require "pact_broker/messages"
+
+# Generates the response headers and body for use when there is a runtime
+# error in the business logic (services and repositories) when executing a Webmachine resource request.
+# Obfuscates any exception messages that might expose vulnerablities in production.
+# Uses the Accept header to determine whether to return application/problem+json
+# or application/hal+json, for backwards compatibility.
+# In the next major version of the Pact Broker, all error responses
+# should use problem+json, regardless of Accept headers.
 
 module PactBroker
   module Api
     module Resources
       class ErrorResponseGenerator
         include PactBroker::Logging
+        extend PactBroker::Messages
 
         # @param error [StandardError]
         # @param error_reference [String] an error reference to display to the user
         # @param env [Hash] the rack env
         # @return [Hash, String] the response headers to set, the response body to set
-        def self.call error, error_reference, env = {}
-          body = response_body_hash(error, error_reference, env, display_message(error, obfuscated_error_message(error_reference)))
+        def self.call(error, error_reference, env, message: nil)
+          body = response_body_hash(error, error_reference, env, display_message(error, message, obfuscated_error_message(error_reference)))
           return headers(env), body.to_json
         end
 
-        def self.display_message(error, obfuscated_message)
-          if PactBroker.configuration.show_backtrace_in_error_response?
+        def self.display_message(error, message, obfuscated_message)
+          if message
+            message
+          elsif PactBroker.configuration.show_backtrace_in_error_response?
             error.message || obfuscated_message
           else
             PactBroker::Errors.reportable_error?(error) ? obfuscated_message : error.message
@@ -46,11 +59,11 @@ module PactBroker
         end
 
         private_class_method def self.problem_json_response_body(message, env)
-          PactBroker::Api::Decorators::RuntimeErrorProblemJSONDecorator.new(message).to_hash(user_options: { base_url: env["pactbroker.base_url" ] })
+          error_decorator_class(env).new(message).to_hash(user_options: { base_url: env["pactbroker.base_url" ] })
         end
 
         private_class_method def self.obfuscated_error_message(error_reference)
-          "An error has occurred. The details have been logged with the reference #{error_reference}"
+          message("errors.runtime.with_error_reference", error_reference: error_reference)
         end
 
         private_class_method def self.headers(env)
@@ -64,6 +77,10 @@ module PactBroker
         private_class_method def self.problem_json?(env)
           env["HTTP_ACCEPT"]&.include?("application/problem+json")
         end
+
+        private_class_method def self.error_decorator_class(env)
+          env["pactbroker.application_context"].decorator_configuration.class_for(:runtime_error_problem_json_decorator)
+        end
       end
     end
   end

data/lib/pact_broker/api/resources/event_methods.rb

@@ -0,0 +1,15 @@
+require "pact_broker/events/subscriber"
+
+module PactBroker
+  module Api
+    module Resources
+      module EventMethods
+        def subscribe(listener)
+          PactBroker::Events.subscribe(listener) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/resources/filter_methods.rb

@@ -0,0 +1,15 @@
+module PactBroker
+  module Api
+    module Resources
+      module FilterMethods
+        def filter_options
+          if request.query.has_key?("q")
+            { query_string: request.query["q"] }
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/resources/group.rb

@@ -1,3 +1,4 @@
+require "pact_broker/string_refinements"
 require "pact_broker/api/resources/base_resource"
 require "pact_broker/api/decorators/relationships_csv_decorator"
 
@@ -5,6 +6,8 @@ module PactBroker
   module Api
     module Resources
       class Group < BaseResource
+        using PactBroker::StringRefinements
+
         def content_types_provided
           [["text/csv", :to_csv]]
         end
@@ -32,9 +35,15 @@ module PactBroker
         private
 
         def group
-          @group ||= group_service.find_group_containing(pacticipant)
+          @group ||= group_service.find_group_containing(pacticipant, max_pacticipants: max_pacticipants)
+        end
+
+        def max_pacticipants
+          if request.query["maxPacticipants"]&.integer?
+            request.query["maxPacticipants"].to_i
+          end
         end
       end
     end
   end
-end
+end

data/lib/pact_broker/api/resources/index.rb

@@ -116,6 +116,12 @@ module PactBroker
               title: "Get, create or delete a tag for a pacticipant version",
               templated: true
             },
+            "pb:pacticipant-branch" =>
+            {
+              href: base_url + "/pacticipants/{pacticipant}/branches/{branch}",
+              title: "Get or delete a pacticipant branch",
+              templated: true
+            },
             "pb:pacticipant-branch-version" =>
             {
               href: base_url + "/pacticipants/{pacticipant}/branches/{branch}/versions/{version}",