Use ErrorCollector from Rails instead of self-written version'

Author: Stanislav (Stas) Katkov

lib/rspec/rails/matchers/have_reported_error.rb

@@ -1,25 +1,13 @@
+require 'active_support/testing/error_reporter_assertions'
+
 module RSpec
   module Rails
     module Matchers
       # @api private
       # Sentinel value to distinguish between no argument passed vs explicitly passed nil.
       # This follows the same pattern as RSpec's raise_error matcher.
       UndefinedValue = Object.new.freeze
-
-      # @api private
-      class ErrorSubscriber
-        attr_reader :events
-
-        ErrorEvent = Struct.new(:error, :attributes)
-
-        def initialize
-          @events = []
-        end
-
-        def report(error, **attrs)
-          @events << ErrorEvent.new(error, attrs.with_indifferent_access)
-        end
-      end
+      ErrorCollector = ActiveSupport::Testing::ErrorReporterAssertions::ErrorCollector
 
       # Matcher class for `have_reported_error`. Should not be instantiated directly.
       #
@@ -68,17 +56,14 @@ def matches?(block)
 
           warn_about_nil_error! if @warn_about_nil_error
 
-          @error_subscriber = ErrorSubscriber.new
-          ::Rails.error.subscribe(@error_subscriber)
-
-          block.call
+          @reports = ErrorCollector.record do
+            block.call
+          end
 
-          return false if @error_subscriber.events.empty?
+          return false if @reports.empty?
           return false unless error_matches_expectation?
 
           return attributes_match_if_specified?
-        ensure
-          ::Rails.error.unsubscribe(@error_subscriber)
         end
 
         def supports_block_expectations?
@@ -109,16 +94,16 @@ def description
         end
 
         def failure_message
-          if !@error_subscriber.events.empty? && !@attributes.empty?
-            event_context = @error_subscriber.events.last.attributes[:context]
-            unmatched = unmatched_attributes(event_context)
+          if !@reports.empty? && !@attributes.empty?
+            report_context = @reports.last.context
+            unmatched = unmatched_attributes(report_context)
             unless unmatched.empty?
-              return "Expected error attributes to match #{@attributes}, but got these mismatches: #{unmatched} and actual values are #{event_context}"
+              return "Expected error attributes to match #{@attributes}, but got these mismatches: #{unmatched} and actual values are #{report_context}"
             end
-          elsif @error_subscriber.events.empty?
+          elsif @reports.empty?
             return 'Expected the block to report an error, but none was reported.'
           elsif actual_error.nil?
-            reported_errors = @error_subscriber.events.map { |event| "#{event.error.class}: '#{event.error.message}'" }.join(', ')
+            reported_errors = @reports.map { |report| "#{report.error.class}: '#{report.error.message}'" }.join(', ')
             if @expected_error && @expected_message
               return "Expected error to be an instance of #{@expected_error} with message '#{@expected_message}', but got: #{reported_errors}"
             elsif @expected_error
@@ -140,7 +125,7 @@ def failure_message
         end
 
         def failure_message_when_negated
-          error_count = @error_subscriber.events.count
+          error_count = @reports.count
           error_word = 'error'.pluralize(error_count)
           verb = error_count == 1 ? 'has' : 'have'
 
@@ -150,10 +135,10 @@ def failure_message_when_negated
         private
 
         def error_matches_expectation?
-          return true if @expected_error.nil? && @expected_message.nil? && @error_subscriber.events.count.positive?
+          return true if @expected_error.nil? && @expected_message.nil? && @reports.count.positive?
 
-          @error_subscriber.events.any? do |event|
-            error_class_matches?(event.error) && error_message_matches?(event.error)
+          @reports.any? do |report|
+            error_class_matches?(report.error) && error_message_matches?(report.error)
           end
         end
 
@@ -177,42 +162,44 @@ def error_message_matches?(error)
 
         def attributes_match_if_specified?
           return true if @attributes.empty?
-          return false unless matching_event
+          return false unless matching_report
 
-          event_context = matching_event.attributes[:context]
-          attributes_match?(event_context)
+          report_context = matching_report.context
+          attributes_match?(report_context)
         end
 
         def actual_error
-          @actual_error ||= matching_event&.error
+          @actual_error ||= matching_report&.error
         end
 
-        def matching_event
-          @matching_event ||= find_matching_event
+        def matching_report
+          @matching_report ||= find_matching_report
         end
 
-        def find_matching_event
-          @error_subscriber.events.find do |event|
-            error_class_matches?(event.error) && error_message_matches?(event.error)
+        def find_matching_report
+          @reports.find do |report|
+            error_class_matches?(report.error) && error_message_matches?(report.error)
           end
         end
 
         def attributes_match?(actual)
           @attributes.all? do |key, value|
+            actual_value = actual[key] || actual[key.to_s] || actual[key.to_sym]
             if value.respond_to?(:matches?)
-              value.matches?(actual[key])
+              value.matches?(actual_value)
             else
-              actual[key] == value
+              actual_value == value
             end
           end
         end
 
         def unmatched_attributes(actual)
           @attributes.reject do |key, value|
+            actual_value = actual[key] || actual[key.to_s] || actual[key.to_sym]
             if value.respond_to?(:matches?)
-              value.matches?(actual[key])
+              value.matches?(actual_value)
             else
-              actual[key] == value
+              actual_value == value
             end
           end
         end

log/development.log

@@ -98,15 +98,15 @@ class AnotherTestError < StandardError; end
         expect {
           Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "actual" })
         }.to have_reported_error.with_context(user_id: 456, context: "expected")
-      }.to fail_with(/Expected error attributes to match {user_id: 456, context: "expected"}, but got these mismatches: {user_id: 456, context: "expected"} and actual values are {"user_id" => 123, "context" => "actual"}/)
+      }.to fail_with(/Expected error attributes to match.*user_id.*456.*context.*expected.*got these mismatches.*user_id.*456.*context.*expected.*actual values are.*user_id.*123.*context.*actual/)
     end
 
     it "identifies partial attribute mismatches correctly" do
       expect {
         expect {
           Rails.error.report(StandardError.new("test"), context: { user_id: 123, status: "active", role: "admin" })
         }.to have_reported_error.with_context(user_id: 456, status: "active") # user_id wrong, status correct
-      }.to fail_with(/got these mismatches: {user_id: 456}/)
+      }.to fail_with(/got these mismatches:.*user_id.*456/)
     end
 
     it "handles RSpec matcher mismatches in failure messages" do
@@ -122,7 +122,7 @@ class AnotherTestError < StandardError; end
         expect {
           Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "actual" })
         }.to have_reported_error.with_context(user_id: 456)
-      }.to fail_with(/actual values are {"user_id" => 123, "context" => "actual"}/)
+      }.to fail_with(/actual values are.*user_id.*123.*context.*actual/)
     end
   end
 
@@ -154,7 +154,7 @@ class AnotherTestError < StandardError; end
         expect {
           Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "actual" })
         }.to have_reported_error.with_context(user_id: 456, context: "expected")
-      }.to fail_with(/Expected error attributes to match {user_id: 456, context: "expected"}, but got these mismatches: {user_id: 456, context: "expected"} and actual values are {"user_id" => 123, "context" => "actual"}/)
+      }.to fail_with(/Expected error attributes to match.*user_id.*456.*context.*expected.*got these mismatches.*user_id.*456.*context.*expected.*actual values are.*user_id.*123.*context.*actual/)
     end
 
     it "fails when no error is reported but attributes are expected" do