switch to error_report matcher type of api

Author: skatkov

features/matchers/README.md

@@ -40,9 +40,14 @@ expect { Rails.error.report(MyError.new("message")) }.to have_reported_error(MyE
 # 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 any error with exact message is reported
+expect { Rails.error.report(StandardError.new("exact message")) }.to have_reported_error("exact message")
+
+# passes when any error with message matching pattern is reported
+expect { Rails.error.report(StandardError.new("test message")) }.to have_reported_error(/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"))
+
 ```

features/matchers/have_reported_error_matcher.feature

@@ -2,15 +2,15 @@ Feature: `have_reported_error` matcher
 
   The `have_reported_error` matcher is used to check if an error was reported
   to Rails error reporting system (`Rails.error`). It can match against error
-  classes, instances, messages, and attributes.
+  classes, messages, and attributes.
 
   The matcher supports several matching strategies:
   * Any error reported
   * A specific error class
-  * Specific error instance with message
+  * A specific error class with message
   * Error message patterns using regular expressions
-  * Error attributes using `.with()`
-  * Symbol errors
+  * Message-only matching (any class)
+  * Error attributes using `.with_context()`
 
   The matcher is available in all spec types where Rails error reporting is used.
 
@@ -24,7 +24,7 @@ Feature: `have_reported_error` matcher
         end
 
         def self.process_with_context
-          Rails.error.report(ArgumentError.new("Invalid input"), context: "user_processing", severity: "high")
+          Rails.error.report(ArgumentError.new("Invalid input"), context: { context: "user_processing", severity: :error })
         end
 
         def self.process_custom_error
@@ -49,6 +49,28 @@ Feature: `have_reported_error` matcher
     When I run `rspec spec/models/user_spec.rb`
     Then the examples should all pass
 
+  Scenario: Checking for message-only matching
+    Given a file named "spec/models/user_spec.rb" with:
+      """ruby
+      require "rails_helper"
+
+      RSpec.describe User do
+        it "reports error with exact message (any class)" do
+          expect {
+            User.process_data
+          }.to have_reported_error("Processing failed")
+        end
+
+        it "reports error with message pattern (any class)" do
+          expect {
+            User.process_custom_error
+          }.to have_reported_error(/Email/)
+        end
+      end
+      """
+    When I run `rspec spec/models/user_spec.rb`
+    Then the examples should all pass
+
   Scenario: Checking for a specific error class
     Given a file named "spec/models/user_spec.rb" with:
       """ruby
@@ -71,7 +93,7 @@ Feature: `have_reported_error` matcher
     When I run `rspec spec/models/user_spec.rb`
     Then the examples should all pass
 
-  Scenario: Checking for specific error instance with message
+  Scenario: Checking for specific error class with message
     Given a file named "spec/models/user_spec.rb" with:
       """ruby
       require "rails_helper"
@@ -80,13 +102,13 @@ Feature: `have_reported_error` matcher
         it "reports error with specific message" do
           expect {
             User.process_data
-          }.to have_reported_error(StandardError.new("Processing failed"))
+          }.to have_reported_error(StandardError, "Processing failed")
         end
 
         it "reports ArgumentError with specific message" do
           expect {
             User.process_with_context
-          }.to have_reported_error(ArgumentError.new("Invalid input"))
+          }.to have_reported_error(ArgumentError, "Invalid input")
         end
       end
       """
@@ -99,17 +121,23 @@ Feature: `have_reported_error` matcher
       require "rails_helper"
 
       RSpec.describe User do
-        it "reports errors with a message matching a pattern" do
+        it "reports errors with a message matching a pattern (any class)" do
           expect {
             User.process_data
           }.to have_reported_error(/Processing/)
         end
+
+        it "reports specific class with message matching a pattern" do
+          expect {
+            User.process_data
+          }.to have_reported_error(StandardError, /Processing/)
+        end
       end
       """
     When I run `rspec spec/models/user_spec.rb`
     Then the examples should all pass
 
-  Scenario: Constraining error matches to their attributes using `with`
+  Scenario: Constraining error matches to their attributes using `with_context`
     Given a file named "spec/models/user_spec.rb" with:
       """ruby
       require "rails_helper"
@@ -118,13 +146,13 @@ Feature: `have_reported_error` matcher
         it "reports error with specific context" do
           expect {
             User.process_with_context
-          }.to have_reported_error.with(context: "user_processing")
+          }.to have_reported_error.with_context(context: "user_processing")
         end
 
         it "reports error with multiple attributes" do
           expect {
             User.process_with_context
-          }.to have_reported_error(ArgumentError).with(context: "user_processing", severity: "high")
+          }.to have_reported_error(ArgumentError).with_context(context: "user_processing", severity: :error)
         end
       end
       """
@@ -140,13 +168,13 @@ Feature: `have_reported_error` matcher
         it "reports a ValidationError" do
           expect {
             User.process_custom_error
-          }.to have_reported_error(ValidationError)
+          }.to have_reported_error(User::ValidationError)
         end
 
         it "reports ValidationError with specific message" do
           expect {
             User.process_custom_error
-          }.to have_reported_error(ValidationError.new("Email is invalid"))
+          }.to have_reported_error(User::ValidationError, "Email is invalid")
         end
       end
       """

lib/rspec/rails/matchers/have_reported_error.rb

@@ -23,22 +23,16 @@ def report(error, **attrs)
       # @api private
       # @see RSpec::Rails::Matchers#have_reported_error
       class HaveReportedError < RSpec::Rails::Matchers::BaseMatcher
-        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)
+        def initialize(expected_error_or_message = nil, expected_message = nil)
+          if expected_error_or_message.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_message = expected_error_or_message
+          elsif expected_error_or_message.is_a?(String)
             @expected_error_class = nil
-            @expected_message = nil
+            @expected_message = expected_error_or_message
           else
-            @expected_error_class = expected_error_class
+            @expected_error_class = expected_error_or_message
             @expected_message = expected_message
-            @expected_error_symbol = nil
           end
 
           @attributes = {}
@@ -77,22 +71,26 @@ def supports_block_expectations?
         end
 
         def description
-          desc = "report an 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
+          base_desc = if @expected_error_class
+                        "report a #{@expected_error_class} error"
+                      else
+                        "report an error"
+                      end
+
+          message_desc = if @expected_message
+                           case @expected_message
+                           when Regexp
+                             " with message matching #{@expected_message}"
+                           when String
+                             " with message '#{@expected_message}'"
+                           end
+                         else
+                           ""
+                         end
+
+          attributes_desc = @attributes.empty? ? "" : " with #{@attributes}"
+
+          base_desc + message_desc + attributes_desc
         end
 
         def failure_message
@@ -105,9 +103,7 @@ def failure_message
           elsif @error_subscriber.events.empty?
             return 'Expected the block to report an error, but none was reported.'
           else
-            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)
+            if @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
@@ -136,11 +132,6 @@ def error_matches_expectation?
           # 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?
 
@@ -206,23 +197,25 @@ def unmatched_attributes(actual)
       # @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 for error with exact message (any class)
+      #   expect { Rails.error.report(StandardError.new("exact message")) }.to have_reported_error("exact message")
       #
-      # @example Checking error attributes
-      #   expect { Rails.error.report(StandardError.new, context: "test") }.to have_reported_error.with_context(context: "test")
+      # @example Checking for error with message pattern (any class)
+      #   expect { Rails.error.report(StandardError.new("test message")) }.to have_reported_error(/test/)
       #
-      # @example Checking error message patterns
+      # @example Checking for specific error class with message pattern
       #   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 Checking error attributes
+      #   expect { Rails.error.report(StandardError.new, context: "test") }.to have_reported_error.with_context(context: "test")
       #
       # @example Negation
       #   expect { "safe code" }.not_to have_reported_error
       #
-      # @param expected_error_class [Class, Exception, Regexp, Symbol, nil] the expected error class to match, or error instance for backward compatibility
+      # @param expected_error_or_message [Class, String, Regexp, nil] the expected error class, message string, or message pattern
       # @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)
+      def have_reported_error(expected_error_or_message = nil, expected_message = nil)
+        HaveReportedError.new(expected_error_or_message, expected_message)
       end
 
       alias_method :reports_error, :have_reported_error

spec/rspec/rails/matchers/have_reported_error_spec.rb

@@ -152,41 +152,33 @@ class AnotherTestError < StandardError; end
     end
   end
 
-  context "backward compatibility with old API" do
-    it "accepts Exception instances and matches class and message" do
+  context "constrained by message only" do
+    it "passes when any error with exact message is reported" do
       expect {
-        Rails.error.report(TestError.new("exact message"))
-      }.to have_reported_error(TestError.new("exact message"))
+        Rails.error.report(StandardError.new("exact message"))
+      }.to have_reported_error("exact message")
     end
 
-    it "accepts Exception instances with empty message and matches any message of that class" do
+    it "passes when any error with message matching pattern is reported" 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"))
+        Rails.error.report(AnotherTestError.new("error with pattern"))
       }.to have_reported_error(/with pattern/)
     end
 
-
-
-    it "fails when Exception instance class doesn't match" do
+    it "fails when no error with exact message is reported" 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/)
+          Rails.error.report(StandardError.new("actual message"))
+        }.to have_reported_error("expected message")
+      }.to fail_with(/Expected error message to be 'expected message', but got: 'actual message'/)
     end
 
-    it "fails when Exception instance message doesn't match" do
+    it "fails when no error with matching pattern is reported" 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'/)
+          Rails.error.report(StandardError.new("error without match"))
+        }.to have_reported_error(/different pattern/)
+      }.to fail_with(/Expected error message to match/)
     end
   end