handle hegated matchers safely, not allowing any attributes

Author: Stanislav (Stas) Katkov

lib/rspec/rails/matchers/have_reported_error.rb

@@ -124,6 +124,8 @@ def failure_message
         end
 
         def failure_message_when_negated
+          warn_about_negated_with_qualifiers! if has_qualifiers?
+
           error_count = @reports.count
           error_word = 'error'.pluralize(error_count)
           verb = error_count == 1 ? 'has' : 'have'
@@ -214,6 +216,19 @@ def warn_about_nil_error!
                          "`RSpec::Expectations.configuration.on_potential_false" \
                          "_positives = :nothing`")
         end
+
+        def warn_about_negated_with_qualifiers!
+          RSpec.warn_with("Using `expect { }.not_to have_reported_error(error_class_or_message)` " \
+                         "or with `.with_context()` is prone to false positives, since any error " \
+                         "that doesn't match the specific error class, message, or context can " \
+                         "cause the expectation to pass. Instead consider using " \
+                         "`expect { }.not_to have_reported_error` with no qualifiers to ensure " \
+                         "that no errors are reported at all.")
+        end
+
+        def has_qualifiers?
+          !@expected_error.nil? || !@expected_message.nil? || !@attributes.empty?
+        end
       end
 
       # @api public

spec/rspec/rails/matchers/have_reported_error_spec.rb

@@ -35,10 +35,6 @@ class AnotherTestError < StandardError; end
         expect { "no error" }.to have_reported_error
       }.to fail_with(/Expected the block to report an error, but none was reported./)
     end
-
-    it "passes when negated and no errors are reported" do
-      expect { "no error" }.not_to have_reported_error
-    end
   end
 
   context "constrained to a specific error class" do
@@ -209,20 +205,64 @@ class AnotherTestError < StandardError; end
     end
   end
 
-  describe "integration with actual usage patterns" do
-    it "works with multiple error reports in a block" do
+  it "works with multiple error reports in a block" do
+    expect {
+      Rails.error.report(StandardError.new("first error"))
+      Rails.error.report(TestError.new("second error"))
+    }.to have_reported_error(StandardError)
+  end
+
+  it "works with matcher chaining" do
+    expect {
+      expect {
+        Rails.error.report(TestError.new("test"))
+      }.to have_reported_error(TestError).and have_reported_error
+    }.to raise_error(ArgumentError, "Chaining is not supported")
+  end
+
+  describe "negation with qualifiers warnings" do
+    it "warns when negated with error class qualifier fails" do
       expect {
-        Rails.error.report(StandardError.new("first error"))
-        Rails.error.report(TestError.new("second error"))
-      }.to have_reported_error(StandardError)
+        expect {
+          Rails.error.report(TestError.new("test"))
+        }.not_to have_reported_error(TestError)
+      }.to raise_error(RuntimeError, /prone to false positives/)
     end
 
-    it "works with matcher chaining" do
+    it "warns when negated with message qualifier fails" do
       expect {
         expect {
-          Rails.error.report(TestError.new("test"))
-        }.to have_reported_error(TestError).and have_reported_error
-      }.to raise_error(ArgumentError, "Chaining is not supported")
+          Rails.error.report(StandardError.new("specific message"))
+        }.not_to have_reported_error("specific message")
+      }.to raise_error(RuntimeError, /prone to false positives/)
+    end
+
+    it "warns when negated with regex message qualifier fails" do
+      expect {
+        expect {
+          Rails.error.report(StandardError.new("test pattern"))
+        }.not_to have_reported_error(/pattern/)
+      }.to raise_error(RuntimeError, /prone to false positives/)
+    end
+
+    it "warns when negated with context qualifier fails" do
+      expect {
+        expect {
+          Rails.error.report(StandardError.new("test"), context: { user_id: 123 })
+        }.not_to have_reported_error.with_context(user_id: 123)
+      }.to raise_error(RuntimeError, /prone to false positives/)
+    end
+
+    it "warns when negated with both error class and message qualifiers fails" do
+      expect {
+        expect {
+          Rails.error.report(TestError.new("message"))
+        }.not_to have_reported_error(TestError, "message")
+      }.to raise_error(RuntimeError, /prone to false positives/)
+    end
+
+    it "does not warn when negated without any qualifiers" do
+      expect { "no error" }.not_to have_reported_error
     end
   end
 end