Remove mocks out of tests

Author: skatkov

lib/rspec/rails/matchers/have_reported_error.rb

@@ -69,11 +69,8 @@ def description
 
         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)
+            event_data = @error_subscriber.events.last[1].with_indifferent_access
+            unmatched = unmatched_attributes(event_data["context"])
             unless unmatched.empty?
               return "Expected error attributes to match #{@attributes}, but got these mismatches: #{unmatched} and actual values are #{event_data}"
             end
@@ -132,8 +129,8 @@ def attributes_match_if_specified?
           return true if @attributes.empty?
           return false if @error_subscriber.events.empty?
 
-          event_data = @error_subscriber.events.last[1]
-          attributes_match?(event_data)
+          event_data = @error_subscriber.events.last[1].with_indifferent_access
+          attributes_match?(event_data["context"])
         end
 
         def actual_error

spec/rspec/rails/matchers/have_reported_error_spec.rb

@@ -4,29 +4,6 @@
   class TestError < StandardError; end
   class AnotherTestError < StandardError; end
 
-  let(:mock_error_reporter) { double("ErrorReporter") }
-  let(:subscribers) { [] }
-
-  before do
-    allow(Rails).to receive(:error).and_return(mock_error_reporter)
-
-    allow(mock_error_reporter).to receive(:subscribe) do |subscriber|
-      subscribers << subscriber
-    end
-
-    allow(mock_error_reporter).to receive(:unsubscribe) do |subscriber|
-      subscribers.delete(subscriber)
-    end
-
-    allow(mock_error_reporter).to receive(:report) do |error, **attrs|
-      subscribers.each { |subscriber| subscriber.report(error, **attrs) }
-    end
-  end
-
-  after do
-    subscribers.clear
-  end
-
   describe "basic functionality" do
     it "passes when an error is reported" do
       test_block = proc do
@@ -118,53 +95,34 @@ class AnotherTestError < StandardError; end
     end
   end
 
-  describe "symbol error matching" do
-    it "passes when symbol matches" do
-      test_block = proc do
-        Rails.error.report(:test_symbol)
-      end
-
-      expect(test_block).to have_reported_error(:test_symbol)
-    end
-
-    it "fails when symbol does not match" do
-      test_block = proc do
-        Rails.error.report(:actual_symbol)
-      end
-      matcher = have_reported_error(:expected_symbol)
-
-      expect(matcher.matches?(test_block)).to be false
-    end
-  end
-
   describe "attribute matching with .with chain" do
     it "passes when attributes match exactly" do
       test_block = proc do
-        Rails.error.report(StandardError.new("test"), user_id: 123, context: "test")
+        Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "test" })
       end
 
       expect(test_block).to have_reported_error.with(user_id: 123, context: "test")
     end
 
     it "passes with partial attribute matching" do
       test_block = proc do
-        Rails.error.report(StandardError.new("test"), user_id: 123, context: "test", extra: "data")
+        Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "test", extra: "data" })
       end
 
       expect(test_block).to have_reported_error.with(user_id: 123)
     end
 
     it "passes with hash matching using RSpec matchers" do
       test_block = proc do
-        Rails.error.report(StandardError.new("test"), params: { foo: "bar", baz: "qux" })
+        Rails.error.report(StandardError.new("test"), context: { params: { foo: "bar", baz: "qux" } })
       end
 
       expect(test_block).to have_reported_error.with(params: a_hash_including(foo: "bar"))
     end
 
     it "fails when attributes do not match" do
       test_block = proc do
-        Rails.error.report(StandardError.new("test"), user_id: 123, context: "actual")
+        Rails.error.report(StandardError.new("test"), context: { user_id: 123, context: "actual" })
       end
       matcher = have_reported_error.with(user_id: 456, context: "expected")
 
@@ -185,8 +143,6 @@ class AnotherTestError < StandardError; end
         Rails.error.report(StandardError.new("test"))
       end
 
-      expect(mock_error_reporter).to receive(:unsubscribe)
-
       expect(test_block).to have_reported_error
     end
 
@@ -196,8 +152,6 @@ class AnotherTestError < StandardError; end
         raise "unexpected error"
       end
 
-      expect(mock_error_reporter).to receive(:unsubscribe)
-
       expect {
         have_reported_error.matches?(test_block)
       }.to raise_error("unexpected error")
@@ -224,7 +178,7 @@ class AnotherTestError < StandardError; end
 
     it "works with matcher chaining" do
       test_block = proc do
-        Rails.error.report(TestError.new("test"), user_id: 123)
+        Rails.error.report(TestError.new("test"), context: { user_id: 123 })
       end
 
       expect(test_block).to have_reported_error(TestError).and have_reported_error