munster 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3f84bd06c033ef585c3282701915793b981142351824cc7bba2f41c5bcde4b
-  data.tar.gz: 9e614a61681b3bed5667905ae378a357fcfa96d85c79b7d85c32473c2b763c4f
+  metadata.gz: 1cc63f1db75010013d7ad528bfcc3d4aa52c8d4242ee93a5baff4ecbe6673d01
+  data.tar.gz: b8458f7196754f2bde9440b37e4fac46f308e713ed21fca28b700c54aa599168
 SHA512:
-  metadata.gz: 616dc8e6585239309106444bb65de90d572e946e08479044459e5f8deb764d0d308d22da895152e3d7250345a81640f627ea72485daf17d6d51b03299d29f5c3
-  data.tar.gz: 369a9b8ce33c83e876836f652b57fc618a82e3028818531f6bc98d8732fad53cc7a926d6faf2ad8711c5e08ac3e0c9ec23de06a95b597087f86091dfb78e6240
+  metadata.gz: 4a8ee7017935cb805c69f7cf0f31b88356b00466159040d5f67b763d19643844246485b3db0d8f4302dfd3ab02b9ff862cabf1fb541a0b338e237897e1327723
+  data.tar.gz: 6ac65ba57bebe9fce221ae820369b20eb78c69823c021a9d74b58d38122a7ac6e6918ba84e63d16db4b60330684bf358f4ec72c55590afddccfaa3113ce7d841

data/CHANGELOG.md

@@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file.
 
 This format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.4.2
+
+- When processing a webhook, print messages to the ActiveJob logger. This allows for quicker debugging if the app does not have an error tracking service set up
+
 ## 0.4.1
 
 - Webhook processor now requires `active_job/railtie`, instead of `active_job`. It requires GlobalID to work and that get's required only with railtie.

data/lib/munster/jobs/processing_job.rb

@@ -4,23 +4,25 @@ require "active_job/railtie"
 
 module Munster
   class ProcessingJob < ActiveJob::Base
-    class WebhookPayloadInvalid < StandardError
-    end
-
     def perform(webhook)
       Rails.error.set_context(munster_handler_module_name: webhook.handler_module_name, **Munster.configuration.error_context)
 
+      webhook_details_for_logs = "Munster::ReceivedWebhook#%s (handler: %s)" % [webhook.id, webhook.handler]
       webhook.with_lock do
-        return unless webhook.received?
+        unless webhook.received?
+          logger.info { "#{webhook_details_for_logs} is being processed in a different job or has been processed already, skipping." }
+          return
+        end
         webhook.processing!
       end
 
       if webhook.handler.valid?(webhook.request)
+        logger.info { "#{webhook_details_for_logs} starting to process" }
         webhook.handler.process(webhook)
         webhook.processed! if webhook.processing?
+        logger.info { "#{webhook_details_for_logs} processed" }
       else
-        e = WebhookPayloadInvalid.new("#{webhook.class} #{webhook.id} did not pass validation and was skipped")
-        Rails.error.report(e, handled: true, severity: :error)
+        logger.info { "#{webhook_details_for_logs} did not pass validation by the handler. Marking it `failed_validation`." }
         webhook.failed_validation!
       end
     rescue => e

data/lib/munster/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Munster
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/test/munster_test.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "test_app"
+
+class TestMunster < ActionDispatch::IntegrationTest
+  teardown { Munster::ReceivedWebhook.delete_all }
+
+  def test_that_it_has_a_version_number
+    refute_nil ::Munster::VERSION
+  end
+
+  def webhook_body
+    <<~JSON
+      {
+        "provider_id": "musterbank-flyio",
+        "starts_at": "<%= Time.now.utc %>",
+        "external_source": "The Forge Of Downtime",
+        "external_ticket_title": "DOWN-123",
+        "internal_description_markdown": "A test has failed"
+      }
+    JSON
+  end
+
+  Munster.configure do |config|
+    config.active_handlers = {
+      test: WebhookTestHandler,
+      inactive: "InactiveHandler",
+      invalid: "InvalidHandler",
+      private: "PrivateHandler",
+      "failing-with-exposed-errors": "FailingWithExposedErrors",
+      "failing-with-concealed-errors": "FailingWithConcealedErrors",
+      extract_id: "ExtractIdHandler"
+    }
+  end
+  self.app = MunsterTestApp
+
+  def self.xtest(msg)
+    test(msg) { skip }
+  end
+
+  test "ensure webhook is processed only once during creation" do
+    tf = Tempfile.new
+    body = {isValid: true, outputToFilename: tf.path}
+    body_json = body.to_json
+
+    assert_enqueued_jobs 1, only: Munster::ProcessingJob do
+      post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+      assert_response 200
+    end
+  end
+
+  test "accepts a webhook, stores and processes it" do
+    tf = Tempfile.new
+    body = {isValid: true, outputToFilename: tf.path}
+    body_json = body.to_json
+
+    post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 200
+
+    webhook = Munster::ReceivedWebhook.last!
+
+    assert_predicate webhook, :received?
+    assert_equal "WebhookTestHandler", webhook.handler_module_name
+    assert_equal webhook.status, "received"
+    assert_equal webhook.body, body_json
+
+    perform_enqueued_jobs
+    assert_predicate webhook.reload, :processed?
+    tf.rewind
+    assert_equal tf.read, body_json
+  end
+
+  test "accepts a webhook but does not process it if it is invalid" do
+    tf = Tempfile.new
+    body = {isValid: false, outputToFilename: tf.path}
+    body_json = body.to_json
+
+    post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 200
+
+    webhook = Munster::ReceivedWebhook.last!
+
+    assert_predicate webhook, :received?
+    assert_equal "WebhookTestHandler", webhook.handler_module_name
+    assert_equal webhook.status, "received"
+    assert_equal webhook.body, body_json
+
+    perform_enqueued_jobs
+    assert_predicate webhook.reload, :failed_validation?
+
+    tf.rewind
+    assert_predicate tf.read, :empty?
+  end
+
+  test "marks a webhook as errored if it raises during processing" do
+    tf = Tempfile.new
+    body = {isValid: true, raiseDuringProcessing: true, outputToFilename: tf.path}
+    body_json = body.to_json
+
+    post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 200
+
+    webhook = Munster::ReceivedWebhook.last!
+
+    assert_predicate webhook, :received?
+    assert_equal "WebhookTestHandler", webhook.handler_module_name
+    assert_equal webhook.status, "received"
+    assert_equal webhook.body, body_json
+
+    assert_raises(StandardError) { perform_enqueued_jobs }
+    assert_predicate webhook.reload, :error?
+
+    tf.rewind
+    assert_predicate tf.read, :empty?
+  end
+
+  test "does not accept a test payload that is larger than the configured maximum size" do
+    oversize = Munster.configuration.request_body_size_limit + 1
+    utf8_junk = Base64.strict_encode64(Random.bytes(oversize))
+    body = {isValid: true, filler: utf8_junk, raiseDuringProcessing: false, outputToFilename: "/tmp/nothing"}
+    body_json = body.to_json
+
+    post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_raises(ActiveRecord::RecordNotFound) { Munster::ReceivedWebhook.last! }
+  end
+
+  test "does not try to process a webhook if it is not in `received' state" do
+    tf = Tempfile.new
+    body = {isValid: true, raiseDuringProcessing: true, outputToFilename: tf.path}
+    body_json = body.to_json
+
+    post "/munster/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 200
+
+    webhook = Munster::ReceivedWebhook.last!
+    webhook.processing!
+
+    perform_enqueued_jobs
+    assert_predicate webhook.reload, :processing?
+
+    tf.rewind
+    assert_predicate tf.read, :empty?
+  end
+
+  test "raises an error if the service_id is not known" do
+    post "/munster/missing_service", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 404
+  end
+
+  test "returns a 503 when a handler is inactive" do
+    post "/munster/inactive", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+    assert_response 503
+    assert_equal 'Webhook handler "inactive" is inactive', response.parsed_body["error"]
+  end
+
+  test "returns a 200 status and error message if the handler does not expose errors" do
+    post "/munster/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"]
+  end
+
+  test "returns a 500 status and error message if the handler does not expose errors" do
+    post "/munster/failing-with-exposed-errors", params: webhook_body, headers: {"CONTENT_TYPE" => "application/json"}
+
+    assert_response 500
+    # The response generation in this case is done by Rails, through the
+    # common Rails error page
+  end
+
+  test "deduplicates received webhooks based on the event ID" do
+    body = {event_id: SecureRandom.uuid, body: "test"}.to_json
+
+    assert_changes_by -> { Munster::ReceivedWebhook.count }, exactly: 1 do
+      3.times do
+        post "/munster/extract_id", params: body, headers: {"CONTENT_TYPE" => "application/json"}
+        assert_response 200
+      end
+    end
+  end
+
+  test "preserves the route params and the request params in the serialised request stored with the webhook" do
+    body = {user_name: "John", number_of_dependents: 14}.to_json
+
+    Munster::ReceivedWebhook.delete_all
+    post "/per-user-munster/123/private", params: body, headers: {"CONTENT_TYPE" => "application/json"}
+    assert_response 200
+
+    received_webhook = Munster::ReceivedWebhook.first!
+    assert_predicate received_webhook, :received?
+    assert_equal body, received_webhook.request.body.read
+    assert_equal "John", received_webhook.request.params["user_name"]
+    assert_equal 14, received_webhook.request.params["number_of_dependents"]
+    assert_equal "123", received_webhook.request.params["user_id"]
+  end
+
+  test "erroneous webhook could be processed again" do
+    webhook = Munster::ReceivedWebhook.create(
+      handler_event_id: "test",
+      handler_module_name: "WebhookTestHandler",
+      status: "error",
+      body: {isValid: true}.to_json
+    )
+
+    assert_enqueued_jobs 1, only: Munster::ProcessingJob do
+      webhook.received!
+
+      assert_equal "received", webhook.status
+    end
+  end
+end

data/test/test-webhook-handlers/extract_id_handler.rb

@@ -0,0 +1,5 @@
+class ExtractIdHandler < WebhookTestHandler
+  def extract_event_id_from_request(action_dispatch_request)
+    JSON.parse(action_dispatch_request.body.read).fetch("event_id")
+  end
+end

data/test/test-webhook-handlers/failing_with_concealed_errors.rb

@@ -0,0 +1,7 @@
+class FailingWithConcealedErrors < Munster::BaseHandler
+  def handle(_request)
+    raise "oops"
+  end
+
+  def expose_errors_to_sender? = false
+end

data/test/test-webhook-handlers/failing_with_exposed_errors.rb

@@ -0,0 +1,7 @@
+class FailingWithExposedErrors < Munster::BaseHandler
+  def handle(_request)
+    raise "oops"
+  end
+
+  def expose_errors_to_sender? = true
+end

data/test/test-webhook-handlers/inactive_handler.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class InactiveHandler < WebhookTestHandler
+  def active? = false
+end

data/test/test-webhook-handlers/invalid_handler.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class InvalidHandler < WebhookTestHandler
+  def valid?(request) = false
+end

data/test/test-webhook-handlers/private_handler.rb

@@ -0,0 +1,3 @@
+class PrivateHandler < WebhookTestHandler
+  def expose_errors_to_sender? = false
+end

data/test/test-webhook-handlers/webhook_test_handler.rb

@@ -0,0 +1,13 @@
+class WebhookTestHandler < Munster::BaseHandler
+  def valid?(request)
+    request.params.fetch(:isValid, false)
+  end
+
+  def process(webhook)
+    raise "Oops, failed" if webhook.request.params[:raiseDuringProcessing]
+    filename = webhook.request.params.fetch(:outputToFilename)
+    File.binwrite(filename, webhook.body)
+  end
+
+  def expose_errors_to_sender? = true
+end

data/test/test_app.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_record"
+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"
+  end
+end
+
+require_relative "../lib/munster"
+require_relative "test-webhook-handlers/webhook_test_handler"
+
+class MunsterTestApp < Rails::Application
+  config.logger = Logger.new(nil)
+  config.autoload_paths << File.dirname(__FILE__) + "/test-webhook-handlers"
+  config.root = __dir__
+  config.eager_load = false
+  config.consider_all_requests_local = true
+  config.secret_key_base = "i_am_a_secret"
+  config.active_support.cache_format_version = 7.0
+  config.hosts << ->(host) { true } # Permit all hosts
+
+  routes.append do
+    mount Munster::Engine, at: "/munster"
+    post "/per-user-munster/:user_id/:service_id" => "munster/receive_webhooks#create"
+  end
+end
+
+MunsterTestApp.initialize!
+
+# run MunsterTestApp

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+require_relative "test_app"
+require "rails/test_help"
+
+class ActiveSupport::TestCase
+  # Same as "assert_changes" in Rails but for countable entities.
+  # @return [*] return value of the block
+  # @example
+  #   assert_changes_by("Notification.count", exactly: 2) do
+  #     cause_two_notifications_to_get_delivered
+  #   end
+  def assert_changes_by(expression, message = nil, exactly: nil, at_least: nil, at_most: nil, &block)
+    # rubocop:disable Security/Eval
+    exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
+    # rubocop:enable Security/Eval
+
+    raise "either exactly:, at_least: or at_most: must be specified" unless exactly || at_least || at_most
+    raise "exactly: is mutually exclusive with other options" if exactly && (at_least || at_most)
+    raise "at_most: must be larger than at_least:" if at_least && at_most && at_most < at_least
+
+    before = exp.call
+    retval = assert_nothing_raised(&block)
+
+    after = exp.call
+    delta = after - before
+
+    if exactly
+      at_most = exactly
+      at_least = exactly
+    end
+
+    # We do not make these an if/else since we allow both at_most and at_least
+    if at_most
+      error = "#{expression.inspect} changed by #{delta} which is more than #{at_most}"
+      error = "#{error}. It was #{before} and became #{after}"
+      error = "#{message.call}.\n" if message&.respond_to?(:call)
+      error = "#{message}.\n#{error}" if message && !message.respond_to?(:call)
+      assert delta <= at_most, error
+    end
+
+    if at_least
+      error = "#{expression.inspect} changed by #{delta} which is less than #{at_least}"
+      error = "#{error}. It was #{before} and became #{after}"
+      error = "#{message.call}.\n" if message&.respond_to?(:call)
+      error = "#{message}.\n#{error}" if message && !message.respond_to?(:call)
+      assert delta >= at_least, error
+    end
+
+    retval
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: munster
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Stanislav Katkov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-29 00:00:00.000000000 Z
+date: 2024-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -186,6 +186,17 @@ files:
 - lib/munster/templates/munster.rb
 - lib/munster/version.rb
 - lib/tasks/munster_tasks.rake
+- test/munster_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
+- test/test-webhook-handlers/failing_with_exposed_errors.rb
+- test/test-webhook-handlers/inactive_handler.rb
+- test/test-webhook-handlers/invalid_handler.rb
+- test/test-webhook-handlers/private_handler.rb
+- test/test-webhook-handlers/webhook_test_handler.rb
+- test/test_app.rb
+- test/test_helper.rb
 homepage: https://www.cheddar.me/
 licenses:
 - MIT
@@ -208,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Webhooks processing engine for Rails applications