webhukhs 0.7.0 → 0.8.0

data/test/browser/admin_click_through.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "ferrum"
+require "puma"
+require "puma/server"
+
+# Clicks through the admin in a real Chrome, so that what the request tests cannot see - the JS, the
+# CSP letting it run, assets resolving under the mount point - is exercised too. Not part of `rake test`,
+# run it with `rake test:browser`.
+class AdminClickThrough < ActiveSupport::TestCase
+  # The app answers from Puma threads with connections of their own, which would not see rows
+  # created inside a test transaction
+  self.use_transactional_tests = false
+
+  PAGE_SIZE = Webhukhs::Admin::ReceivedWebhooksController::PAGE_SIZE
+
+  def self.server
+    @server ||= Puma::Server.new(WebhukhsTestApp, nil, min_threads: 0, max_threads: 4, log_writer: Puma::LogWriter.null).tap do |server|
+      server.add_tcp_listener("127.0.0.1", 0)
+      server.run
+      Minitest.after_run { server.stop(true) }
+    end
+  end
+
+  setup do
+    @base_url = "http://127.0.0.1:#{self.class.server.connected_ports.first}/admin"
+    @console_errors = []
+    # GitHub's Ubuntu runners do not let Chrome set up its sandbox
+    browser_options = ENV["CI"] ? {"no-sandbox" => nil} : {}
+    @browser = Ferrum::Browser.new(timeout: 10, js_errors: true, browser_options: browser_options)
+    @browser.on("Log.entryAdded") { |params| @console_errors << params.dig("entry", "text") if params.dig("entry", "level") == "error" }
+    @browser.on("Runtime.consoleAPICalled") { |params| @console_errors << params["args"].map { |arg| arg["value"] }.join(" ") if params["type"] == "error" }
+    @browser.page.command("Log.enable")
+  end
+
+  teardown do
+    failed = @browser.network.traffic.filter_map do |exchange|
+      "#{exchange.response.status} #{exchange.request.url}" if exchange.response && exchange.response.status >= 400
+    end
+    @browser.quit
+    Webhukhs::ReceivedWebhook.delete_all
+
+    assert_empty failed, "Requests failed"
+    assert_empty @console_errors, "The browser logged errors"
+  end
+
+  def create_webhook(**attributes)
+    Webhukhs::ReceivedWebhook.create!(
+      handler_module_name: "WebhookTestHandler",
+      handler_event_id: SecureRandom.uuid,
+      status: "processed",
+      body: '{"event":"thing.happened"}',
+      **attributes
+    )
+  end
+
+  def visit(path)
+    @browser.go_to(@base_url + path)
+  end
+
+  def wait_for(what, timeout: 5)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    until (result = yield)
+      flunk "Timed out waiting for #{what}" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+      sleep 0.05
+    end
+    result
+  end
+
+  def click_and_wait_for_page(node)
+    url = @browser.current_url
+    label = node.text.strip
+    # Ferrum clicks at the node's coordinates as they are, and a click below the fold hits nothing
+    node.scroll_into_view
+    node.click
+    wait_for("#{label.inspect} to leave #{url}") { @browser.current_url != url }
+    # The URL changes as soon as the navigation commits, while the new document may still be parsing
+    wait_for("the page after #{label.inspect} to load") { @browser.evaluate("document.readyState") == "complete" }
+    @browser.network.wait_for_idle
+  end
+
+  # In one evaluate, so that auto-refresh swapping the table cannot pull the nodes out from under us
+  def texts(selector)
+    @browser.evaluate("Array.from(document.querySelectorAll(#{selector.to_json}), (node) => node.textContent.trim())")
+  end
+
+  test "lists, sorts, filters and pages through webhooks" do
+    PAGE_SIZE.times { |i| create_webhook(handler_event_id: "evt-#{i}", created_at: i.minutes.ago) }
+    create_webhook(handler_event_id: "the-failed-one", status: "error", created_at: 2.days.ago)
+
+    visit "/received"
+    assert_equal "Received webhooks", @browser.at_css("h1").text
+    # The stylesheet must have made it through the CSP - unstyled, the header would not be a flexbox
+    assert_equal "flex", @browser.evaluate("getComputedStyle(document.querySelector('.admin-header')).display")
+    assert_equal PAGE_SIZE, @browser.css("tbody tr").length
+    assert_equal "evt-0", texts("tbody tr td:nth-child(5)").first
+
+    click_and_wait_for_page(@browser.at_xpath("//th/a[contains(., 'Received')]"))
+    assert_includes @browser.current_url, "direction=asc"
+    assert_equal "the-failed-one", texts("tbody tr td:nth-child(5)").first
+
+    # Not Ferrum's Node#select: it blanks the select by assigning it `undefined` first, which
+    # left it blank on the Chromium snapshot CI got
+    @browser.execute(<<~JS)
+      const select = document.querySelector("select[name=status]")
+      select.value = "error"
+      select.dispatchEvent(new Event("change", {bubbles: true}))
+    JS
+    assert_equal "error", @browser.evaluate("document.querySelector('select[name=status]').value")
+    click_and_wait_for_page(@browser.at_css("form.filters input[type=submit]"))
+    assert_equal ["the-failed-one"], texts("tbody tr td:nth-child(5)")
+    # The sort survives filtering
+    assert_includes @browser.current_url, "direction=asc"
+
+    click_and_wait_for_page(@browser.at_xpath("//form//a[text()='Clear']"))
+    assert_equal "Any status", @browser.evaluate("document.querySelector('select[name=status]').selectedOptions[0].text")
+
+    click_and_wait_for_page(@browser.at_css("a[rel=next]"))
+    assert_equal 1, @browser.css("tbody tr").length
+    click_and_wait_for_page(@browser.at_css("a[rel=prev]"))
+    assert_equal PAGE_SIZE, @browser.css("tbody tr").length
+  end
+
+  test "opens a webhook by clicking anywhere on its row" do
+    webhook = create_webhook(handler_event_id: "evt-clicked")
+
+    visit "/received"
+    # The status cell is not a link, but the row link stretched over it takes the click
+    click_and_wait_for_page(@browser.at_css("tbody tr td:nth-child(4)"))
+
+    assert @browser.current_url.end_with?("/received/#{webhook.id}"), @browser.current_url
+    assert_includes @browser.at_css("h1").text, "WebhookTestHandler"
+  end
+
+  test "switches between the pretty and the as-sent body" do
+    webhook = create_webhook(body: '{"event":"thing.happened","data":{"id":1}}')
+
+    visit "/received/#{webhook.id}"
+    pretty = -> { @browser.evaluate("document.getElementById('body-pretty').hidden") == false }
+    raw = -> { @browser.evaluate("document.getElementById('body-raw').hidden") == false }
+    assert pretty.call
+    refute raw.call
+
+    @browser.at_css("#body-tab-raw").click
+    wait_for("the as-sent tab") { raw.call }
+    refute pretty.call
+    assert_equal "true", @browser.at_css("#body-tab-raw").attribute("aria-selected")
+    assert_equal '{"event":"thing.happened","data":{"id":1}}', @browser.at_css("#body-raw code").text
+
+    @browser.at_css("#body-tab-raw").focus
+    @browser.keyboard.type(:Left)
+    wait_for("the arrow key to go back to the pretty tab") { pretty.call }
+    assert_equal "body-tab-pretty", @browser.evaluate("document.activeElement.id")
+  end
+
+  test "copies to the clipboard" do
+    webhook = create_webhook(handler_event_id: "evt-to-copy")
+
+    visit "/received/#{webhook.id}"
+    # Headless Chrome has no clipboard to grant, so we only check that the right text gets handed to it
+    @browser.execute("navigator.clipboard.writeText = (text) => { window.copied = text; return Promise.resolve() }")
+
+    @browser.at_css("button.btn-copy[data-copy='evt-to-copy']").click
+    wait_for("the copy button to flash") { @browser.at_css("button.btn-copy.copied[data-copy='evt-to-copy']") }
+    assert_equal "evt-to-copy", @browser.evaluate("window.copied")
+
+    @browser.at_css("button.btn-copy-panel").click
+    wait_for("the body to be copied") { @browser.evaluate("window.copied") != "evt-to-copy" }
+    assert_equal JSON.pretty_generate({"event" => "thing.happened"}), @browser.evaluate("window.copied")
+  end
+
+  test "shows bodies that are not JSON, or too large to display" do
+    form = create_webhook(body: "event=paid&amount=12.50")
+    large = create_webhook(body: "x" * (Webhukhs::Admin::ReceivedWebhookPresenter::DISPLAY_LIMIT + 1))
+
+    visit "/received/#{form.id}"
+    assert_equal "This body is not valid JSON, so it is shown as it was sent", @browser.at_css(".flash.alert").text
+    assert_equal "event=paid&amount=12.50", @browser.at_css("pre.body-raw code").text
+    assert_empty @browser.css("[role=tab]")
+
+    visit "/received/#{large.id}"
+    assert_equal "The body was 256 KB, display is truncated", @browser.at_css(".flash.alert").text
+  end
+
+  test "picks up new webhooks while auto-refresh is on, and remembers the switch" do
+    create_webhook(handler_event_id: "evt-before")
+
+    visit "/received"
+    switch = -> { @browser.evaluate("document.getElementById('auto-refresh').checked") }
+    refute switch.call
+    @browser.at_css("label.switch").click
+    wait_for("the switch to turn on") { switch.call }
+
+    create_webhook(handler_event_id: "evt-arrived")
+    # One poll interval, with some slack
+    wait_for("the new webhook to show up", timeout: 8) { texts("tbody tr td:nth-child(5)").include?("evt-arrived") }
+    assert_equal ["evt-arrived", "evt-before"], texts("tbody tr td:nth-child(5)")
+
+    visit "/received"
+    assert switch.call, "The switch should stay on after a reload"
+    # After a page load only the timer refetches, so this one has to come in through a poll
+    create_webhook(handler_event_id: "evt-polled")
+    wait_for("the polled webhook to show up", timeout: 8) { texts("tbody tr td:nth-child(5)").include?("evt-polled") }
+    @browser.at_css("label.switch").click
+    wait_for("the switch to turn off") { !switch.call }
+  end
+end

data/test/processing_job_test.rb

@@ -37,36 +37,25 @@ class ProcessingJobTest < ActiveJob::TestCase
     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
-
-    assert_no_enqueued_jobs only: Webhukhs::ProcessingJob
-  end
-
-  test "raises a specific error message when webhook argument is nil" do
-    error = assert_raises(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
-      Webhukhs::ProcessingJob.new.perform(nil)
-    end
-
-    assert_equal "ProcessingJob received nil webhook argument", error.message
   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")
-    end
-
-    assert_no_enqueued_jobs only: Webhukhs::ProcessingJob
-  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
 
-  test "raises a specific error message when webhook argument is not a ReceivedWebhook" do
-    error = assert_raises(Webhukhs::ProcessingJob::InvalidWebhookArgument) do
-      Webhukhs::ProcessingJob.new.perform("not a webhook")
+      assert_equal message, error.message
     end
-
-    assert_equal "ProcessingJob expected Webhukhs::ReceivedWebhook, got String", error.message
   end
 
   test "processes webhooks under a lock" do
@@ -89,7 +78,7 @@ class ProcessingJobTest < ActiveJob::TestCase
 
     Webhukhs::ProcessingJob.new.perform(webhook)
 
-    assert_equal true, with_lock_called
+    assert_true with_lock_called
     assert_predicate webhook.reload, :failed_validation?
   end
 
@@ -189,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

@@ -65,6 +65,22 @@ class ReceivedWebhookTest < ActiveSupport::TestCase
     )
   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(

data/test/test_app.rb

@@ -46,6 +46,7 @@ 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"
@@ -80,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,19 +1,22 @@
-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/"
+    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.
   # @return [*] return value of the block

data/test/webhukhs_test.rb

@@ -25,10 +25,6 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
 
   teardown { Webhukhs::ReceivedWebhook.delete_all }
 
-  def test_that_it_has_a_version_number
-    refute_nil ::Webhukhs::VERSION
-  end
-
   def webhook_body
     <<~JSON
       {
@@ -64,32 +60,8 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
     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}
-    body_json = body.to_json
-
-    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
+  test "loads engine generators" do
+    assert_nothing_raised { Webhukhs::Engine.load_generators }
   end
 
   test "accepts a webhook, stores and processes it" do
@@ -99,20 +71,25 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
 
     post "/webhukhs/test", params: body_json, headers: {"CONTENT_TYPE" => "application/json"}
     assert_response 200
+    assert_equal({"ok" => true, "error" => nil}, response.parsed_body)
 
     webhook = Webhukhs::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 "stores the body of a form-encoded webhook" do
+    # Rails parses the form into params before the handler sees the request, which leaves the body
+    # stream at its end
+    post "/webhukhs/test", params: "event=paid&amount=12.50", headers: {"CONTENT_TYPE" => "application/x-www-form-urlencoded"}
+    assert_response 200
+
+    assert_equal "event=paid&amount=12.50", Webhukhs::ReceivedWebhook.last!.body
+  end
+
   test "accepts a webhook but does not process it if it is invalid" do
     tf = Tempfile.new
     body = {isValid: false, outputToFilename: tf.path}
@@ -123,11 +100,6 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
 
     webhook = Webhukhs::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?
 
@@ -145,11 +117,6 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
 
     webhook = Webhukhs::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?
 
@@ -210,16 +177,22 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
   end
 
   test "returns a 200 status and error message if the handler does not expose errors" 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
-      assert_equal false, response.parsed_body["ok"]
+      assert_false response.parsed_body["ok"]
       assert_equal "Internal error (oops)", response.parsed_body["error"]
     end
 
     assert_predicate report, :handled?
     assert_equal :error, report.severity
+    assert_equal "webhooks", report.context[:component]
+  ensure
+    Webhukhs.configuration.error_context = original_error_context
   end
 
   test "returns a 500 status and error message if the handler does not expose errors" do
@@ -256,10 +229,7 @@ class TestWebhukhs < ActionDispatch::IntegrationTest
     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)
+    assert_instance_of WebhookTestHandler, Webhukhs::ReceiveWebhooksController.new.lookup_handler("class_handler")
   ensure
     Webhukhs.configuration.active_handlers = original_active_handlers
   end
@@ -304,16 +274,4 @@ 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