first pass at have_reported_error matcher

Author: skatkov

lib/rspec/rails/matchers.rb

@@ -20,6 +20,7 @@ module Matchers
 require 'rspec/rails/matchers/relation_match_array'
 require 'rspec/rails/matchers/be_valid'
 require 'rspec/rails/matchers/have_http_status'
+require 'rspec/rails/matchers/have_reported_error'
 require 'rspec/rails/matchers/send_email'
 
 if RSpec::Rails::FeatureCheck.has_active_job?

lib/rspec/rails/matchers/have_reported_error.rb

@@ -0,0 +1,184 @@
+require "rspec/rails/matchers/base_matcher"
+
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class ErrorSubscriber
+        attr_reader :events
+
+        def initialize
+          @events = []
+        end
+
+        def report(error, **attrs)
+          @events << [error, attrs]
+        end
+      end
+
+      # Matcher class for `have_reported_error`. Should not be instantiated directly.
+      #
+      # @private
+      # @see RSpec::Rails::Matchers#have_reported_error
+      class HaveReportedError < RSpec::Rails::Matchers::BaseMatcher
+        def initialize(expected_error = nil)
+          @expected_error = expected_error
+          @attributes = {}
+          @error_subscriber = nil
+        end
+
+        def with(expected_attributes)
+          @attributes.merge!(expected_attributes)
+          self
+        end
+
+        def matches?(block)
+          @error_subscriber = ErrorSubscriber.new
+          ::Rails.error.subscribe(@error_subscriber)
+
+          block&.call
+
+          case @expected_error
+          when Class
+            return false unless actual_error&.is_a?(@expected_error)
+          when Exception
+            return false unless actual_error&.is_a?(@expected_error.class)
+            unless @expected_error.message.empty?
+              return false unless actual_error.message == @expected_error.message
+            end
+          when nil
+            return false unless @error_subscriber.events.count >= 1
+          when Regexp
+            return false unless actual_error&.message&.match(@expected_error)
+          when Symbol
+            return false unless actual_error == @expected_error
+          end
+
+          if !@attributes.empty? && !@error_subscriber.events.empty?
+            event_data = @error_subscriber.events.last[1]
+            return attributes_match?(event_data)
+          end
+
+          true
+        ensure
+          ::Rails.error.unsubscribe(@error_subscriber) if @error_subscriber
+        end
+
+        def supports_block_expectations?
+          true
+        end
+
+        def description
+          desc = "report an error"
+          case @expected_error
+          when Class
+            desc = "report a #{@expected_error} error"
+          when Exception
+            desc = "report a #{@expected_error.class} error"
+            desc += " with message '#{@expected_error.message}'" unless @expected_error.message.empty?
+          when Regexp
+            desc = "report an error with message matching #{@expected_error}"
+          when Symbol
+            desc = "report #{@expected_error}"
+          end
+          desc += " with #{@attributes}" unless @attributes.empty?
+          desc
+        end
+
+        def failure_message
+          if !@error_subscriber.events.empty? && !@attributes.empty?
+            event_data = @error_subscriber.events.last[1]
+            if defined?(ActiveSupport::HashWithIndifferentAccess)
+              event_data = event_data.with_indifferent_access
+            end
+            unmatched = unmatched_attributes(event_data)
+            unless unmatched.empty?
+              return "Expected error attributes to match #{@attributes}, but got these mismatches: #{unmatched} and actual values are #{event_data}"
+            end
+          elsif @error_subscriber.events.empty?
+            return 'Expected the block to report an error, but none was reported.'
+          else
+            case @expected_error
+            when Class
+              return "Expected error to be an instance of #{@expected_error}, but got #{actual_error.class} with message: '#{actual_error.message}'"
+            when Exception
+              return "Expected error to be #{@expected_error.class} with message '#{@expected_error.message}', but got #{actual_error.class} with message: '#{actual_error.message}'"
+            when Regexp
+              return "Expected error message to match #{@expected_error}, but got: '#{actual_error.message}'"
+            when Symbol
+              return "Expected error to be #{@expected_error}, but got: #{actual_error}"
+            else
+              return "Expected specific error, but got #{actual_error.class} with message: '#{actual_error.message}'"
+            end
+          end
+        end
+
+        def failure_message_when_negated
+          error_count = @error_subscriber.events.count
+          if defined?(ActiveSupport::Inflector)
+            error_word = 'error'.pluralize(error_count)
+            verb = error_count == 1 ? 'has' : 'have'
+          else
+            error_word = error_count == 1 ? 'error' : 'errors'
+            verb = error_count == 1 ? 'has' : 'have'
+          end
+          "Expected the block not to report any errors, but #{error_count} #{error_word} #{verb} been reported."
+        end
+
+        private
+
+        def actual_error
+          @error_subscriber.events.empty? ? nil : @error_subscriber.events.last[0]
+        end
+
+        def attributes_match?(actual)
+          @attributes.all? do |key, value|
+            if defined?(RSpec::Matchers) && value.respond_to?(:matches?)
+              value.matches?(actual[key])
+            else
+              actual[key] == value
+            end
+          end
+        end
+
+        def unmatched_attributes(actual)
+          @attributes.reject do |key, value|
+            if defined?(RSpec::Matchers) && value.respond_to?(:matches?)
+              value.matches?(actual[key])
+            else
+              actual[key] == value
+            end
+          end
+        end
+      end
+
+      # @api public
+      # Passes if the block reports an error to `Rails.error`.
+      #
+      # This matcher asserts that ActiveSupport::ErrorReporter has received an error report.
+      #
+      # @example Checking for any error
+      #   expect { Rails.error.report(StandardError.new) }.to have_reported_error
+      #
+      # @example Checking for specific error class
+      #   expect { Rails.error.report(MyError.new) }.to have_reported_error(MyError)
+      #
+      # @example Checking for specific error instance with message
+      #   expect { Rails.error.report(MyError.new("message")) }.to have_reported_error(MyError.new("message"))
+      #
+      # @example Checking error attributes
+      #   expect { Rails.error.report(StandardError.new, context: "test") }.to have_reported_error.with(context: "test")
+      #
+      # @example Checking error message patterns
+      #   expect { Rails.error.report(StandardError.new("test message")) }.to have_reported_error(/test/)
+      #
+      # @example Negation
+      #   expect { "safe code" }.not_to have_reported_error
+      #
+      # @param expected_error [Class, Exception, Regexp, Symbol, nil] the expected error to match
+      def have_reported_error(expected_error = nil)
+        HaveReportedError.new(expected_error)
+      end
+    end
+  end
+end