hooksniff 1.2.0 → 1.3.0

data/lib/hooksniff/webhook.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
+require "base64"
+require "json"
 
 module HookSniff
+  # Error raised when webhook signature verification fails
+  class WebhookVerificationError < StandardError; end
+  # Error raised when webhook signing fails
+  class WebhookSigningError < StandardError; end
+
   class Webhook
 
     def self.new_using_raw_bytes(secret)
@@ -15,6 +22,15 @@ module HookSniff
       @secret = Base64.decode64(secret)
     end
 
+    # Verify and parse a webhook payload.
+    #
+    # Verifies the HMAC-SHA256 signature, then parses the payload
+    # into a typed WebhookEvent with +event+, +data+, and +timestamp+.
+    #
+    # @param payload [String] raw request body
+    # @param headers [Hash] request headers containing hooksniff-id, hooksniff-timestamp, hooksniff-signature
+    # @return [WebhookEvent] parsed webhook event
+    # @raise [WebhookVerificationError] if signature is invalid or timestamp is outside tolerance
     def verify(payload, headers)
       msgId = headers["hooksniff-id"]
       msgSignature = headers["hooksniff-signature"]
@@ -32,6 +48,45 @@ module HookSniff
 
       _, signature = sign(msgId, msgTimestamp, payload).split(",", 2)
 
+      passedSignatures = msgSignature.split(" ")
+      passedSignatures.each do |versionedSignature|
+        version, expectedSignature = versionedSignature.split(",", 2)
+        if version != "v1"
+          next
+        end
+
+        if ::HookSniff::secure_compare(signature, expectedSignature)
+          return parse_payload(payload)
+        end
+      end
+
+      raise WebhookVerificationError, "No matching signature found"
+    end
+
+    # Verify and return raw payload without parsing.
+    # Use this when you need the raw hash instead of a typed event.
+    #
+    # @param payload [String] raw request body
+    # @param headers [Hash] request headers
+    # @return [Hash, nil] parsed JSON hash
+    # @raise [WebhookVerificationError] if signature is invalid
+    def verify_raw(payload, headers)
+      msgId = headers["hooksniff-id"]
+      msgSignature = headers["hooksniff-signature"]
+      msgTimestamp = headers["hooksniff-timestamp"]
+      if !msgSignature || !msgId || !msgTimestamp
+        msgId = headers["webhook-id"]
+        msgSignature = headers["webhook-signature"]
+        msgTimestamp = headers["webhook-timestamp"]
+        if !msgSignature || !msgId || !msgTimestamp
+          raise WebhookVerificationError, "Missing required headers"
+        end
+      end
+
+      verify_timestamp(msgTimestamp)
+
+      _, signature = sign(msgId, msgTimestamp, payload).split(",", 2)
+
       passedSignatures = msgSignature.split(" ")
       passedSignatures.each do |versionedSignature|
         version, expectedSignature = versionedSignature.split(",", 2)
@@ -80,5 +135,12 @@ module HookSniff
         raise WebhookVerificationError, "Message timestamp too new"
       end
     end
+
+    def parse_payload(payload)
+      return WebhookEvent.new(event: "", data: {}, timestamp: "") if payload.empty?
+
+      parsed = JSON.parse(payload, symbolize_names: true)
+      WebhookEvent.parse(parsed)
+    end
   end
 end

data/lib/hooksniff/webhook_event.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module HookSniff
+  # ─── Event Data Classes ─────────────────────────────────────────
+
+  # Data payload for endpoint.created events.
+  class EndpointCreatedEventData
+    attr_reader :app_id, :endpoint_id, :app_uid
+
+    def initialize(app_id:, endpoint_id:, app_uid: nil)
+      @app_id = app_id
+      @endpoint_id = endpoint_id
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for endpoint.updated events.
+  class EndpointUpdatedEventData
+    attr_reader :app_id, :endpoint_id, :app_uid
+
+    def initialize(app_id:, endpoint_id:, app_uid: nil)
+      @app_id = app_id
+      @endpoint_id = endpoint_id
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for endpoint.deleted events.
+  class EndpointDeletedEventData
+    attr_reader :app_id, :endpoint_id, :app_uid
+
+    def initialize(app_id:, endpoint_id:, app_uid: nil)
+      @app_id = app_id
+      @endpoint_id = endpoint_id
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for endpoint.enabled events.
+  class EndpointEnabledEventData
+    attr_reader :app_id, :endpoint_id, :app_uid
+
+    def initialize(app_id:, endpoint_id:, app_uid: nil)
+      @app_id = app_id
+      @endpoint_id = endpoint_id
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for endpoint.disabled events.
+  class EndpointDisabledEventData
+    attr_reader :app_id, :endpoint_id, :app_uid, :fail_since, :trigger
+
+    def initialize(app_id:, endpoint_id:, app_uid: nil, fail_since: nil, trigger: nil)
+      @app_id = app_id
+      @endpoint_id = endpoint_id
+      @app_uid = app_uid
+      @fail_since = fail_since
+      @trigger = trigger
+    end
+  end
+
+  # Info about the last delivery attempt.
+  class LastAttemptInfo
+    attr_reader :id, :timestamp, :response_status_code
+
+    def initialize(id:, timestamp:, response_status_code:)
+      @id = id
+      @timestamp = timestamp
+      @response_status_code = response_status_code
+    end
+  end
+
+  # Info about a delivery attempt.
+  class AttemptInfo
+    attr_reader :id, :timestamp, :response_status_code
+
+    def initialize(id:, timestamp:, response_status_code:)
+      @id = id
+      @timestamp = timestamp
+      @response_status_code = response_status_code
+    end
+  end
+
+  # Data payload for message.attempt.exhausted events.
+  class MessageAttemptExhaustedEventData
+    attr_reader :app_id, :msg_id, :last_attempt, :app_uid
+
+    def initialize(app_id:, msg_id:, last_attempt:, app_uid: nil)
+      @app_id = app_id
+      @msg_id = msg_id
+      @last_attempt = last_attempt
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for message.attempt.failing events.
+  class MessageAttemptFailingEventData
+    attr_reader :app_id, :msg_id, :attempt, :app_uid
+
+    def initialize(app_id:, msg_id:, attempt:, app_uid: nil)
+      @app_id = app_id
+      @msg_id = msg_id
+      @attempt = attempt
+      @app_uid = app_uid
+    end
+  end
+
+  # Data payload for message.attempt.recovered events.
+  class MessageAttemptRecoveredEventData
+    attr_reader :app_id, :msg_id, :attempt, :app_uid
+
+    def initialize(app_id:, msg_id:, attempt:, app_uid: nil)
+      @app_id = app_id
+      @msg_id = msg_id
+      @attempt = attempt
+      @app_uid = app_uid
+    end
+  end
+
+  # ─── WebhookEvent (base class — must come before subclasses) ────
+
+  # Represents a parsed webhook event from HookSniff.
+  class WebhookEvent
+    # @return [String] event type name (e.g., "endpoint.created")
+    attr_reader :event
+
+    # @return [Object] event payload data (typed data class or Hash)
+    attr_reader :data
+
+    # @return [String] ISO 8601 timestamp string
+    attr_reader :timestamp
+
+    def initialize(event:, data:, timestamp:)
+      @event = event
+      @data = data
+      @timestamp = timestamp
+    end
+
+    # Alias for +event+ — the event type name.
+    def event_type
+      @event
+    end
+
+    # Get a value from the data (Hash or typed object).
+    def get(key)
+      if @data.is_a?(Hash)
+        @data[key.to_s] || @data[key.to_sym]
+      else
+        @data.respond_to?(key.to_sym) ? @data.send(key.to_sym) : nil
+      end
+    end
+
+    # Access data values with bracket notation (backward compat).
+    def [](key)
+      get(key)
+    end
+
+    # Check if key exists in data.
+    def key?(key)
+      if @data.is_a?(Hash)
+        @data.key?(key.to_s) || @data.key?(key.to_sym)
+      else
+        @data.respond_to?(key.to_sym)
+      end
+    end
+
+    def to_s
+      "#<#{self.class.name} event=#{@event} timestamp=#{@timestamp}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    # Map of known event types to their classes
+    EVENT_TYPE_MAP = {
+      "endpoint.created" => "EndpointCreatedEvent",
+      "endpoint.updated" => "EndpointUpdatedEvent",
+      "endpoint.deleted" => "EndpointDeletedEvent",
+      "endpoint.enabled" => "EndpointEnabledEvent",
+      "endpoint.disabled" => "EndpointDisabledEvent",
+      "message.attempt.exhausted" => "MessageAttemptExhaustedEvent",
+      "message.attempt.failing" => "MessageAttemptFailingEvent",
+      "message.atattempt.failing" => "MessageAttemptFailingEvent",
+      "message.attempt.recovered" => "MessageAttemptRecoveredEvent",
+      "message.atattempt.recovered" => "MessageAttemptRecoveredEvent",
+    }.freeze
+
+    # Parse a webhook payload hash into a typed WebhookEvent.
+    def self.parse(data)
+      event_type = data[:event] || data["event"] || data[:eventType] || data["eventType"] || ""
+      raw_data = data[:data] || data["data"] || {}
+      timestamp = data[:timestamp] || data["timestamp"] || ""
+
+      parsed_data = parse_event_data(event_type, raw_data)
+      class_name = EVENT_TYPE_MAP[event_type]
+      event_class = class_name ? const_get(class_name) : WebhookEvent
+
+      event_class.new(event: event_type, data: parsed_data, timestamp: timestamp)
+    end
+
+    private
+
+    def self.parse_event_data(event_type, raw)
+      case event_type
+      when "endpoint.created"
+        EndpointCreatedEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          endpoint_id: raw[:endpointId] || raw["endpointId"] || raw[:endpoint_id] || raw["endpoint_id"] || "",
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "endpoint.updated"
+        EndpointUpdatedEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          endpoint_id: raw[:endpointId] || raw["endpointId"] || raw[:endpoint_id] || raw["endpoint_id"] || "",
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "endpoint.deleted"
+        EndpointDeletedEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          endpoint_id: raw[:endpointId] || raw["endpointId"] || raw[:endpoint_id] || raw["endpoint_id"] || "",
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "endpoint.enabled"
+        EndpointEnabledEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          endpoint_id: raw[:endpointId] || raw["endpointId"] || raw[:endpoint_id] || raw["endpoint_id"] || "",
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "endpoint.disabled"
+        EndpointDisabledEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          endpoint_id: raw[:endpointId] || raw["endpointId"] || raw[:endpoint_id] || raw["endpoint_id"] || "",
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"],
+          fail_since: raw[:failSince] || raw["failSince"] || raw[:fail_since] || raw["fail_since"],
+          trigger: raw[:trigger] || raw["trigger"]
+        )
+      when "message.attempt.exhausted"
+        last_raw = raw[:lastAttempt] || raw["lastAttempt"] || raw[:last_attempt] || raw["last_attempt"] || {}
+        MessageAttemptExhaustedEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          msg_id: raw[:msgId] || raw["msgId"] || raw[:msg_id] || raw["msg_id"] || "",
+          last_attempt: parse_last_attempt(last_raw),
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "message.attempt.failing", "message.atattempt.failing"
+        attempt_raw = raw[:attempt] || raw["attempt"] || {}
+        MessageAttemptFailingEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          msg_id: raw[:msgId] || raw["msgId"] || raw[:msg_id] || raw["msg_id"] || "",
+          attempt: parse_attempt(attempt_raw),
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      when "message.atattempt.recovered", "message.attempt.recovered"
+        attempt_raw = raw[:attempt] || raw["attempt"] || {}
+        MessageAttemptRecoveredEventData.new(
+          app_id: raw[:appId] || raw["appId"] || raw[:app_id] || raw["app_id"] || "",
+          msg_id: raw[:msgId] || raw["msgId"] || raw[:msg_id] || raw["msg_id"] || "",
+          attempt: parse_attempt(attempt_raw),
+          app_uid: raw[:appUid] || raw["appUid"] || raw[:app_uid] || raw["app_uid"]
+        )
+      else
+        raw
+      end
+    end
+
+    def self.parse_last_attempt(raw)
+      LastAttemptInfo.new(
+        id: raw[:id] || raw["id"] || "",
+        timestamp: raw[:timestamp] || raw["timestamp"] || "",
+        response_status_code: raw[:responseStatusCode] || raw["responseStatusCode"] || raw[:response_status_code] || raw["response_status_code"] || 0
+      )
+    end
+
+    def self.parse_attempt(raw)
+      AttemptInfo.new(
+        id: raw[:id] || raw["id"] || "",
+        timestamp: raw[:timestamp] || raw["timestamp"] || "",
+        response_status_code: raw[:responseStatusCode] || raw["responseStatusCode"] || raw[:response_status_code] || raw["response_status_code"] || 0
+      )
+    end
+  end
+
+  # ─── Typed Event Subclasses ─────────────────────────────────────
+
+  class EndpointCreatedEvent < WebhookEvent; end
+  class EndpointUpdatedEvent < WebhookEvent; end
+  class EndpointDeletedEvent < WebhookEvent; end
+  class EndpointEnabledEvent < WebhookEvent; end
+  class EndpointDisabledEvent < WebhookEvent; end
+  class MessageAttemptExhaustedEvent < WebhookEvent; end
+  class MessageAttemptFailingEvent < WebhookEvent; end
+  class MessageAttemptRecoveredEvent < WebhookEvent; end
+end

data/lib/hooksniff.rb

@@ -5,6 +5,9 @@ require "hooksniff/hooksniff_http_client"
 require "hooksniff/api_error"
 require "hooksniff/errors"
 require "hooksniff/util"
+require "hooksniff/webhook_event"
+require "hooksniff/response_metadata"
+require "hooksniff/options"
 require "hooksniff/webhook"
 
 # Original resources

data/test/test_hooksniff.rb

@@ -56,17 +56,6 @@ class WebhookTest < Minitest::Test
     end
   end
 
-  def test_svix_branded_headers
-    wh = HookSniff::Webhook.new(SECRET)
-    sig = sign(SECRET, MSG_ID, TIMESTAMP, PAYLOAD)
-    headers = {
-      "svix-id" => MSG_ID,
-      "svix-timestamp" => TIMESTAMP.to_s,
-      "svix-signature" => sig,
-    }
-    result = wh.verify(PAYLOAD, headers)
-    assert_equal({"event" => "test"}, result)
-  end
 end
 
 class ErrorTest < Minitest::Test

data/test/test_typed_events.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "../lib/hooksniff/webhook_event"
+
+class TypedWebhookEventTest < Minitest::Test
+  def test_endpoint_created
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a1", endpointId: "e1", appUid: "u1" },
+      timestamp: "2026-05-19"
+    )
+    assert_instance_of HookSniff::EndpointCreatedEvent, event
+    assert_instance_of HookSniff::EndpointCreatedEventData, event.data
+    assert_equal "a1", event.data.app_id
+    assert_equal "e1", event.data.endpoint_id
+    assert_equal "u1", event.data.app_uid
+  end
+
+  def test_endpoint_disabled
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.disabled",
+      data: { appId: "a1", endpointId: "e1", failSince: "2026-01", trigger: "repeated-failure" },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::EndpointDisabledEvent, event
+    assert_equal "2026-01", event.data.fail_since
+    assert_equal "repeated-failure", event.data.trigger
+  end
+
+  def test_message_attempt_exhausted
+    event = HookSniff::WebhookEvent.parse(
+      event: "message.attempt.exhausted",
+      data: { appId: "a1", msgId: "m1", lastAttempt: { id: "att", timestamp: "t", responseStatusCode: 500 } },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::MessageAttemptExhaustedEvent, event
+    assert_equal "m1", event.data.msg_id
+    assert_equal 500, event.data.last_attempt.response_status_code
+  end
+
+  def test_message_attempt_failing
+    event = HookSniff::WebhookEvent.parse(
+      event: "message.attempt.failing",
+      data: { appId: "a1", msgId: "m1", attempt: { id: "att", timestamp: "t", responseStatusCode: 429 } },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::MessageAttemptFailingEvent, event
+    assert_equal 429, event.data.attempt.response_status_code
+  end
+
+  def test_message_attempt_recovered
+    event = HookSniff::WebhookEvent.parse(
+      event: "message.attempt.recovered",
+      data: { appId: "a1", msgId: "m1", attempt: { id: "att", timestamp: "t", responseStatusCode: 200 } },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::MessageAttemptRecoveredEvent, event
+  end
+
+  def test_unknown_event_fallback
+    event = HookSniff::WebhookEvent.parse(
+      event: "custom.unknown",
+      data: { x: 1 },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::WebhookEvent, event
+    assert_equal 1, event.data[:x]
+  end
+
+  def test_backward_compat_get
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a1", endpointId: "e1" },
+      timestamp: "t"
+    )
+    assert_equal "a1", event.get("app_id")
+    assert_equal "a1", event["app_id"]
+    assert event.key?("app_id")
+    assert_equal "endpoint.created", event.event_type
+  end
+
+  def test_snake_case_fields
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { app_id: "a1", endpoint_id: "e1" },
+      timestamp: ""
+    )
+    assert_equal "a1", event.data.app_id
+    assert_equal "e1", event.data.endpoint_id
+  end
+
+  def test_empty_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: {},
+      timestamp: ""
+    )
+    assert_equal "", event.data.app_id
+  end
+
+  def test_missing_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      timestamp: ""
+    )
+    assert_equal "", event.data.app_id
+  end
+
+  def test_unknown_event_keeps_raw_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "custom.unknown",
+      data: { "x" => 1 },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::WebhookEvent, event
+    assert_equal 1, event.get("x")
+  end
+
+  def test_unicode_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "ünïcödé", endpointId: "日本語" },
+      timestamp: ""
+    )
+    assert_equal "ünïcödé", event.data.app_id
+    assert_equal "日本語", event.data.endpoint_id
+  end
+
+  def test_event_type_map_count
+    assert_equal 10, HookSniff::WebhookEvent::EVENT_TYPE_MAP.size
+  end
+
+  def test_endpoint_updated
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.updated",
+      data: { appId: "a1", endpointId: "e1" },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::EndpointUpdatedEvent, event
+  end
+
+  def test_endpoint_deleted
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.deleted",
+      data: { appId: "a1", endpointId: "e1" },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::EndpointDeletedEvent, event
+  end
+
+  def test_endpoint_enabled
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.enabled",
+      data: { appId: "a1", endpointId: "e1" },
+      timestamp: ""
+    )
+    assert_instance_of HookSniff::EndpointEnabledEvent, event
+  end
+
+  def test_unicode_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "ünïcödé", endpointId: "日本語" },
+      timestamp: ""
+    )
+    assert_equal "ünïcödé", event.data.app_id
+    assert_equal "日本語", event.data.endpoint_id
+  end
+
+  def test_large_data
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a" * 10000, endpointId: "e" * 10000 },
+      timestamp: ""
+    )
+    assert_equal 10000, event.data.app_id.length
+  end
+
+  def test_special_characters
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a@b.c", endpointId: "e#1" },
+      timestamp: ""
+    )
+    assert_equal "a@b.c", event.data.app_id
+  end
+
+  def test_trigger_none
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.disabled",
+      data: { appId: "a", endpointId: "e", trigger: "none" },
+      timestamp: ""
+    )
+    assert_equal "none", event.data.trigger
+  end
+
+  def test_trigger_first_failure
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.disabled",
+      data: { appId: "a", endpointId: "e", trigger: "first-failure" },
+      timestamp: ""
+    )
+    assert_equal "first-failure", event.data.trigger
+  end
+
+  def test_all_event_types
+    %w[endpoint.created endpoint.updated endpoint.deleted endpoint.enabled endpoint.disabled
+       message.attempt.exhausted message.attempt.failing message.attempt.recovered].each do |et|
+      event = HookSniff::WebhookEvent.parse(event: et, data: { appId: "a" }, timestamp: "")
+      assert_equal et, event.event
+    end
+  end
+
+  def test_get_with_symbol_key
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a1" },
+      timestamp: ""
+    )
+    assert_equal "a1", event.get(:appId)
+  end
+
+  def test_bracket_with_symbol
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a1" },
+      timestamp: ""
+    )
+    assert_equal "a1", event[:appId]
+  end
+
+  def test_key_with_symbol
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: { appId: "a1" },
+      timestamp: ""
+    )
+    assert event.key?(:appId)
+  end
+
+  def test_to_s
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: {},
+      timestamp: "2026-05-19"
+    )
+    assert_match(/EndpointCreatedEvent/, event.to_s)
+    assert_match(/2026-05-19/, event.to_s)
+  end
+
+  def test_inspect
+    event = HookSniff::WebhookEvent.parse(
+      event: "endpoint.created",
+      data: {},
+      timestamp: "2026-05-19"
+    )
+    assert_equal event.to_s, event.inspect
+  end
+end