have_reported_error to accept class name and a message

Author: skatkov

features/matchers/README.md

@@ -28,6 +28,21 @@ expect(assigns(:widget)).to be_a_new(Widget)
 ### error reporting
 
 ```ruby
-# passes when `Rails.error.report` is called with specific error instance and message
+# passes when any error is reported
+expect { Rails.error.report(StandardError.new) }.to have_reported_error
+
+# passes when specific error class is reported
+expect { Rails.error.report(MyError.new) }.to have_reported_error(MyError)
+
+# passes when specific error class with exact message is reported
+expect { Rails.error.report(MyError.new("message")) }.to have_reported_error(MyError, "message")
+
+# passes when specific error class with message matching pattern is reported
+expect { Rails.error.report(MyError.new("test message")) }.to have_reported_error(MyError, /test/)
+
+# passes when error is reported with specific context attributes
+expect { Rails.error.report(StandardError.new, context: { user_id: 123 }) }.to have_reported_error.with_context(user_id: 123)
+
+# backward compatibility - accepts error instances
 expect { Rails.error.report(MyError.new("message")) }.to have_reported_error(MyError.new("message"))
 ```

lib/rspec/rails/matchers/have_reported_error.rb

@@ -23,8 +23,24 @@ def report(error, **attrs)
       # @api private
       # @see RSpec::Rails::Matchers#have_reported_error
       class HaveReportedError < RSpec::Rails::Matchers::BaseMatcher
-        def initialize(expected_error = nil)
-          @expected_error = expected_error
+        def initialize(expected_error_class = nil, expected_message = nil)
+          # Handle backward compatibility with old API
+          if expected_error_class.is_a?(Exception)
+            @expected_error_class = expected_error_class.class
+            @expected_message = expected_error_class.message.empty? ? nil : expected_error_class.message
+          elsif expected_error_class.is_a?(Regexp)
+            @expected_error_class = nil
+            @expected_message = expected_error_class
+          elsif expected_error_class.is_a?(Symbol)
+            @expected_error_symbol = expected_error_class
+            @expected_error_class = nil
+            @expected_message = nil
+          else
+            @expected_error_class = expected_error_class
+            @expected_message = expected_message
+            @expected_error_symbol = nil
+          end
+          
           @attributes = {}
           @error_subscriber = nil
         end
@@ -48,7 +64,7 @@ def matches?(block)
 
           block.call
 
-          return false if @error_subscriber.events.empty? && !@expected_error.nil?
+          return false if @error_subscriber.events.empty?
           return false unless error_matches_expectation?
 
           return attributes_match_if_specified?
@@ -62,16 +78,18 @@ def supports_block_expectations?
 
         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}"
+          if @expected_error_symbol
+            desc = "report #{@expected_error_symbol}"
+          elsif @expected_error_class
+            desc = "report a #{@expected_error_class} error"
+          end
+          if @expected_message
+            case @expected_message
+            when Regexp
+              desc += " with message matching #{@expected_message}"
+            when String
+              desc += " with message '#{@expected_message}'"
+            end
           end
           desc += " with #{@attributes}" unless @attributes.empty?
           desc
@@ -87,15 +105,17 @@ def failure_message
           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}"
+            if @expected_error_symbol
+              return "Expected error to be #{@expected_error_symbol}, but got: #{actual_error}"
+            elsif @expected_error_class && !actual_error.is_a?(@expected_error_class)
+              return "Expected error to be an instance of #{@expected_error_class}, but got #{actual_error.class} with message: '#{actual_error.message}'"
+            elsif @expected_message
+              case @expected_message
+              when Regexp
+                return "Expected error message to match #{@expected_message}, but got: '#{actual_error.message}'"
+              when String
+                return "Expected error message to be '#{@expected_message}', but got: '#{actual_error.message}'"
+              end
             else
               return "Expected specific error, but got #{actual_error.class} with message: '#{actual_error.message}'"
             end
@@ -113,19 +133,30 @@ def failure_message_when_negated
         private
 
         def error_matches_expectation?
-          return true if @expected_error.nil? && @error_subscriber.events.any?
-
-          case @expected_error
-          when Class
-            actual_error.is_a?(@expected_error)
-          when Exception
-            actual_error.is_a?(@expected_error.class) &&
-              (@expected_error.message.empty? || actual_error.message == @expected_error.message)
-          when Regexp
-            actual_error.message&.match(@expected_error)
-          when Symbol
-            actual_error == @expected_error
+          # If no events were reported, we can't match anything
+          return false if @error_subscriber.events.empty?
+          
+          # Handle symbol matching (backward compatibility)
+          if @expected_error_symbol
+            return actual_error == @expected_error_symbol
+          end
+          
+          # If no constraints are given, any error should match
+          return true if @expected_error_class.nil? && @expected_message.nil?
+
+          class_matches = @expected_error_class.nil? || actual_error.is_a?(@expected_error_class)
+          
+          message_matches = if @expected_message.nil?
+            true
+          elsif @expected_message.is_a?(Regexp)
+            actual_error.message&.match(@expected_message)
+          elsif @expected_message.is_a?(String)
+            actual_error.message == @expected_message
+          else
+            false
           end
+
+          class_matches && message_matches
         end
 
         def attributes_match_if_specified?
@@ -172,21 +203,26 @@ def unmatched_attributes(actual)
       # @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
+      # @example Checking for specific error class with message
+      #   expect { Rails.error.report(MyError.new("message")) }.to have_reported_error(MyError, "message")
+      #
+      # @example Checking for specific error instance (backward compatibility)
       #   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(context: "test")
       #
       # @example Checking error message patterns
+      #   expect { Rails.error.report(StandardError.new("test message")) }.to have_reported_error(StandardError, /test/)
       #   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)
+      # @param expected_error_class [Class, Exception, Regexp, Symbol, nil] the expected error class to match, or error instance for backward compatibility
+      # @param expected_message [String, Regexp, nil] the expected error message to match
+      def have_reported_error(expected_error_class = nil, expected_message = nil)
+        HaveReportedError.new(expected_error_class, expected_message)
       end
 
       alias_method :reports_error, :have_reported_error

spec/rspec/rails/matchers/have_reported_error_spec.rb

@@ -46,36 +46,36 @@ class AnotherTestError < StandardError; end
     it "passes with an error that matches exactly" do
       expect {
         Rails.error.report(TestError.new("exact message"))
-      }.to have_reported_error(TestError.new("exact message"))
+      }.to have_reported_error(TestError, "exact message")
     end
 
-    it "passes any error of the same class if the expected message is empty" do
+    it "passes any error of the same class if no message is specified" do
       expect {
         Rails.error.report(TestError.new("any message"))
-      }.to have_reported_error(TestError.new(""))
+      }.to have_reported_error(TestError)
     end
 
     it "fails when the error has different message to the expected" do
       expect {
         expect {
           Rails.error.report(TestError.new("actual message"))
-        }.to have_reported_error(TestError.new("expected message"))
-      }.to fail_with(/Expected error to be TestError with message 'expected message', but got TestError with message: 'actual message'/)
+        }.to have_reported_error(TestError, "expected message")
+      }.to fail_with(/Expected error message to be 'expected message', but got: 'actual message'/)
     end
   end
 
   context "constrained by regex pattern matching" do
     it "passes when an error message matches the pattern" do
       expect {
         Rails.error.report(StandardError.new("error with pattern"))
-      }.to have_reported_error(/with pattern/)
+      }.to have_reported_error(StandardError, /with pattern/)
     end
 
     it "fails when no error messages match the pattern" do
       expect {
         expect {
           Rails.error.report(StandardError.new("error without match"))
-        }.to have_reported_error(/different pattern/)
+        }.to have_reported_error(StandardError, /different pattern/)
       }.to fail_with(/Expected error message to match/)
     end
   end
@@ -152,6 +152,44 @@ class AnotherTestError < StandardError; end
     end
   end
 
+  context "backward compatibility with old API" do
+    it "accepts Exception instances and matches class and message" do
+      expect {
+        Rails.error.report(TestError.new("exact message"))
+      }.to have_reported_error(TestError.new("exact message"))
+    end
+
+    it "accepts Exception instances with empty message and matches any message of that class" do
+      expect {
+        Rails.error.report(TestError.new("any message"))
+      }.to have_reported_error(TestError.new(""))
+    end
+
+    it "accepts Regexp directly for message matching" do
+      expect {
+        Rails.error.report(StandardError.new("error with pattern"))
+      }.to have_reported_error(/with pattern/)
+    end
+
+
+
+    it "fails when Exception instance class doesn't match" do
+      expect {
+        expect {
+          Rails.error.report(AnotherTestError.new("message"))
+        }.to have_reported_error(TestError.new("message"))
+      }.to fail_with(/Expected error to be an instance of TestError, but got AnotherTestError/)
+    end
+
+    it "fails when Exception instance message doesn't match" do
+      expect {
+        expect {
+          Rails.error.report(TestError.new("actual message"))
+        }.to have_reported_error(TestError.new("expected message"))
+      }.to fail_with(/Expected error message to be 'expected message', but got: 'actual message'/)
+    end
+  end
+
   describe "integration with actual usage patterns" do
     it "works with multiple error reports in a block" do
       expect {