webhukhs 0.6.0 → 0.8.0

data/test/processing_job_test.rb

@@ -1,25 +1,167 @@
 # frozen_string_literal: true
 
 require "test_helper"
-require_relative "test_app"
+
+class SkipDuringProcessingHandler < Webhukhs::BaseHandler
+  def process(webhook)
+    webhook.skipped!
+  end
+end
+
+class LoggingHandler < Webhukhs::BaseHandler
+  class_attribute :processed_webhook_ids, default: []
+
+  def self.reset!
+    self.processed_webhook_ids = []
+  end
+
+  def to_s = self.class.name
+
+  def valid?(_request) = true
+
+  def process(webhook)
+    self.class.processed_webhook_ids += [webhook.id]
+  end
+end
+
+class InvalidLoggingHandler < LoggingHandler
+  def valid?(_request) = false
+end
 
 class ProcessingJobTest < ActiveJob::TestCase
-  teardown { Webhukhs::ReceivedWebhook.delete_all }
+  cover "Webhukhs::ProcessingJob*"
+
+  teardown do
+    Webhukhs::ReceivedWebhook.delete_all
+    LoggingHandler.reset!
+    InvalidLoggingHandler.reset!
+  end
 
-  test "discards job and reports error when webhook argument is nil" do
-    assert_error_reported(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
-      Webhukhs::ProcessingJob.perform_now(nil)
+  test "discards job and reports invalid webhook arguments" do
+    [nil, "not a webhook"].each do |argument|
+      assert_error_reported(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
+        Webhukhs::ProcessingJob.perform_now(argument)
+      end
     end
+  end
+
+  test "raises specific invalid webhook argument messages" do
+    {
+      nil => "ProcessingJob received nil webhook argument",
+      "not a webhook" => "ProcessingJob expected Webhukhs::ReceivedWebhook, got String"
+    }.each do |argument, message|
+      error = assert_raises(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
+        Webhukhs::ProcessingJob.new.perform(argument)
+      end
 
-    assert_no_enqueued_jobs only: Webhukhs::ProcessingJob
+      assert_equal message, error.message
+    end
   end
 
-  test "discards job and reports error when webhook argument is not a ReceivedWebhook" do
-    assert_error_reported(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
-      Webhukhs::ProcessingJob.perform_now("not a webhook")
+  test "processes webhooks under a lock" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: "lock-test",
+      handler_module_name: "WebhookTestHandler",
+      status: "received",
+      body: {isValid: false}.to_json,
+      request_headers: {
+        "CONTENT_TYPE" => "application/json",
+        "action_dispatch.request.path_parameters" => {}
+      }
+    )
+    with_lock_called = false
+
+    webhook.define_singleton_method(:with_lock) do |&block|
+      with_lock_called = true
+      block.call
     end
 
-    assert_no_enqueued_jobs only: Webhukhs::ProcessingJob
+    Webhukhs::ProcessingJob.new.perform(webhook)
+
+    assert_true with_lock_called
+    assert_predicate webhook.reload, :failed_validation?
+  end
+
+  test "logs when processing is skipped because the webhook is not received" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: "skip-log-test",
+      handler_module_name: "LoggingHandler",
+      status: "processing",
+      body: {}.to_json,
+      request_headers: {}
+    )
+    job = Webhukhs::ProcessingJob.new
+    details = "Webhukhs::ReceivedWebhook##{webhook.id} (handler: LoggingHandler)"
+
+    with_captured_info_logs(Webhukhs::ProcessingJob) do |messages|
+      job.perform(webhook)
+
+      assert_equal ["#{details} is being processed in a different job or has been processed already, skipping."], messages
+    end
+  end
+
+  test "logs when processing starts and completes" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: "success-log-test",
+      handler_module_name: "LoggingHandler",
+      status: "received",
+      body: {}.to_json,
+      request_headers: {
+        "CONTENT_TYPE" => "application/json",
+        "action_dispatch.request.path_parameters" => {}
+      }
+    )
+    job = Webhukhs::ProcessingJob.new
+    details = "Webhukhs::ReceivedWebhook##{webhook.id} (handler: LoggingHandler)"
+
+    with_captured_info_logs(Webhukhs::ProcessingJob) do |messages|
+      job.perform(webhook)
+
+      assert_equal ["#{details} starting to process", "#{details} processed"], messages
+    end
+
+    assert_predicate webhook.reload, :processed?
+    assert_equal [webhook.id], LoggingHandler.processed_webhook_ids
+  end
+
+  test "logs when validation fails" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: "failed-validation-log-test",
+      handler_module_name: "InvalidLoggingHandler",
+      status: "received",
+      body: {}.to_json,
+      request_headers: {
+        "CONTENT_TYPE" => "application/json",
+        "action_dispatch.request.path_parameters" => {}
+      }
+    )
+    job = Webhukhs::ProcessingJob.new
+    details = "Webhukhs::ReceivedWebhook##{webhook.id} (handler: InvalidLoggingHandler)"
+
+    with_captured_info_logs(Webhukhs::ProcessingJob) do |messages|
+      job.perform(webhook)
+
+      assert_equal ["#{details} did not pass validation by the handler. Marking it `failed_validation`."], messages
+    end
+
+    assert_predicate webhook.reload, :failed_validation?
+  end
+
+  test "does not overwrite webhook state changed by the handler" do
+    webhook = Webhukhs::ReceivedWebhook.create!(
+      handler_event_id: "skip-test",
+      handler_module_name: "SkipDuringProcessingHandler",
+      status: "received",
+      body: {}.to_json,
+      request_headers: {
+        "CONTENT_TYPE" => "application/json",
+        "action_dispatch.request.path_parameters" => {}
+      }
+    )
+
+    Webhukhs::ProcessingJob.new.perform(webhook)
+
+    assert_predicate webhook.reload, :skipped?
   end
 
   test "discards job and reports error when webhook record has been deleted (DeserializationError)" do
@@ -36,7 +178,5 @@ class ProcessingJobTest < ActiveJob::TestCase
     assert_error_reported(ActiveJob::DeserializationError) do
       perform_enqueued_jobs
     end
-
-    assert_no_enqueued_jobs only: Webhukhs::ProcessingJob
   end
 end

data/test/received_webhook_test.rb

@@ -0,0 +1,260 @@
+# 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 stores the whole body even if the body io was already read" do
+    body_io = StringIO.new("event=paid")
+    body_io.read
+    request = ActionDispatch::Request.new(
+      "CONTENT_TYPE" => "application/x-www-form-urlencoded",
+      "rack.input" => body_io,
+      "action_dispatch.request.path_parameters" => {}
+    )
+    webhook = Webhukhs::ReceivedWebhook.new
+
+    webhook.request = request
+
+    assert_equal "event=paid".b, webhook.body
+    assert_equal 0, body_io.pos
+  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,25 +5,48 @@ 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 "../lib/webhukhs/admin"
 require_relative "test-webhook-handlers/webhook_test_handler"
 require_relative "test-webhook-handlers/inactive_handler"
 require_relative "test-webhook-handlers/invalid_handler"
@@ -58,6 +81,7 @@ class WebhukhsTestApp < Rails::Application
   routes.append do
     mount Webhukhs::Engine, at: "/webhukhs"
     post "/per-user-webhukhs/:user_id/:service_id" => "webhukhs/receive_webhooks#create"
+    mount Webhukhs::Admin::Engine, at: "/admin"
   end
 end
 

data/test/test_helper.rb

@@ -1,5 +1,21 @@
+if ENV["SIMPLECOV"]
+  require "simplecov"
+
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/test/"
+    add_filter "/lib/webhukhs/install_generator.rb"
+    minimum_coverage 100
+    minimum_coverage_by_file 100
+  end
+end
+
 require_relative "test_app"
 require "rails/test_help"
+require "minitest/strict"
+require "mutant/minitest/coverage"
+require "active_support/logger"
+require "stringio"
 
 class ActiveSupport::TestCase
   # Same as "assert_changes" in Rails but for countable entities.
@@ -47,4 +63,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