rubocop-rspec_rails 2.32.0 → 2.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a750fc4e562218ed87ba5242d34797589b5df5598ad0cac33799546bf2a0230
-  data.tar.gz: 76e8e5c35753d371fa4fd4fdb41ced69adb33c2168d0232f6b2ba5f73a82b5da
+  metadata.gz: a42fb50c1cc6fac2f7c5a5c81dcf9573d4cbc27390157cc0063b907c880b12ae
+  data.tar.gz: b4e95f46c045360b80c76177b975ba2932c247974e63d56cd7e376b176831288
 SHA512:
-  metadata.gz: 8929c0661a8c342e41d652597c24549eefef4a3fad2ad566588df2bae35aeed79d68c44ea2a1d7270ee91d089c698095889e41b3f9012b3cddad2fadba6a4d48
-  data.tar.gz: a4a1dfde481062a1d2445100d753bfb66df082537c0157a2189ba6af9ab4f5dd8a459561278db7e2b80c434009455b908927549f201a7aa692f66fc4b28f1adc
+  metadata.gz: 594c53b8d30e097e94063476fd9d42d014ae3f4913a029956b66a9c25be1064d8136bedeea8247e7845bfd6278b614a8a7ea7da2a71e1677739500c44ce24782
+  data.tar.gz: 7318471ee0e4062142c4a64ca3ad5a718d7d00c6653d6210d7345bbf60208fe51f8b4c815849e369daecf3810d59d351c69b330ddb7130c028b89cbeb21af152

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Master (Unreleased)
 
+## 2.33.0 (2026-10-07)
+
+- Add `RSpecRails/FileFixture` cop to prefer `file_fixture` over hardcoded fixture paths. ([@ydah])
+- Fix `RSpecRails/HttpStatus` to detect unknown symbolic HTTP statuses and handle custom numeric string statuses consistently. ([@ydah])
+- Speed up loading rubocop-rspec_rails by lazily loading only the cops needed for a run. This requires RuboCop 1.89.0+. ([@koic])
+- Fix offense message for `RSpecRails/HttpStatusNameConsistency` cop. ([@fatkodima])
+- Fix `RSpecRails/MinitestAssertions` autocorrection for quoted predicate symbols. ([@ydah])
+- Fix `RSpecRails/AvoidSetupHook` to only check setup hooks inside example groups. ([@ydah])
+- Fix a false positive for `RspecRails/NegationBeValid` when use `to_not`. ([@ydah])
+- Fix false positives for `RSpecRails/TravelAround` when travel does not directly wrap the around example. ([@ydah])
+- Supporting correcting `assest_redirected_to` in `RSpec/Rails/MinitestAssertions`. ([@nzlaura])
+- Add new `RSpecRails/ReceivePerformLater` cop. ([@ydah])
+- Fix `RSpecRails/ReceivePerformLater` offense range to exclude chains after the expectation. ([@ydah])
+- Fix a false positive for `RSpecRails/ReceivePerformLater` when `receive(:perform_later)` is used inside another matcher. ([@ydah])
+- Support `described_class` for `RSpecRails/ReceivePerformLater`. ([@ydah])
+- Fix `RSpecRails/TravelAround` autocorrection to keep the indentation of the surrounding `around` block. ([@eugeneius])
+- Fix `RSpecRails/ReceivePerformLater` offense messages for negative expectations. ([@ydah])
+
 ## 2.32.0 (2025-11-12)
 
 - Add `RSpecRails/HttpStatusNameConsistency` cop. ([@taketo1113])
@@ -83,8 +101,11 @@
 [@anthony-robin]: https://github.com/anthony-robin
 [@bquorning]: https://github.com/bquorning
 [@corydiamand]: https://github.com/corydiamand
+[@eugeneius]: https://github.com/eugeneius
+[@fatkodima]: https://github.com/fatkodima
 [@g-rath]: https://github.com/G-Rath
 [@jojos003]: https://github.com/jojos003
+[@koic]: https://github.com/koic
 [@mothonmars]: https://github.com/MothOnMars
 [@mvz]: https://github.com/mvz
 [@nzlaura]: https://github.com/nzlaura

data/config/default.yml

@@ -7,11 +7,18 @@ RSpecRails:
     - "**/spec/**/*"
 
 RSpecRails/AvoidSetupHook:
-  Description: Checks that tests use RSpec `before` hook over Rails `setup` method.
+  Description: Checks that tests use RSpec `before` instead of Rails `setup`.
   Enabled: pending
   VersionAdded: '2.4'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec_rails/RuboCop/Cop/RSpecRails/AvoidSetupHook
 
+RSpecRails/FileFixture:
+  Description: Prefer `file_fixture` over hardcoded paths into `spec/fixtures`.
+  Enabled: pending
+  Safe: false
+  VersionAdded: '2.33'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec_rails/RuboCop/Cop/RSpecRails/FileFixture
+
 RSpecRails/HaveHttpStatus:
   Description: Checks that tests use `have_http_status` instead of equality matchers.
   Enabled: pending
@@ -65,7 +72,7 @@ RSpecRails/InferredSpecType:
     views: view
 
 RSpecRails/MinitestAssertions:
-  Description: Check if using Minitest-like matchers.
+  Description: Detects Minitest-like matchers.
   Enabled: pending
   VersionAdded: '2.17'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec_rails/RuboCop/Cop/RSpecRails/MinitestAssertions
@@ -83,8 +90,14 @@ RSpecRails/NegationBeValid:
   VersionChanged: '2.29'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec_rails/RuboCop/Cop/RSpecRails/NegationBeValid
 
+RSpecRails/ReceivePerformLater:
+  Description: Prefer `have_enqueued_job` over `receive(:perform_later)`.
+  Enabled: pending
+  VersionAdded: '2.33'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec_rails/RuboCop/Cop/RSpecRails/ReceivePerformLater
+
 RSpecRails/TravelAround:
-  Description: Prefer to travel in `before` rather than `around`.
+  Description: Checks for time travel helpers in `around` hooks.
   Enabled: pending
   Safe: false
   VersionAdded: '2.19'

data/lib/rubocop/cop/rspec_rails/avoid_setup_hook.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpecRails
-      # Checks that tests use RSpec `before` hook over Rails `setup` method.
+      # Checks that tests use RSpec `before` instead of Rails `setup`.
       #
       # @example
       #   # bad
@@ -16,8 +16,9 @@ module RuboCop
       #     allow(foo).to receive(:bar)
       #   end
       #
-      class AvoidSetupHook < ::RuboCop::Cop::Base
+      class AvoidSetupHook < RuboCop::Cop::RSpec::Base
         extend AutoCorrector
+        include RuboCop::Cop::RSpec::InsideExampleGroup
 
         MSG = 'Use `before` instead of `setup`.'
 
@@ -28,7 +29,9 @@ module RuboCop
             (args) _)
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler, InternalAffairs/NumblockHandler
+          return unless inside_example_group?(node)
+
           setup_call(node) do |setup|
             add_offense(node) do |corrector|
               corrector.replace setup, 'before'

data/lib/rubocop/cop/rspec_rails/file_fixture.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpecRails
+      # Prefer `file_fixture` over hardcoded paths into `spec/fixtures`.
+      #
+      # @safety
+      #   `file_fixture` uses the configured `file_fixture_path`, which defaults
+      #   to `spec/fixtures/files`. A file under `spec/fixtures` may need to be
+      #   moved or `file_fixture_path` configured before replacing the path.
+      #
+      # @example
+      #   # bad
+      #   Rails.root.join('spec', 'fixtures', 'files', 'example.pdf')
+      #
+      #   # good
+      #   file_fixture('example.pdf')
+      class FileFixture < RuboCop::Cop::Base
+        MSG = 'Prefer `file_fixture` for files under `spec/fixtures`.'
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        # @!method fixture_path?(node)
+        def_node_matcher :fixture_path?, <<~PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :root)
+            :join (str "spec") (str "fixtures") _ ...)
+        PATTERN
+
+        # @!method combined_fixture_path?(node)
+        def_node_matcher :combined_fixture_path?, <<~PATTERN
+          (send
+            (send (const {nil? cbase} :Rails) :root)
+            :join (str "spec/fixtures") _ ...)
+        PATTERN
+
+        def on_send(node)
+          return unless fixture_path?(node) || combined_fixture_path?(node)
+
+          add_offense(node.loc.selector)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec_rails/have_http_status.rb

@@ -5,7 +5,11 @@ module RuboCop
     module RSpecRails
       # Checks that tests use `have_http_status` instead of equality matchers.
       #
-      # @example ResponseMethods: ['response', 'last_response'] (default)
+      # @safety
+      #   The autocorrection is marked as unsafe because
+      #   `response.status` response is not always an HTTP response status.
+      #
+      # @example `ResponseMethods: ['response', 'last_response']` (default)
       #   # bad
       #   expect(response.status).to be(200)
       #   expect(last_response.code).to eq("200")
@@ -14,7 +18,7 @@ module RuboCop
       #   expect(response).to have_http_status(200)
       #   expect(last_response).to have_http_status(200)
       #
-      # @example ResponseMethods: ['foo_response']
+      # @example `ResponseMethods: ['foo_response']`
       #   # bad
       #   expect(foo_response.status).to be(200)
       #
@@ -25,7 +29,7 @@ module RuboCop
       #   expect(response).to have_http_status(200)
       #   expect(last_response).to have_http_status(200)
       #
-      class HaveHttpStatus < ::RuboCop::Cop::Base
+      class HaveHttpStatus < RuboCop::Cop::Base
         extend AutoCorrector
 
         MSG =

data/lib/rubocop/cop/rspec_rails/http_status.rb

@@ -64,9 +64,10 @@ module RuboCop
       #
       #   # good
       #   it { is_expected.to have_http_status :ok }
-      class HttpStatus < ::RuboCop::Cop::Base
+      class HttpStatus < RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
+
         RESTRICT_ON_SEND = %i[have_http_status].freeze
 
         # @!method http_status(node)
@@ -142,16 +143,44 @@ module RuboCop
             node.sym_type? && ALLOWED_STATUSES.include?(node.value)
           end
 
+          def known_status_symbol?
+            node.sym_type? &&
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(node.value)
+          end
+
+          def known_status_code?
+            numeric_status_code? &&
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(status_code_number)
+          end
+
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
+            numeric_status_code? && !known_status_code?
+          end
+
+          def numeric_status_code?
+            node.int_type? || numeric_string?
+          end
+
+          def numeric_string?
+            node.str_type? && node.value.match?(/\A\d+\z/)
+          end
+
+          def status_code_number
+            node.value.to_i
+          end
+
+          def status_code_symbol
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(status_code_number)
           end
         end
 
         # :nodoc:
         class SymbolicStyleChecker < StyleCheckerBase
           def offensive?
-            !node.sym_type? && !custom_http_status_code?
+            return false if allowed_symbol? || known_status_symbol?
+            return false if custom_http_status_code?
+
+            true
           end
 
           def autocorrectable?
@@ -165,18 +194,17 @@ module RuboCop
           private
 
           def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-          end
-
-          def number
-            node.value.to_i
+            status_code_symbol if known_status_code?
           end
         end
 
         # :nodoc:
         class NumericStyleChecker < StyleCheckerBase
           def offensive?
-            !node.int_type? && !allowed_symbol?
+            return false if node.int_type? || allowed_symbol?
+            return false if custom_http_status_code?
+
+            true
           end
 
           def autocorrectable?
@@ -189,20 +217,19 @@ module RuboCop
 
           private
 
-          def symbol
-            node.value
-          end
-
           def number
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol.to_sym]
+            return status_code_number if known_status_code?
+
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[node.value.to_sym]
           end
         end
 
         # :nodoc:
         class BeStatusStyleChecker < StyleCheckerBase
           def offensive?
-            (!node.sym_type? && !custom_http_status_code?) ||
-              (!node.int_type? && !allowed_symbol?)
+            return false if allowed_symbol? || custom_http_status_code?
+
+            true
           end
 
           def autocorrectable?
@@ -220,30 +247,18 @@ module RuboCop
           private
 
           def status_code
-            if node.sym_type?
+            if known_status_symbol?
               node.value
-            elsif node.int_type?
-              symbol
+            elsif known_status_code?
+              status_code_symbol
             else
               normalize_str
             end
           end
 
-          def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-          end
-
-          def number
-            node.value.to_i
-          end
-
           def normalize_str
             str = node.value.to_s
-            if str.match?(/\A\d+\z/)
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(str.to_i)
-            elsif ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(str.to_sym)
-              str
-            end
+            str if ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(str.to_sym)
           end
         end
       end

data/lib/rubocop/cop/rspec_rails/http_status_name_consistency.rb

@@ -13,12 +13,12 @@ module RuboCop
       #   # good
       #   it { is_expected.to have_http_status :unprocessable_content }
       #
-      class HttpStatusNameConsistency < ::RuboCop::Cop::Base
+      class HttpStatusNameConsistency < RuboCop::Cop::Base
         extend AutoCorrector
 
         requires_gem 'rack', '>= 3.1.0'
 
-        MSG = 'Use `Prefer `:%<preferred>s` over `:%<current>s`.'
+        MSG = 'Prefer `:%<preferred>s` over `:%<current>s`.'
 
         RESTRICT_ON_SEND = %i[have_http_status].freeze
 

data/lib/rubocop/cop/rspec_rails/inferred_spec_type.rb

@@ -30,12 +30,7 @@ module RuboCop
       #   RSpec.describe User, type: :common do
       #   end
       #
-      # @example `Inferences` configuration
-      #   # .rubocop.yml
-      #   # RSpecRails/InferredSpecType:
-      #   #   Inferences:
-      #   #     services: service
-      #
+      # @example `Inferences: {services: service}`
       #   # bad
       #   # spec/services/user_spec.rb
       #   RSpec.describe User, type: :service do
@@ -50,13 +45,13 @@ module RuboCop
       #   # spec/services/user_spec.rb
       #   RSpec.describe User, type: :common do
       #   end
-      class InferredSpecType < ::RuboCop::Cop::RSpec::Base
+      class InferredSpecType < RuboCop::Cop::RSpec::Base
         extend AutoCorrector
 
         MSG = 'Remove redundant spec type.'
 
         # @param [RuboCop::AST::BlockNode] node
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
           return unless example_group?(node)
 
           pair_node = describe_with_type(node)

data/lib/rubocop/cop/rspec_rails/minitest_assertions.rb

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module RSpecRails
-      # Check if using Minitest-like matchers.
+      # Detects Minitest-like matchers.
       #
-      # Check the use of minitest-like matchers
-      # starting with `assert_` or `refute_`.
+      # Detects the use of Minitest-like matchers
+      # (those starting with `assert_` or `refute_`).
       #
       # @example
       #   # bad
@@ -19,6 +19,7 @@ module RuboCop
       #   assert_true(a)
       #   assert_false(a)
       #   assert_response :ok
+      #   assert_redirected_to '/users'
       #
       #   # good
       #   expect(b).to eq(a)
@@ -30,8 +31,9 @@ module RuboCop
       #   expect(a).to be(true)
       #   expect(a).to be(false)
       #   expect(response).to have_http_status(:ok)
+      #   expect(response).to redirect_to('/users')
       #
-      class MinitestAssertions < ::RuboCop::Cop::Base
+      class MinitestAssertions < RuboCop::Cop::Base
         extend AutoCorrector
 
         # :nodoc:
@@ -40,12 +42,25 @@ module RuboCop
 
           attr_reader :expected, :actual, :failure_message
 
+          def self.match_assertions(*matchers, captures:)
+            const_set(:MATCHERS, matchers.freeze)
+
+            matcher_pattern = matchers.map { |matcher| ":#{matcher}" }.join(' ')
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {#{matcher_pattern}} #{captures})
+            PATTERN
+          end
+
           def self.minitest_assertion
             # :nocov:
             raise NotImplementedError
             # :nocov:
           end
 
+          def self.match(expected, actual, failure_message)
+            new(expected, actual, failure_message.first)
+          end
+
           def initialize(expected, actual, failure_message)
             @expected = expected&.source
             @actual = actual.source
@@ -74,20 +89,10 @@ module RuboCop
 
         # :nodoc:
         class EqualAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_equal
-            assert_not_equal
-            refute_equal
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_equal :assert_not_equal :refute_equal} $_ $_ $_?)
-          PATTERN
-
-          def self.match(expected, actual, failure_message)
-            new(expected, actual, failure_message.first)
-          end
+          match_assertions :assert_equal,
+                           :assert_not_equal,
+                           :refute_equal,
+                           captures: '$_ $_ $_?'
 
           def assertion
             "eq(#{expected})"
@@ -96,20 +101,10 @@ module RuboCop
 
         # :nodoc:
         class KindOfAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_kind_of
-            assert_not_kind_of
-            refute_kind_of
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_kind_of :assert_not_kind_of :refute_kind_of} $_ $_ $_?)
-          PATTERN
-
-          def self.match(expected, actual, failure_message)
-            new(expected, actual, failure_message.first)
-          end
+          match_assertions :assert_kind_of,
+                           :assert_not_kind_of,
+                           :refute_kind_of,
+                           captures: '$_ $_ $_?'
 
           def assertion
             "be_a_kind_of(#{expected})"
@@ -118,20 +113,10 @@ module RuboCop
 
         # :nodoc:
         class InstanceOfAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_instance_of
-            assert_not_instance_of
-            refute_instance_of
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_instance_of :assert_not_instance_of :refute_instance_of} $_ $_ $_?)
-          PATTERN
-
-          def self.match(expected, actual, failure_message)
-            new(expected, actual, failure_message.first)
-          end
+          match_assertions :assert_instance_of,
+                           :assert_not_instance_of,
+                           :refute_instance_of,
+                           captures: '$_ $_ $_?'
 
           def assertion
             "be_an_instance_of(#{expected})"
@@ -140,16 +125,10 @@ module RuboCop
 
         # :nodoc:
         class IncludesAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_includes
-            assert_not_includes
-            refute_includes
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_includes :assert_not_includes :refute_includes} $_ $_ $_?)
-          PATTERN
+          match_assertions :assert_includes,
+                           :assert_not_includes,
+                           :refute_includes,
+                           captures: '$_ $_ $_?'
 
           def self.match(collection, expected, failure_message)
             new(expected, collection, failure_message.first)
@@ -162,16 +141,10 @@ module RuboCop
 
         # :nodoc:
         class InDeltaAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_in_delta
-            assert_not_in_delta
-            refute_in_delta
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_in_delta :assert_not_in_delta :refute_in_delta} $_ $_ $_? $_?)
-          PATTERN
+          match_assertions :assert_in_delta,
+                           :assert_not_in_delta,
+                           :refute_in_delta,
+                           captures: '$_ $_ $_? $_?'
 
           def self.match(expected, actual, delta, failure_message)
             new(expected, actual, delta.first, failure_message.first)
@@ -190,43 +163,41 @@ module RuboCop
 
         # :nodoc:
         class PredicateAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_predicate
-            assert_not_predicate
-            refute_predicate
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_predicate :assert_not_predicate :refute_predicate} $_ ${sym} $_?)
-          PATTERN
+          match_assertions :assert_predicate,
+                           :assert_not_predicate,
+                           :refute_predicate,
+                           captures: '$_ ${sym} $_?'
 
           def self.match(subject, predicate, failure_message)
-            return nil unless predicate.value.end_with?('?')
+            predicate_name = predicate.value.to_s
+            return nil unless predicate_name.end_with?('?')
+
+            matcher_name = predicate_name.delete_suffix('?')
+            return nil unless valid_matcher_name?(matcher_name)
 
-            new(predicate, subject, failure_message.first)
+            new(predicate, subject, failure_message.first, matcher_name)
+          end
+
+          def self.valid_matcher_name?(matcher_name)
+            matcher_name.match?(/\A\w+\z/)
+          end
+
+          def initialize(expected, actual, failure_message, matcher_name)
+            super(expected, actual, failure_message)
+
+            @matcher_name = matcher_name
           end
 
           def assertion
-            "be_#{expected.delete_prefix(':').delete_suffix('?')}"
+            "be_#{@matcher_name}"
           end
         end
 
         # :nodoc:
         class MatchAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_match
-            refute_match
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_match :refute_match} $_ $_ $_?)
-          PATTERN
-
-          def self.match(matcher, actual, failure_message)
-            new(matcher, actual, failure_message.first)
-          end
+          match_assertions :assert_match,
+                           :refute_match,
+                           captures: '$_ $_ $_?'
 
           def assertion
             "match(#{expected})"
@@ -235,16 +206,10 @@ module RuboCop
 
         # :nodoc:
         class NilAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_nil
-            assert_not_nil
-            refute_nil
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_nil :assert_not_nil :refute_nil} $_ $_?)
-          PATTERN
+          match_assertions :assert_nil,
+                           :assert_not_nil,
+                           :refute_nil,
+                           captures: '$_ $_?'
 
           def self.match(actual, failure_message)
             new(nil, actual, failure_message.first)
@@ -257,16 +222,10 @@ module RuboCop
 
         # :nodoc:
         class EmptyAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_empty
-            assert_not_empty
-            refute_empty
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_empty :assert_not_empty :refute_empty} $_ $_?)
-          PATTERN
+          match_assertions :assert_empty,
+                           :assert_not_empty,
+                           :refute_empty,
+                           captures: '$_ $_?'
 
           def self.match(actual, failure_message)
             new(nil, actual, failure_message.first)
@@ -279,14 +238,7 @@ module RuboCop
 
         # :nodoc:
         class TrueAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_true
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_true} $_ $_?)
-          PATTERN
+          match_assertions :assert_true, captures: '$_ $_?'
 
           def self.match(actual, failure_message)
             new(nil, actual, failure_message.first)
@@ -299,14 +251,7 @@ module RuboCop
 
         # :nodoc:
         class FalseAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_false
-          ].freeze
-
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_false} $_ $_?)
-          PATTERN
+          match_assertions :assert_false, captures: '$_ $_?'
 
           def self.match(actual, failure_message)
             new(nil, actual, failure_message.first)
@@ -318,27 +263,36 @@ module RuboCop
         end
 
         # :nodoc:
-        class ResponseAssertion < BasicAssertion
-          MATCHERS = %i[
-            assert_response
-          ].freeze
+        module ResponseAssertionActual
+          RESPONSE_NODE = Struct.new(:source).new('response')
 
-          ASSERT_ACTUAL_NODE = Struct.new(:source).new('response')
+          def match(expected, failure_message)
+            new(expected, RESPONSE_NODE, failure_message.first)
+          end
+        end
 
-          # @!method self.minitest_assertion(node)
-          def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
-            (send nil? {:assert_response} $_ $_?)
-          PATTERN
+        # :nodoc:
+        class ResponseAssertion < BasicAssertion
+          extend ResponseAssertionActual
 
-          def self.match(expected, failure_message)
-            new(expected, ASSERT_ACTUAL_NODE, failure_message.first)
-          end
+          match_assertions :assert_response, captures: '$_ $_?'
 
           def assertion
             "have_http_status(#{expected})"
           end
         end
 
+        # :nodoc:
+        class RedirectAssertion < BasicAssertion
+          extend ResponseAssertionActual
+
+          match_assertions :assert_redirected_to, captures: '$_ $_?'
+
+          def assertion
+            "redirect_to(#{expected})"
+          end
+        end
+
         MSG = 'Use `%<prefer>s`.'
 
         # TODO: replace with `BasicAssertion.subclasses` in Ruby 3.1+

data/lib/rubocop/cop/rspec_rails/negation_be_valid.rb

@@ -9,7 +9,7 @@ module RuboCop
       #   This cop is unsafe because it cannot guarantee that
       #   the test target is an instance of `ActiveModel::Validations``.
       #
-      # @example EnforcedStyle: not_to (default)
+      # @example `EnforcedStyle: not_to` (default)
       #   # bad
       #   expect(foo).to be_invalid
       #
@@ -19,7 +19,7 @@ module RuboCop
       #   # good (with method chain)
       #   expect(foo).to be_invalid.and be_odd
       #
-      # @example EnforcedStyle: be_invalid
+      # @example `EnforcedStyle: be_invalid`
       #   # bad
       #   expect(foo).not_to be_valid
       #
@@ -29,7 +29,7 @@ module RuboCop
       #   # good (with method chain)
       #   expect(foo).to be_invalid.or be_even
       #
-      class NegationBeValid < ::RuboCop::Cop::Base
+      class NegationBeValid < RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 
@@ -38,7 +38,7 @@ module RuboCop
 
         # @!method not_to?(node)
         def_node_matcher :not_to?, <<~PATTERN
-          (send ... :not_to (send nil? :be_valid ...))
+          (send ... {:not_to :to_not} (send nil? :be_valid ...))
         PATTERN
 
         # @!method be_invalid?(node)

data/lib/rubocop/cop/rspec_rails/receive_perform_later.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpecRails
+      # Prefer `have_enqueued_job` over `receive(:perform_later)`.
+      #
+      # The `have_enqueued_job` matcher is preferred for testing ActiveJob
+      # enqueuing. It is more explicit and provides better clarity than
+      # using `receive(:perform_later)`.
+      #
+      # @example
+      #   # bad
+      #   expect(MyJob).to receive(:perform_later)
+      #   do_something
+      #
+      #   # bad
+      #   allow(MyJob).to receive(:perform_later)
+      #   do_something
+      #   expect(MyJob).to have_received(:perform_later)
+      #
+      #   # bad
+      #   expect(MyJob).to receive(:perform_later).with(user, order)
+      #
+      #   # good
+      #   expect { do_something }.to have_enqueued_job(MyJob)
+      #
+      #   # good
+      #   expect { do_something }.to have_enqueued_job(MyJob).with(user, order)
+      #
+      #   # good
+      #   expect { do_something }
+      #     .to have_enqueued_job(MyJob)
+      #     .on_queue('mailers')
+      #     .at(Date.tomorrow.noon)
+      #
+      class ReceivePerformLater < RuboCop::Cop::Base
+        MSG = 'Prefer `expect { ... }.%<runner>s ' \
+              'have_enqueued_job(%<job_class>s)` ' \
+              'over `%<receiver>s(%<job_class>s).%<to>s ' \
+              '%<matcher>s(:perform_later)`.'
+
+        RESTRICT_ON_SEND = %i[receive have_received].to_set
+        RUNNERS = %i[to to_not not_to].freeze
+
+        # @!method receive_perform_later?(node)
+        def_node_matcher :receive_perform_later?, <<~PATTERN
+          (send nil? {:receive :have_received}
+            (sym :perform_later))
+        PATTERN
+
+        # @!method expect_or_allow?(node)
+        def_node_matcher :expect_or_allow?, <<~PATTERN
+          (send nil? {:expect :allow} {const_type? (send nil? :described_class)})
+        PATTERN
+
+        def on_send(node)
+          return unless receive_perform_later?(node)
+          return unless (runner_node = find_runner_node(node))
+          return unless runner_matcher?(node, runner_node)
+
+          register_offense(node, runner_node)
+        end
+
+        private
+
+        def register_offense(matcher_node, runner_node)
+          expect_node = runner_node.receiver
+          return unless expect_or_allow?(expect_node)
+          return if allow_receive_combination?(expect_node, matcher_node)
+
+          job_class = expect_node.first_argument
+          add_offense(runner_node,
+                      message: offense_message(expect_node, job_class,
+                                               runner_node, matcher_node))
+        end
+
+        def allow_receive_combination?(expect_node, matcher_node)
+          expect_node.method?(:allow) && matcher_node.method?(:receive)
+        end
+
+        def offense_message(expect_node, job_class, runner_node, matcher_node)
+          format(MSG,
+                 receiver: expect_node.method_name,
+                 job_class: job_class.source,
+                 runner: runner_node.method_name,
+                 to: runner_node.method_name,
+                 matcher: matcher_node.method_name)
+        end
+
+        def find_runner_node(node)
+          node.each_ancestor(:send).find { |ancestor| runner?(ancestor) }
+        end
+
+        def runner_matcher?(matcher_node, runner_node)
+          node = runner_node.first_argument
+          node = node.receiver while node&.send_type? && node != matcher_node
+          node == matcher_node
+        end
+
+        def runner?(node)
+          RUNNERS.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec_rails/travel_around.rb

@@ -3,15 +3,26 @@
 module RuboCop
   module Cop
     module RSpecRails
-      # Prefer to travel in `before` rather than `around`.
+      # Checks for time travel helpers in `around` hooks.
+      #
+      # In Rails example groups, `freeze_time` in a `before` hook does not need
+      # a block: Rails' `after_teardown` calls `travel_back` after each example.
+      # This also allows an example to use block-form time travel, which Rails
+      # does not allow inside another time travel block.
+      # See https://api.rubyonrails.org/classes/ActiveSupport/Testing/TimeHelpers.html
       #
       # @safety
-      #   This cop is unsafe because the automatic `travel_back` is only run
-      #   on test cases that are considered as Rails related.
+      #   The automatic `travel_back` requires both
+      #   `ActiveSupport::Testing::TimeHelpers` and RSpec Rails' lifecycle
+      #   hooks. RSpec Rails applies those hooks to example groups with Rails
+      #   `type:` metadata. File paths set that metadata only when
+      #   `infer_spec_type_from_file_location!` is enabled. In a plain RSpec
+      #   group that only includes TimeHelpers, use a block or call
+      #   `travel_back` explicitly.
+      #   See https://rspec.info/features/7-1/rspec-rails/directory-structure/
       #
-      #   And also, this cop's autocorrection is unsafe because the order of
-      #   execution will change if other steps exist before traveling in
-      #   `around`.
+      #   Autocorrection can change execution order: `around` starts before
+      #   all `before` hooks, while `before` runs in normal hook order.
       #
       # @example
       #   # bad
@@ -29,7 +40,7 @@ module RuboCop
       #   # good
       #   before { freeze_time }
       #
-      class TravelAround < ::RuboCop::Cop::Base
+      class TravelAround < RuboCop::Cop::Base
         extend AutoCorrector
 
         MSG = 'Prefer to travel in `before` rather than `around`.'
@@ -45,7 +56,7 @@ module RuboCop
           (block
             $(send nil? TRAVEL_METHOD_NAMES ...)
             (args ...)
-            (send _ :run)
+            (send (lvar _) :run)
           )
         PATTERN
 
@@ -64,7 +75,7 @@ module RuboCop
           )
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
           extract_run_in_travel(node) do |run_node|
             run_in_travel(node, run_node)
           end
@@ -76,26 +87,30 @@ module RuboCop
 
         private
 
-        def run_in_travel(node, run_node)
-          around_node = extract_surrounding_around_block(run_node)
+        def run_in_travel(node, travel_node)
+          around_node = extract_surrounding_around_block(node)
           return unless around_node
+          return unless matching_run_receiver?(node.body, around_node)
 
           add_offense(node) do |corrector|
             corrector.replace(node, node.body.source)
-            corrector.insert_before(around_node,
-                                    "before { #{run_node.source} }\n\n")
+            corrector.insert_before(
+              around_node,
+              "before { #{travel_node.source} }\n\n#{indent(around_node)}"
+            )
           end
         end
 
         def travel_with_block_pass(node, lvar)
           around_node = extract_surrounding_around_block(node)
           return unless around_node
+          return unless lvar.name == around_argument_name(around_node)
 
           add_offense(node) do |corrector|
             corrector.replace(node, "#{lvar.name}.run")
             corrector.insert_before(
               around_node,
-              "before { #{node.method_name} }\n\n"
+              "before { #{node.method_name} }\n\n#{indent(around_node)}"
             )
           end
         end
@@ -104,9 +119,23 @@ module RuboCop
         # @return [RuboCop::AST::BlockNode, nil]
         def extract_surrounding_around_block(node)
           node.each_ancestor(:block).find do |ancestor|
-            match_around_each?(ancestor)
+            match_around_each?(ancestor) &&
+              direct_child_of_around_body?(node, ancestor)
           end
         end
+
+        def direct_child_of_around_body?(node, around_node)
+          node.parent == around_node ||
+            (node.parent.begin_type? && node.parent.parent == around_node)
+        end
+
+        def matching_run_receiver?(run_node, around_node)
+          run_node.receiver.children.first == around_argument_name(around_node)
+        end
+
+        def around_argument_name(around_node)
+          around_node.first_argument&.name
+        end
       end
     end
   end

data/lib/rubocop/cop/rspec_rails.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `RSpecRails` department. The department's cops are
+    # registered for lazy loading and their files are loaded on demand.
+    module RSpecRails
+      extend LazyLoader
+
+      register_cop :AvoidSetupHook, "#{__dir__}/rspec_rails/avoid_setup_hook"
+      register_cop :FileFixture, "#{__dir__}/rspec_rails/file_fixture"
+      register_cop :HaveHttpStatus, "#{__dir__}/rspec_rails/have_http_status"
+      register_cop :HttpStatus, "#{__dir__}/rspec_rails/http_status"
+      register_cop :HttpStatusNameConsistency, "#{__dir__}/rspec_rails/http_status_name_consistency"
+      register_cop :InferredSpecType, "#{__dir__}/rspec_rails/inferred_spec_type"
+      register_cop :MinitestAssertions, "#{__dir__}/rspec_rails/minitest_assertions"
+      register_cop :NegationBeValid, "#{__dir__}/rspec_rails/negation_be_valid"
+      register_cop :ReceivePerformLater, "#{__dir__}/rspec_rails/receive_perform_later"
+      register_cop :TravelAround, "#{__dir__}/rspec_rails/travel_around"
+    end
+  end
+end

data/lib/rubocop/cop/rspec_rails_cops.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'rspec_rails/avoid_setup_hook'
-require_relative 'rspec_rails/have_http_status'
-require_relative 'rspec_rails/http_status'
-require_relative 'rspec_rails/http_status_name_consistency'
-require_relative 'rspec_rails/inferred_spec_type'
-require_relative 'rspec_rails/minitest_assertions'
-require_relative 'rspec_rails/negation_be_valid'
-require_relative 'rspec_rails/travel_around'
+# @deprecated This file is deprecated. Cops are registered for lazy loading in
+#   `rubocop/cop/rspec_rails`; this file is kept for compatibility with code
+#   that requires it directly.
+require_relative 'rspec_rails'

data/lib/rubocop/rspec_rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpecRails
     # Version information for the RSpec Rails RuboCop plugin.
     module Version
-      STRING = '2.32.0'
+      STRING = '2.33.0'
     end
   end
 end

data/lib/rubocop-rspec_rails.rb

@@ -10,4 +10,4 @@ require_relative 'rubocop/rspec_rails/plugin'
 require_relative 'rubocop/rspec_rails/version'
 
 require 'rubocop/cop/rspec/base'
-require_relative 'rubocop/cop/rspec_rails_cops'
+require_relative 'rubocop/cop/rspec_rails'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec_rails
 version: !ruby/object:Gem::Version
-  version: 2.32.0
+  version: 2.33.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -32,20 +32,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: '1.89'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: '1.89'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -75,13 +69,16 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-rspec_rails.rb
+- lib/rubocop/cop/rspec_rails.rb
 - lib/rubocop/cop/rspec_rails/avoid_setup_hook.rb
+- lib/rubocop/cop/rspec_rails/file_fixture.rb
 - lib/rubocop/cop/rspec_rails/have_http_status.rb
 - lib/rubocop/cop/rspec_rails/http_status.rb
 - lib/rubocop/cop/rspec_rails/http_status_name_consistency.rb
 - lib/rubocop/cop/rspec_rails/inferred_spec_type.rb
 - lib/rubocop/cop/rspec_rails/minitest_assertions.rb
 - lib/rubocop/cop/rspec_rails/negation_be_valid.rb
+- lib/rubocop/cop/rspec_rails/receive_perform_later.rb
 - lib/rubocop/cop/rspec_rails/travel_around.rb
 - lib/rubocop/cop/rspec_rails_cops.rb
 - lib/rubocop/rspec_rails/config_formatter.rb
@@ -111,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Code style checking for RSpec Rails files
 test_files: []