wip - use actual events when comparing

sentry-ruby/lib/sentry/rspec.rb

@@ -2,13 +2,16 @@
 
 RSpec::Matchers.define :include_sentry_event do |event_message = "", **opts|
   match do |sentry_events|
-    @expected_event = Sentry.get_current_client.event_from_message(event_message)
+    @expected_exception = expected_exception(**opts)
+    @context = context(**opts)
+    @tags = tags(**opts)
 
-    event = sentry_events.find { |event| event.message == @expected_event.message }
+    @expected_event = expected_event(event_message)
+    @matched_event = find_matched_event(event_message, sentry_events)
 
-    return false unless event
+    return false unless @matched_event
 
-    [verify_exception(event, **opts), verify_context(event, **opts), verify_tags(event, **opts)].all?
+    [verify_context(), verify_tags()].all?
   end
 
   chain :with_context do |context|
@@ -21,23 +24,51 @@
 
   failure_message do |sentry_events|
     info = ["Failed to find event matching:\n"]
-    info << "  message: #{event_message}"
-    info << "  context: #{context.inspect}"
-    info << "  tags: #{tags.inspect}"
+    info << "  message: #{@expected_event.message.inspect}"
+    info << "  exception: #{@expected_exception.inspect}"
+    info << "  context: #{@context.inspect}"
+    info << "  tags: #{@tags.inspect}"
     info << "\n"
     info << "Captured events:\n"
     info << dump_events(sentry_events)
     info.join("\n")
   end
 
-  define_method(:context) do
+  def expected_event(event_message)
+    if @expected_exception
+      Sentry.get_current_client.event_from_exception(@expected_exception)
+    else
+      Sentry.get_current_client.event_from_message(event_message)
+    end
+  end
+
+  def expected_exception(**opts)
+    opts[:exception].new(opts[:message]) if opts[:exception]
+  end
+
+  def context(**opts)
     opts.fetch(:context, @context || {})
   end
 
-  define_method(:tags) do
+  def tags(**opts)
     opts.fetch(:tags, @tags || {})
   end
 
+  def find_matched_event(event_message, sentry_events)
+    @matched_event ||= sentry_events
+      .find { |event|
+        if @expected_exception
+          # Is it OK that we only compare the first exception?
+          event_exception = event.exception.values.first
+          expected_event_exception = @expected_event.exception.values.first
+
+          event_exception.type == expected_event_exception.type && event_exception.value == expected_event_exception.value
+        else
+          event.message == @expected_event.message
+        end
+      }
+  end
+
   def dump_events(sentry_events)
     sentry_events.map(&Kernel.method(:Hash)).map do |hash|
       hash.slice(:message, :contexts, :tags, :exception)
@@ -46,23 +77,15 @@ def dump_events(sentry_events)
     end.join("\n\n")
   end
 
-  def verify_exception(event, exception: nil, message: nil, **)
-    return true unless exception && message
-
-    event.exception.values.any? do |sentry_exception|
-      sentry_exception.type == exception.name && sentry_exception.value == message
-    end
-  end
-
-  def verify_context(event, context: @context, **)
-    return true unless context
+  def verify_context()
+    return true if @context.empty?
 
-    event.contexts.any? { |key, value| value == context[key] }
+    @matched_event.contexts.any? { |key, value| value == @context[key] }
   end
 
-  def verify_tags(event, tags: @tags, **)
-    return true unless tags
+  def verify_tags()
+    return true if @tags.empty?
 
-    tags.all? { |key, value| event.tags.include?(key) && event.tags[key] == value }
+    @tags.all? { |key, value| @matched_event.tags.include?(key) && @matched_event.tags[key] == value }
   end
 end

sentry-ruby/spec/sentry/rspec/matchers_spec.rb

@@ -23,14 +23,6 @@
 
   let(:exception) { StandardError.new("Gaah!") }
 
-  let(:exception_message) do
-    if exception.respond_to?(:detailed_message)
-      exception.detailed_message(highlight: false)
-    else
-      exception.message || ""
-    end
-  end
-
   describe "include_sentry_event" do
     it "matches events with the given message" do
       Sentry.capture_message("Ooops")
@@ -47,7 +39,7 @@
     it "matches events with exception" do
       Sentry.capture_exception(exception)
 
-      expect(sentry_events).to include_sentry_event(exception: exception.class, message: exception_message)
+      expect(sentry_events).to include_sentry_event(exception: exception.class, message: exception.message)
     end
 
     it "does not match events with different exception" do
@@ -96,7 +88,7 @@
 
       Sentry.capture_exception(exception)
 
-      expect(sentry_events).to include_sentry_event(exception: exception.class, message: exception_message)
+      expect(sentry_events).to include_sentry_event(exception: exception.class, message: exception.message)
         .with_tags({ foo: "bar", baz: "qux" })
         .with_context("rails.error" => { some: "stuff" })
     end
@@ -109,7 +101,7 @@
 
       expect(sentry_events).to include_sentry_event(
         exception: exception.class,
-        message: exception_message,
+        message: exception.message,
         tags: { foo: "bar", baz: "qux" },
         context: { "rails.error" => { some: "stuff" } }
       )