webhukhs 0.5.0 → 0.7.0

data/test/received_webhook_test.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class StringIdReceivedWebhook < Webhukhs::ReceivedWebhook
+  self.table_name = "string_id_received_webhooks"
+end
+
+unless ActiveRecord::Base.connection.data_source_exists?("string_id_received_webhooks")
+  original_migration_verbose = ActiveRecord::Migration.verbose
+  ActiveRecord::Migration.verbose = false
+
+  begin
+    ActiveRecord::Schema.define do
+      create_table "string_id_received_webhooks", id: :string, force: true do |t|
+        t.string "handler_event_id", null: false
+        t.string "handler_module_name", null: false
+        t.string "status", default: "received", null: false
+        t.binary "body", null: false
+        t.json "request_headers", null: true
+        t.datetime "created_at", null: false
+        t.datetime "updated_at", null: false
+      end
+    end
+  ensure
+    ActiveRecord::Migration.verbose = original_migration_verbose
+  end
+end
+
+class ReceivedWebhookTest < ActiveSupport::TestCase
+  cover "Webhukhs::ReceivedWebhook*"
+
+  teardown do
+    Webhukhs::ReceivedWebhook.delete_all
+    StringIdReceivedWebhook.delete_all if ActiveRecord::Base.connection.data_source_exists?("string_id_received_webhooks")
+  end
+
+  test "request stores uppercase string headers and rewinds the body io" do
+    body_io = StringIO.new('{"ok":true}')
+    request = ActionDispatch::Request.new(
+      "CONTENT_TYPE" => "application/json",
+      "HTTP_X_SIGNATURE" => "sig",
+      "lowercase" => "skip",
+      "Mixed-Case" => "skip",
+      "HTTP_X_NUMBER" => 123,
+      123 => "skip",
+      "RAW_POST_DATA" => "legacy",
+      "rack.input" => body_io,
+      "action_dispatch.request.path_parameters" => {"user_id" => "123"}
+    )
+    webhook = Webhukhs::ReceivedWebhook.new
+
+    webhook.request = request
+
+    assert_equal 0, body_io.pos
+    assert_equal body_io.string.b, webhook.body
+    assert_equal Encoding::ASCII_8BIT, webhook.body.encoding
+    assert_equal(
+      {
+        "CONTENT_TYPE" => "application/json",
+        "HTTP_X_SIGNATURE" => "sig",
+        "action_dispatch.request.path_parameters" => {"user_id" => "123"}
+      },
+      webhook.request_headers
+    )
+  end
+
+  test "request writer coerces the stored body to binary before type casting" do
+    body_io = StringIO.new("payload")
+    request = ActionDispatch::Request.new(
+      "CONTENT_TYPE" => "application/json",
+      "rack.input" => body_io,
+      "action_dispatch.request.path_parameters" => {}
+    )
+    webhook = Webhukhs::ReceivedWebhook.new
+    captured_body = nil
+
+    with_overridden_singleton_method(webhook, :write_attribute, ->(name, value) {
+      captured_body = value if name == "body"
+    }) do
+      webhook.request = request
+
+      assert_equal "payload".b, captured_body
+      assert_equal Encoding::ASCII_8BIT, captured_body.encoding
+    end
+  end
+
+  test "request rejects oversized bodies and rewinds the body io" do
+    original_limit = Webhukhs.configuration.request_body_size_limit
+    Webhukhs.configuration.request_body_size_limit = 3
+
+    body_io = StringIO.new("four")
+    request = ActionDispatch::Request.new(
+      "CONTENT_TYPE" => "application/json",
+      "rack.input" => body_io,
+      "action_dispatch.request.path_parameters" => {}
+    )
+    webhook = Webhukhs::ReceivedWebhook.new
+
+    error = assert_raises(RuntimeError) { webhook.request = request }
+
+    assert_equal "Cannot accept the webhook as the request body is larger than 3 bytes", error.message
+    assert_equal 0, body_io.pos
+  ensure
+    Webhukhs.configuration.request_body_size_limit = original_limit
+  end
+
+  test "request reconstructs the body without mutating stored headers" do
+    request_headers = {
+      "CONTENT_TYPE" => "application/json",
+      "action_dispatch.request.path_parameters" => {"user_id" => "123"}
+    }
+    webhook = Webhukhs::ReceivedWebhook.new(
+      handler_event_id: "request-read",
+      handler_module_name: "WebhookTestHandler",
+      status: "received",
+      body: "payload",
+      request_headers: request_headers.deep_dup
+    )
+
+    request = webhook.request
+    request_body = request.body.read
+
+    assert_equal "payload".b, request_body.b
+    assert_equal Encoding::ASCII_8BIT, request_body.encoding
+    assert_equal request_headers, webhook.request_headers
+  end
+
+  test "request reader coerces the reconstructed body to binary" do
+    webhook = Webhukhs::ReceivedWebhook.new
+
+    request_headers = {
+      "CONTENT_TYPE" => "application/json",
+      "action_dispatch.request.path_parameters" => {}
+    }
+
+    with_overridden_singleton_methods(webhook, {
+      body: -> { "payload" },
+      request_headers: -> {
+        request_headers
+      }
+    }) do
+      request_body = webhook.request.body.read
+
+      assert_equal "payload".b, request_body.b
+      assert_equal Encoding::ASCII_8BIT, request_body.encoding
+    end
+  end
+
+  test "assigns uuid ids for string primary keys" do
+    with_overridden_singleton_methods(SecureRandom, {
+      respond_to?: ->(method_name, include_all = false) {
+        method_name == :uuid_v7 || super(method_name, include_all)
+      },
+      uuid_v7: -> {
+        "00000000-0000-7000-8000-000000000001"
+      },
+      uuid: -> {
+        "00000000-0000-4000-8000-000000000002"
+      }
+    }) do
+      webhook = StringIdReceivedWebhook.create!(
+        handler_event_id: "generated-id-event",
+        handler_module_name: "WebhookTestHandler",
+        status: "received",
+        body: {}.to_json,
+        request_headers: {}
+      )
+
+      assert_equal "00000000-0000-7000-8000-000000000001", webhook.id
+    end
+  end
+
+  test "falls back to uuid when uuid_v7 is unavailable" do
+    with_overridden_singleton_methods(SecureRandom, {
+      respond_to?: ->(method_name, include_all = false) {
+        (method_name == :uuid_v7) ? false : super(method_name, include_all)
+      },
+      uuid_v7: -> {
+        raise "uuid_v7 should not be called when unavailable"
+      },
+      uuid: -> {
+        "00000000-0000-4000-8000-000000000002"
+      }
+    }) do
+      webhook = StringIdReceivedWebhook.create!(
+        handler_event_id: "fallback-id-event",
+        handler_module_name: "WebhookTestHandler",
+        status: "received",
+        body: {}.to_json,
+        request_headers: {}
+      )
+
+      assert_equal "00000000-0000-4000-8000-000000000002", webhook.id
+    end
+  end
+
+  test "does not call uuid generation for integer primary keys" do
+    with_overridden_singleton_methods(SecureRandom, {
+      uuid_v7: -> {
+        raise "uuid_v7 should not be called for integer primary keys"
+      },
+      uuid: -> {
+        raise "uuid should not be called for integer primary keys"
+      }
+    }) do
+      webhook = Webhukhs::ReceivedWebhook.create!(
+        handler_event_id: "integer-id-event",
+        handler_module_name: "WebhookTestHandler",
+        status: "received",
+        body: {}.to_json,
+        request_headers: {}
+      )
+
+      assert_kind_of Integer, webhook.id
+    end
+  end
+
+  test "does not overwrite explicitly assigned string ids" do
+    webhook = StringIdReceivedWebhook.create!(
+      id: "manual-id",
+      handler_event_id: "manual-id-event",
+      handler_module_name: "WebhookTestHandler",
+      status: "received",
+      body: {}.to_json,
+      request_headers: {}
+    )
+
+    assert_equal "manual-id", webhook.id
+  end
+
+  test "assigns a uuid when a string id is blank" do
+    webhook = StringIdReceivedWebhook.create!(
+      id: "",
+      handler_event_id: "blank-id-event",
+      handler_module_name: "WebhookTestHandler",
+      status: "received",
+      body: {}.to_json,
+      request_headers: {}
+    )
+
+    assert_match(/\A[0-9a-f-]{36}\z/, webhook.id)
+  end
+end

data/test/test_app.rb

@@ -5,24 +5,46 @@ require "action_pack"
 require "action_controller"
 require "rails"
 
-database = "development.sqlite3"
-ENV["DATABASE_URL"] = "sqlite3:#{database}"
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: database)
-ActiveRecord::Base.logger = Logger.new(nil)
-ActiveRecord::Schema.define do
-  create_table "received_webhooks", force: :cascade do |t|
-    t.string "handler_event_id", null: false
-    t.string "handler_module_name", null: false
-    t.string "status", default: "received", null: false
-    t.binary "body", null: false
-    t.json "request_headers", null: true
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["handler_module_name", "handler_event_id"], name: "webhook_dedup_idx", unique: true
-    t.index ["status"], name: "index_received_webhooks_on_status"
+module Test
+  DEFAULT_DATABASE_PATH = File.expand_path("development.sqlite3", __dir__)
+  DEFAULT_DATABASE_URL = "sqlite3:#{DEFAULT_DATABASE_PATH}"
+
+  def self.database_url
+    ENV.fetch("DATABASE_URL", DEFAULT_DATABASE_URL)
+  end
+
+  def self.database_path
+    File.expand_path(database_url.delete_prefix("sqlite3:"))
+  end
+
+  def self.establish_database_connection
+    database = database_path
+
+    ENV["DATABASE_URL"] = database_url
+    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: database)
+    ActiveRecord::Base.logger = Logger.new(nil)
+  end
+
+  def self.define_test_schema
+    ActiveRecord::Schema.define do
+      create_table "received_webhooks", force: :cascade do |t|
+        t.string "handler_event_id", null: false
+        t.string "handler_module_name", null: false
+        t.string "status", default: "received", null: false
+        t.binary "body", null: false
+        t.json "request_headers", null: true
+        t.datetime "created_at", null: false
+        t.datetime "updated_at", null: false
+        t.index ["handler_module_name", "handler_event_id"], name: "webhook_dedup_idx", unique: true
+        t.index ["status"], name: "index_received_webhooks_on_status"
+      end
+    end
   end
 end
 
+Test.establish_database_connection
+Test.define_test_schema
+
 require_relative "../lib/webhukhs"
 require_relative "test-webhook-handlers/webhook_test_handler"
 require_relative "test-webhook-handlers/inactive_handler"

data/test/test_helper.rb

@@ -1,5 +1,18 @@
 require_relative "test_app"
 require "rails/test_help"
+require "mutant/minitest/coverage"
+require "active_support/logger"
+require "stringio"
+
+if ENV["SIMPLECOV"]
+  require "simplecov"
+
+  SimpleCov.start do
+    add_filter "/spec/"
+    minimum_coverage 100
+    minimum_coverage_by_file 100
+  end
+end
 
 class ActiveSupport::TestCase
   # Same as "assert_changes" in Rails but for countable entities.
@@ -47,4 +60,57 @@ class ActiveSupport::TestCase
 
     retval
   end
+
+  def with_overridden_singleton_method(target, method_name, implementation, &block)
+    with_overridden_singleton_methods(target, {method_name => implementation}, &block)
+  end
+
+  def with_captured_info_logs(logger_owner)
+    messages = []
+    original_logger = logger_owner.logger
+    test_logger = ActiveSupport::Logger.new(StringIO.new)
+    test_logger.level = Logger::INFO
+    test_logger.formatter = lambda do |_severity, _time, _progname, message|
+      messages << message
+      ""
+    end
+
+    logger_owner.logger = test_logger
+    yield messages
+  ensure
+    logger_owner.logger = original_logger
+  end
+
+  def with_overridden_singleton_methods(target, methods)
+    singleton_class = target.singleton_class
+    original_names = methods.keys.each_with_index.to_h do |name, index|
+      sanitized_name = name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      [name, :"__original_#{sanitized_name}_for_test_#{object_id}_#{index}"]
+    end
+
+    silence_warnings do
+      singleton_class.class_eval do
+        original_names.each do |name, original_name|
+          alias_method original_name, name
+        end
+
+        methods.each do |name, override|
+          define_method(name, &override)
+        end
+      end
+    end
+
+    yield
+  ensure
+    silence_warnings do
+      singleton_class.class_eval do
+        original_names.each do |name, original_name|
+          next unless method_defined?(original_name)
+
+          alias_method name, original_name
+          remove_method original_name
+        end
+      end
+    end
+  end
 end

data/test/webhukhs_test.rb

@@ -1,9 +1,28 @@
 # frozen_string_literal: true
 
 require "test_helper"
-require_relative "test_app"
+
+class FailingLookupReceiveWebhooksController < Webhukhs::ReceiveWebhooksController
+  def initialize(error)
+    super()
+    @error = error
+  end
+
+  def service_id = "broken"
+
+  def lookup_handler(_service_id)
+    raise @error
+  end
+end
 
 class TestWebhukhs < ActionDispatch::IntegrationTest
+  cover "Webhukhs*"
+  cover "Webhukhs::BaseHandler*"
+  cover "Webhukhs::Configuration*"
+  cover "Webhukhs::ProcessingJob*"
+  cover "Webhukhs::ReceiveWebhooksController*"
+  cover "Webhukhs::ReceivedWebhook*"
+
   teardown { Webhukhs::ReceivedWebhook.delete_all }
 
   def test_that_it_has_a_version_number
@@ -28,6 +47,39 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
     test(msg) { skip }
   end
 
+  test "returns a memoized configuration object and yields it to configure" do
+    original_configuration = Webhukhs.instance_variable_get(:@configuration)
+    Webhukhs.remove_instance_variable(:@configuration) if Webhukhs.instance_variable_defined?(:@configuration)
+
+    configuration = Webhukhs.configuration
+
+    assert_instance_of Webhukhs::Configuration, configuration
+    assert_same configuration, Webhukhs.configuration
+
+    yielded = nil
+    Webhukhs.configure { |config| yielded = config }
+
+    assert_same configuration, yielded
+  ensure
+    Webhukhs.instance_variable_set(:@configuration, original_configuration)
+  end
+
+  test "applies the configured error context before handling requests" do
+    original_error_context = Webhukhs.configuration.error_context
+
+    Webhukhs.configuration.error_context = {component: "webhooks"}
+
+    report = assert_error_reported(RuntimeError) do
+      post "/webhukhs/failing-with-concealed-errors", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+      assert_response 200
+    end
+
+    assert_equal "webhooks", report.context[:component]
+  ensure
+    Webhukhs.configuration.error_context = original_error_context
+  end
+
   test "ensure webhook is processed only once during creation" do
     tf = Tempfile.new
     body = {isValid: true, outputToFilename: tf.path}
@@ -36,6 +88,7 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
     assert_enqueued_jobs 1, only: Webhukhs::ProcessingJob do
       post "/webhukhs/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
       assert_response 200
+      assert_equal({"ok" => true, "error" => nil}, response.parsed_body)
     end
   end
 
@@ -133,23 +186,40 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
   end
 
   test "raises an error if the service_id is not known" do
-    post "/webhukhs/missing_service", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
-    assert_response 404
+    report = assert_error_reported(Webhukhs::ReceiveWebhooksController::UnknownHandler) do
+      post "/webhukhs/missing_service", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+      assert_response 404
+      assert_equal "No handler found for \"missing_service\"", response.parsed_body["error"]
+    end
+
+    assert_predicate report, :handled?
+    assert_equal :error, report.severity
   end
 
   test "returns a 503 when a handler is inactive" do
-    post "/webhukhs/inactive", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+    report = assert_error_reported(Webhukhs::ReceiveWebhooksController::HandlerInactive) do
+      post "/webhukhs/inactive", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+      assert_response 503
+      assert_equal 'Webhook handler "inactive" is inactive', response.parsed_body["error"]
+    end
 
-    assert_response 503
-    assert_equal 'Webhook handler "inactive" is inactive', response.parsed_body["error"]
+    assert_predicate report, :handled?
+    assert_equal :error, report.severity
   end
 
   test "returns a 200 status and error message if the handler does not expose errors" do
-    post "/webhukhs/failing-with-concealed-errors", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+    report = assert_error_reported(RuntimeError) do
+      post "/webhukhs/failing-with-concealed-errors", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
 
-    assert_response 200
-    assert_equal false, response.parsed_body["ok"]
-    assert response.parsed_body["error"]
+      assert_response 200
+      assert_equal false, response.parsed_body["ok"]
+      assert_equal "Internal error (oops)", response.parsed_body["error"]
+    end
+
+    assert_predicate report, :handled?
+    assert_equal :error, report.severity
   end
 
   test "returns a 500 status and error message if the handler does not expose errors" do
@@ -160,6 +230,40 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
     # common Rails error page
   end
 
+  test "re-raises lookup errors before a handler has been assigned" do
+    original_active_handlers = Webhukhs.configuration.active_handlers
+    Webhukhs.configuration.active_handlers = original_active_handlers.merge(broken: "MissingHandler")
+
+    post "/webhukhs/broken", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+    assert_response 500
+    assert_includes response.body, "NameError"
+    assert_includes response.body, "MissingHandler"
+  ensure
+    Webhukhs.configuration.active_handlers = original_active_handlers
+  end
+
+  test "re-raises the original error when lookup fails before assigning a handler" do
+    original_error = NameError.new("uninitialized constant MissingHandler")
+    controller = FailingLookupReceiveWebhooksController.new(original_error)
+
+    raised_error = assert_raises(NameError) { controller.create }
+
+    assert_same original_error, raised_error
+  end
+
+  test "accepts handlers configured as class constants" do
+    original_active_handlers = Webhukhs.configuration.active_handlers
+    Webhukhs.configuration.active_handlers = original_active_handlers.merge(class_handler: WebhookTestHandler)
+
+    post "/webhukhs/class_handler", params: {isValid: false, outputToFilename: "/tmp/unused"}.to_json, headers: {"CONTENT_TYPE" => "application/json"}
+
+    assert_response 200
+    assert_equal({"ok" => true, "error" => nil}, response.parsed_body)
+  ensure
+    Webhukhs.configuration.active_handlers = original_active_handlers
+  end
+
   test "deduplicates received webhooks based on the event ID" do
     body = {event_id: SecureRandom.uuid, body: "test"}.to_json
 
@@ -200,4 +304,16 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
       assert_equal "received", webhook.status
     end
   end
+
+  test "ensure_id does not override id for integer primary key columns" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: SecureRandom.uuid,
+      handler_module_name: "WebhookTestHandler",
+      status: "received",
+      body: {isValid: true}.to_json
+    )
+
+    assert_kind_of Integer, webhook.id
+    assert webhook.id > 0
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webhukhs
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Stanislav Katkov
@@ -108,9 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 description: Webhukhs is a Rails engine for processing webhooks from various services.
-  Engine saves webhook in database first and later processes webhook in async process.
-  Supports custom handlers with Webhukhs::BaseHandler and integrates with Rails common
-  error reporter.
+  Engine saves webhook in database first and later processes in async job.
 email:
 - github@skatkov.com
 executables: []
@@ -120,11 +118,15 @@ files:
 - ".editorconfig"
 - ".rubocop.yml"
 - ".standard.yml"
+- ".yard-lint.yml"
+- AGENTS.md
 - Appraisals
 - CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
+- config/mutant.rb
+- config/mutant.yml
 - config/routes.rb
 - example/.gitattributes
 - example/.gitignore
@@ -193,6 +195,7 @@ files:
 - gemfiles/rails_8.0.gemfile.lock
 - gemfiles/rails_8.1.gemfile
 - gemfiles/rails_8.1.gemfile.lock
+- gemfiles/rails_master.gemfile
 - handler-examples/customer_io_handler.rb
 - handler-examples/revolut_business_v1_handler.rb
 - handler-examples/revolut_business_v2_handler.rb
@@ -209,6 +212,9 @@ files:
 - lib/webhukhs/templates/create_webhukhs_tables.rb.erb
 - lib/webhukhs/templates/webhukhs.rb
 - lib/webhukhs/version.rb
+- test/base_handler_test.rb
+- test/processing_job_test.rb
+- test/received_webhook_test.rb
 - test/test-webhook-handlers/.DS_Store
 - test/test-webhook-handlers/extract_id_handler.rb
 - test/test-webhook-handlers/failing_with_concealed_errors.rb
@@ -241,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.1
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Webhooks processing engine for Rails applications
 test_files: []