pact_broker 2.107.1 → 2.108.0

data/lib/pact_broker/webhooks/job.rb

@@ -36,11 +36,15 @@ module PactBroker
       def perform_with_triggered_webhook
         @error_count = data[:error_count] || 0
         begin
-          webhook_execution_result = PactBroker::Webhooks::TriggerService.execute_triggered_webhook_now(triggered_webhook, webhook_options(data))
-          if webhook_execution_result.success?
-            handle_success
+          if triggered_webhook.webhook
+            webhook_execution_result = PactBroker::Webhooks::TriggerService.execute_triggered_webhook_now(triggered_webhook, webhook_options(data))
+            if webhook_execution_result.success?
+              handle_success
+            else
+              handle_failure
+            end
           else
-            handle_failure
+            handle_webhook_deleted
           end
         rescue StandardError => e
           handle_error e
@@ -73,19 +77,24 @@ module PactBroker
       end
 
       def handle_success
-        update_triggered_webhook_status TriggeredWebhook::STATUS_SUCCESS
+        update_triggered_webhook_status(TriggeredWebhook::STATUS_SUCCESS)
       end
 
       def handle_failure
         if reschedule_job?
           reschedule_job
-          update_triggered_webhook_status TriggeredWebhook::STATUS_RETRYING
+          update_triggered_webhook_status(TriggeredWebhook::STATUS_RETRYING)
         else
           logger.info "Failed to execute webhook #{triggered_webhook.webhook_uuid} after #{retry_schedule.size + 1} attempts."
-          update_triggered_webhook_status TriggeredWebhook::STATUS_FAILURE
+          update_triggered_webhook_status(TriggeredWebhook::STATUS_FAILURE)
         end
       end
 
+      def handle_webhook_deleted
+        logger.info("Webhook with uuid #{triggered_webhook.webhook_uuid} cannot be executed it has been deleted. Marking triggered webhook as failed.")
+        update_triggered_webhook_status(TriggeredWebhook::STATUS_FAILURE)
+      end
+
       def reschedule_job?
         error_count < retry_schedule.size
       end

data/lib/pact_broker/webhooks/pact_and_verification_parameters.rb

@@ -134,7 +134,7 @@ module PactBroker
           webhook_context[:consumer_version_tags].join(", ")
         else
           if pact
-            pact.consumer_version.tags.collect(&:name).join(", ")
+            pact.consumer_version_tag_names.join(", ")
           else
             ""
           end
@@ -145,7 +145,7 @@ module PactBroker
         if webhook_context.key?(:consumer_version_branch)
           webhook_context[:consumer_version_branch] || ""
         else
-          pact&.consumer_version&.branch_names&.last || ""
+          pact&.consumer_version_branch_names&.last || ""
         end
       end
 

data/lib/pact_broker/webhooks/repository.rb

@@ -1,4 +1,3 @@
-require "sequel"
 require "pact_broker/domain/webhook"
 require "pact_broker/domain/pacticipant"
 require "pact_broker/db"

data/lib/pact_broker/webhooks/trigger_service.rb

@@ -13,11 +13,21 @@ module PactBroker
       include PactBroker::Logging
       using PactBroker::HashRefinements
 
+      # the main entry point
+      def create_triggered_webhooks_for_event pact, verification, event_name, event_context
+        webhooks = webhook_repository.find_webhooks_to_trigger(consumer: pact.consumer, provider: pact.provider, event_name: event_name)
+
+        if webhooks.any?
+          create_triggered_webhooks_for_webhooks(webhooks, pact, verification, event_name, event_context.merge(event_name: event_name))
+        else
+          []
+        end
+      end
+
       def next_uuid
         SecureRandom.uuid
       end
 
-      # TODO support currently deployed
       def test_execution webhook, event_context, execution_configuration
         merged_options = execution_configuration.with_failure_log_message("Webhook execution failed").to_hash
 
@@ -36,17 +46,6 @@ module PactBroker
         webhook_execution_result
       end
 
-      # the main entry point
-      def create_triggered_webhooks_for_event pact, verification, event_name, event_context
-        webhooks = webhook_repository.find_webhooks_to_trigger(consumer: pact.consumer, provider: pact.provider, event_name: event_name)
-
-        if webhooks.any?
-          create_triggered_webhooks_for_webhooks(webhooks, pact, verification, event_name, event_context.merge(event_name: event_name))
-        else
-          []
-        end
-      end
-
       def schedule_webhooks(triggered_webhooks, options)
         triggered_webhooks.each_with_index do | triggered_webhook, i |
           logger.info "Scheduling job for webhook with uuid #{triggered_webhook.webhook.uuid}, context: #{triggered_webhook.event_context}"

data/lib/pact_broker/webhooks/triggered_webhook.rb

@@ -1,5 +1,4 @@
-require "sequel"
-require "pact_broker/repositories/helpers"
+require "pact_broker/dataset"
 require "pact_broker/webhooks/execution"
 require "pact_broker/hash_refinements"
 
@@ -23,7 +22,7 @@ module PactBroker
       STATUS_FAILURE = "failure".freeze
 
       dataset_module do
-        include PactBroker::Repositories::Helpers
+        include PactBroker::Dataset
 
         def delete
           require "pact_broker/webhooks/execution"
@@ -70,7 +69,7 @@ module PactBroker
       def execute options
         # getting a random 'no method to_domain for null' error
         # not sure on which object, so splitting this out into two lines
-        pact = pact_publication.to_domain
+        pact = pact_publication.with_version_branches_and_tags.to_domain
         webhook.to_domain.execute(pact, verification, event_context.symbolize_keys, options)
       end
 

data/lib/pact_broker/webhooks/webhook.rb

@@ -1,4 +1,4 @@
-require "sequel"
+require "pact_broker/dataset"
 require "pact_broker/domain/webhook"
 require "pact_broker/webhooks/webhook_request_template"
 require "pact_broker/domain/pacticipant"
@@ -15,7 +15,7 @@ module PactBroker
       one_to_many :events, :class => "PactBroker::Webhooks::WebhookEvent", :reciprocal => :webhook
 
       dataset_module do
-        include PactBroker::Repositories::Helpers
+        include PactBroker::Dataset
 
         # Keep the triggered webhooks after the webhook has been deleted
         def delete

data/lib/pact_broker/webhooks/webhook_event.rb

@@ -1,5 +1,4 @@
-require "sequel"
-require "pact_broker/repositories/helpers"
+require "pact_broker/dataset"
 
 module PactBroker
   module Webhooks
@@ -17,9 +16,7 @@ module PactBroker
 
       EVENT_NAMES = [CONTRACT_PUBLISHED, CONTRACT_CONTENT_CHANGED, VERIFICATION_PUBLISHED, VERIFICATION_SUCCEEDED, VERIFICATION_FAILED, CONTRACT_REQUIRING_VERIFICATION_PUBLISHED]
 
-      dataset_module do
-        include PactBroker::Repositories::Helpers
-      end
+      dataset_module(PactBroker::Dataset)
 
       def contract_published?
         name == CONTRACT_PUBLISHED

data/lib/rack/pact_broker/add_cache_header.rb

@@ -0,0 +1,14 @@
+module Rack
+  module PactBroker
+    class AddCacheHeader
+      def initialize app
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        [status, { "Cache-Control" => "no-cache" }.merge(headers || {}), body]
+      end
+    end
+  end
+end

data/lib/rack/pact_broker/application_context.rb

@@ -0,0 +1,16 @@
+# Sets the PactBroker::ApplicationContext on the rack env if it is not already set.
+
+module Rack
+  module PactBroker
+    class ApplicationContext
+      def initialize(app, application_context)
+        @app = app
+        @application_context = application_context
+      end
+
+      def call(env)
+        @app.call({ "pactbroker.application_context" => @application_context }.merge(env))
+      end
+    end
+  end
+end

data/lib/rack/pact_broker/configurable_make_it_later.rb

@@ -1,5 +1,5 @@
 
-# Allows a default Rack middlware implementation to be set,
+# Allows a default Rack middleware implementation to be set,
 # and then be optionally changed out for a different implementation
 # after the app has been built.
 # Used for allowing the authorization code to set after the

data/lib/rack/pact_broker/invalid_uri_protection.rb

@@ -12,6 +12,8 @@ module Rack
     class InvalidUriProtection
       include ::PactBroker::Messages
 
+      CONSECUTIVE_SLASH = /\/{2,}/
+
       def initialize app
         @app = app
       end
@@ -19,12 +21,12 @@ module Rack
       def call env
         if (uri = valid_uri?(env))
           if (error_message = validate(uri))
-            [422, {"Content-Type" => "text/plain"}, [error_message]]
+            [422, headers, [body(env, error_message, "Unprocessable", "invalid-request-parameter-value", 422)]]
           else
             app.call(env)
           end
         else
-          [404, {}, []]
+          [404, headers, [body(env, "Empty path component found", "Not Found", "not-found", 404)]]
         end
       end
 
@@ -34,7 +36,9 @@ module Rack
 
       def valid_uri? env
         begin
-          parse(::Rack::Request.new(env).url)
+          uri = parse(::Rack::Request.new(env).url)
+          return nil if CONSECUTIVE_SLASH.match(uri.path)
+          uri
         rescue URI::InvalidURIError, ArgumentError
           nil
         end
@@ -52,6 +56,18 @@ module Rack
           message("errors.tab_in_url_path")
         end
       end
+
+      def headers
+        {"Content-Type" => "application/problem+json"}
+      end
+
+      def body(env, detail, title, type, status)
+        env["pactbroker.application_context"]
+          .decorator_configuration
+          .class_for(:custom_error_problem_json_decorator)
+          .new(detail: detail, title: title, type: type, status: status)
+          .to_json(user_options: { base_url: env["pactbroker.base_url"] })
+      end
     end
   end
 end

data/lib/webmachine/describe_routes.rb

@@ -1,6 +1,10 @@
 require "webmachine/adapters/rack_mapped"
 require "pact_broker/string_refinements"
 
+# Code to describe the routes in a Webmachine API, including
+# path, resource class, allowed methods, schemas, policy class.
+# Used in tests and in the pact_broker:routes task
+
 module Webmachine
   class DescribeRoutes
     using PactBroker::StringRefinements
@@ -12,18 +16,11 @@ module Webmachine
         :resource_name,
         :resource_class_location,
         :allowed_methods,
-        :policy_class,
+        :policy_names,
+        :policy_classes, # only used by pactflow
         :schemas,
         keyword_init: true) do
 
-      def [](key)
-        if respond_to?(key)
-          send(key)
-        else
-          nil
-        end
-      end
-
       def path_include?(component)
         path.include?(component)
       end
@@ -47,7 +44,7 @@ module Webmachine
         }.merge(path_params)
 
         rack_req = ::Rack::Request.new({ "REQUEST_METHOD" => "GET", "rack.input" => StringIO.new("") }.merge(env) )
-        dummy_request = Webmachine::Adapters::Rack::RackRequest.new(
+        request = Webmachine::Adapters::Rack::RackRequest.new(
           rack_req.env["REQUEST_METHOD"],
           path,
           Webmachine::Headers.from_cgi({"HTTP_HOST" => "example.org"}.merge(env)),
@@ -56,13 +53,13 @@ module Webmachine
           {},
           rack_req.env
         )
-        dummy_request.path_info = path_info
-        resource_class.new(dummy_request, Webmachine::Response.new)
+        request.path_info = path_info
+        resource_class.new(request, Webmachine::Response.new)
       end
     end
 
     def self.call(webmachine_applications, search_term: nil)
-      path_mappings = webmachine_applications.flat_map { | webmachine_application | paths_to_resource_class_mappings(webmachine_application) }
+      path_mappings = webmachine_applications.flat_map { | webmachine_application | build_routes(webmachine_application) }
 
       if search_term
         path_mappings = path_mappings.select{ |(route, _)| route[:path].include?(search_term) }
@@ -71,8 +68,10 @@ module Webmachine
       path_mappings.sort_by{ | mapping | mapping[:path] }
     end
 
-    def self.paths_to_resource_class_mappings(webmachine_application)
-      webmachine_application.routes.collect do | webmachine_route |
+    # Build a Route object to describe every Webmachine route defined in the app.routes block
+    # @return [Array<Webmachine::DescribeRoutes::Route>]
+    def self.build_routes(webmachine_application)
+      webmachine_routes_to_describe(webmachine_application).collect do | webmachine_route |
         resource_path_absolute = Pathname.new(source_location_for(webmachine_route.resource))
         Route.new({
           path: "/" + webmachine_route.path_spec.collect{ |part| part.is_a?(Symbol) ? ":#{part}" : part  }.join("/"),
@@ -80,22 +79,23 @@ module Webmachine
           resource_class: webmachine_route.resource,
           resource_name: webmachine_route.instance_variable_get(:@bindings)[:resource_name],
           resource_class_location: resource_path_absolute.relative_path_from(Pathname.pwd).to_s
-        }.merge(info_from_resource_instance(webmachine_route, webmachine_application.application_context)))
-      end.reject{ | route | route.resource_class == Webmachine::Trace::TraceResource }
+        }.merge(properties_for_webmachine_route(webmachine_route, webmachine_application.application_context)))
+      end
+    end
+
+    def self.webmachine_routes_to_describe(webmachine_application)
+      webmachine_application.routes.reject{ | route | route.resource == Webmachine::Trace::TraceResource }.collect
     end
 
-    def self.info_from_resource_instance(webmachine_route, application_context)
+    def self.properties_for_webmachine_route(webmachine_route, application_context)
       with_no_logging do
         path_info = { application_context: application_context, pacticipant_name: "foo", pacticipant_version_number: "1", resource_name: "foo" }
         path_info.default = "1"
-        dummy_request = dummy_request(http_method: "GET", path_info: path_info)
-
-        dummy_resource = webmachine_route.resource.new(dummy_request, Webmachine::Response.new)
-        if dummy_resource
-          {
-            allowed_methods: dummy_resource.allowed_methods,
-            schemas: dummy_resource.respond_to?(:schema, true) && dummy_resource.send(:schema) ? schemas(dummy_resource.allowed_methods, webmachine_route.resource, path_info) : nil
-          }.compact
+        request = build_request(http_method: "GET", path_info: path_info)
+
+        resource = webmachine_route.resource.new(request, Webmachine::Response.new)
+        if resource
+          properties_for_resource(resource.allowed_methods - ["OPTIONS"], webmachine_route, application_context)
         else
           {}
         end
@@ -105,22 +105,38 @@ module Webmachine
       {}
     end
 
-    # This is not entirely accurate, because some GET requests have schemas too, but we can't tell that statically at the moment
-    def self.schemas(allowed_methods, resource, path_info)
-      (allowed_methods - ["GET", "OPTIONS", "DELETE"]).collect do | http_method |
-        resource.new(dummy_request(http_method: http_method, path_info: path_info), Webmachine::Response.new).send(:schema)
-      end.uniq.collect do | schema_class |
-        {
-          class: schema_class,
-          location: source_location_for(schema_class)
-        }
+    # Return the properties of the resource that can only be determined by instantiating the resource
+    # @return [Hash]
+    def self.properties_for_resource(allowed_methods, webmachine_route, application_context)
+      schemas = []
+      policy_names = []
+      allowed_methods.each do | http_method |
+        resource = build_resource(webmachine_route, http_method, application_context)
+        if (schema_class = resource.respond_to?(:schema, true) && resource.send(:schema))
+          schemas << { http_method: http_method, class: schema_class, location: source_location_for(schema_class)}
+        end
+
+        policy_names << resource.policy_name
       end
+
+      {
+        allowed_methods: allowed_methods,
+        schemas: schemas,
+        policy_names: policy_names.uniq
+      }
+    end
+
+    def self.build_resource(webmachine_route, http_method, application_context)
+      path_info = { application_context: application_context, pacticipant_name: "foo", pacticipant_version_number: "1", resource_name: "foo" }
+      path_info.default = "1"
+      request = build_request(http_method: http_method, path_info: path_info)
+      webmachine_route.resource.new(request, Webmachine::Response.new)
     end
 
-    def self.dummy_request(http_method: "GET", path_info: )
-      dummy_request = Webmachine::Adapters::Rack::RackRequest.new(http_method, "/", Webmachine::Headers["host" => "example.org"], nil, {}, {}, { "REQUEST_METHOD" => http_method })
-      dummy_request.path_info = path_info
-      dummy_request
+    def self.build_request(http_method: "GET", path_info: )
+      request = Webmachine::Adapters::Rack::RackRequest.new(http_method, "/", Webmachine::Headers["host" => "example.org"], nil, {}, {}, { "REQUEST_METHOD" => http_method })
+      request.path_info = path_info
+      request
     end
 
     def self.source_location_for(clazz)

data/lib/webmachine/render_error_monkey_patch.rb

@@ -35,7 +35,7 @@ module Webmachine
       title = options[:title] if options[:title]
       message = options[:message] if options[:message]
 
-      res.body = error_response_body(message, title, title.dasherize.gsub(/^\d+\-/, ""), code, req)
+      res.body = error_response_body(req, message, title, title.dasherize.gsub(/^\d+\-/, ""), code, req)
       res.headers[CONTENT_TYPE] = error_response_content_type(req)
     end
     ensure_content_length(res)
@@ -60,11 +60,20 @@ module Webmachine
     end
   end
 
-  def self.error_response_body(detail, title, type, status, request)
+  # rubocop: disable Metrics/ParameterLists
+  def self.error_response_body(req, detail, title, type, status, request)
     if problem_json_error_content_type?(request)
-      PactBroker::Api::Decorators::CustomErrorProblemJSONDecorator.new(detail: detail, title: title, type: type, status: status).to_json
+      decorator_configuration(req)
+        .class_for(:custom_error_problem_json_decorator)
+        .new(detail: detail, title: title, type: type, status: status)
+        .to_json(user_options: { base_url: req.env["pactbroker.base_url"] })
     else
-      { error: detail }.to_json
+      decorator_configuration(req).class_for(:error_decorator).new(detail).to_json
     end
   end
+  # rubocop: enable Metrics/ParameterLists
+
+  def self.decorator_configuration(req)
+    req.env["pactbroker.application_context"].decorator_configuration
+  end
 end

data/pact_broker.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{See description}
   gem.homepage      = "https://github.com/pact-foundation/pact_broker"
 
-  gem.required_ruby_version = ">= 2.2.0"
+  gem.required_ruby_version = ">= 2.7.0"
 
   gem.files         = begin
                         if Dir.exist?(".git")
@@ -58,14 +58,14 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "webmachine", ">= 2.0.0.beta", "< 3.0"
   gem.add_runtime_dependency "webrick", "~> 1.8" # webmachine requires webrick, but doesn't declare it as a dependency :shrug:
   gem.add_runtime_dependency "semver2", "~> 3.4.2"
-  gem.add_runtime_dependency "rack", ">= 2.2.3", "~> 2.2"
+  gem.add_runtime_dependency "rack", ">= 2.2.3", "~> 2.2" # TODO update to 3
   gem.add_runtime_dependency "redcarpet", ">= 3.5.1", "~>3.5"
   gem.add_runtime_dependency "pact-support" , "~> 1.16", ">= 1.16.4"
   gem.add_runtime_dependency "padrino-core", ">= 0.14.3", "~> 0.14"
-  gem.add_runtime_dependency "sinatra", ">= 2.0.8.1", "< 3.0"
+  gem.add_runtime_dependency "sinatra", "~> 3.0"
   gem.add_runtime_dependency "haml", "~>5.0"
   gem.add_runtime_dependency "sucker_punch", "~>2.0"
-  gem.add_runtime_dependency "rack-protection", ">= 2.0.8.1", "< 3.0"
+  gem.add_runtime_dependency "rack-protection", "~> 3.0"
   gem.add_runtime_dependency "table_print", "~> 1.5"
   gem.add_runtime_dependency "semantic_logger", "~> 4.11"
   gem.add_runtime_dependency "sanitize", "~> 6.0"