rubocop-rspec 2.25.0 → 2.27.1

data/lib/rubocop/cop/rspec/rails/minitest_assertions.rb

@@ -4,54 +4,346 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Check if using Minitest matchers.
+        # Check if using Minitest-like matchers.
+        #
+        # Check the use of minitest-like matchers
+        # starting with `assert_` or `refute_`.
         #
         # @example
         #   # bad
         #   assert_equal(a, b)
         #   assert_equal a, b, "must be equal"
+        #   assert_not_includes a, b
         #   refute_equal(a, b)
+        #   assert_nil a
+        #   refute_empty(b)
+        #   assert_true(a)
+        #   assert_false(a)
         #
         #   # good
         #   expect(b).to eq(a)
         #   expect(b).to(eq(a), "must be equal")
+        #   expect(a).not_to include(b)
         #   expect(b).not_to eq(a)
+        #   expect(a).to eq(nil)
+        #   expect(a).not_to be_empty
+        #   expect(a).to be(true)
+        #   expect(a).to be(false)
         #
         class MinitestAssertions < Base
           extend AutoCorrector
 
+          # :nodoc:
+          class BasicAssertion
+            extend NodePattern::Macros
+
+            attr_reader :expected, :actual, :failure_message
+
+            def self.minitest_assertion
+              raise NotImplementedError
+            end
+
+            def initialize(expected, actual, failure_message)
+              @expected = expected&.source
+              @actual = actual.source
+              @failure_message = failure_message&.source
+            end
+
+            def replaced(node)
+              runner = negated?(node) ? 'not_to' : 'to'
+              if failure_message.nil?
+                "expect(#{actual}).#{runner} #{assertion}"
+              else
+                "expect(#{actual}).#{runner}(#{assertion}, #{failure_message})"
+              end
+            end
+
+            def negated?(node)
+              node.method_name.start_with?('assert_not_', 'refute_')
+            end
+
+            def assertion
+              raise NotImplementedError
+            end
+          end
+
+          # :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
+
+            def assertion
+              "eq(#{expected})"
+            end
+          end
+
+          # :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
+
+            def assertion
+              "be_a_kind_of(#{expected})"
+            end
+          end
+
+          # :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
+
+            def assertion
+              "be_an_instance_of(#{expected})"
+            end
+          end
+
+          # :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
+
+            def self.match(collection, expected, failure_message)
+              new(expected, collection, failure_message.first)
+            end
+
+            def assertion
+              "include(#{expected})"
+            end
+          end
+
+          # :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
+
+            def self.match(expected, actual, delta, failure_message)
+              new(expected, actual, delta.first, failure_message.first)
+            end
+
+            def initialize(expected, actual, delta, fail_message)
+              super(expected, actual, fail_message)
+
+              @delta = delta&.source || '0.001'
+            end
+
+            def assertion
+              "be_within(#{@delta}).of(#{expected})"
+            end
+          end
+
+          # :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
+
+            def self.match(subject, predicate, failure_message)
+              return nil unless predicate.value.end_with?('?')
+
+              new(predicate, subject, failure_message.first)
+            end
+
+            def assertion
+              "be_#{expected.delete_prefix(':').delete_suffix('?')}"
+            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
+
+            def assertion
+              "match(#{expected})"
+            end
+          end
+
+          # :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
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'eq(nil)'
+            end
+          end
+
+          # :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
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be_empty'
+            end
+          end
+
+          # :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
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be(true)'
+            end
+          end
+
+          # :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
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be(false)'
+            end
+          end
+
           MSG = 'Use `%<prefer>s`.'
-          RESTRICT_ON_SEND = %i[assert_equal refute_equal].freeze
 
-          # @!method minitest_assertion(node)
-          def_node_matcher :minitest_assertion, <<-PATTERN
-          (send nil? {:assert_equal :refute_equal} $_ $_ $_?)
-          PATTERN
+          # TODO: replace with `BasicAssertion.subclasses` in Ruby 3.1+
+          ASSERTION_MATCHERS = constants(false).filter_map do |c|
+            const = const_get(c)
+
+            const if const.is_a?(Class) && const.superclass == BasicAssertion
+          end
+
+          RESTRICT_ON_SEND = ASSERTION_MATCHERS.flat_map { |m| m::MATCHERS }
 
           def on_send(node)
-            minitest_assertion(node) do |expected, actual, failure_message|
-              prefer = replacement(node, expected, actual,
-                                   failure_message.first)
-              add_offense(node, message: message(prefer)) do |corrector|
-                corrector.replace(node, prefer)
+            ASSERTION_MATCHERS.each do |m|
+              m.minitest_assertion(node) do |*args|
+                assertion = m.match(*args)
+
+                next if assertion.nil?
+
+                on_assertion(node, assertion)
               end
             end
           end
 
-          private
-
-          def replacement(node, expected, actual, failure_message)
-            runner = node.method?(:assert_equal) ? 'to' : 'not_to'
-            if failure_message.nil?
-              "expect(#{actual.source}).#{runner} eq(#{expected.source})"
-            else
-              "expect(#{actual.source}).#{runner}(eq(#{expected.source}), " \
-                "#{failure_message.source})"
+          def on_assertion(node, assertion)
+            preferred = assertion.replaced(node)
+            add_offense(node, message: message(preferred)) do |corrector|
+              corrector.replace(node, preferred)
             end
           end
 
-          def message(prefer)
-            format(MSG, prefer: prefer)
+          def message(preferred)
+            format(MSG, prefer: preferred)
           end
         end
       end

data/lib/rubocop/cop/rspec/receive_counts.rb

@@ -30,7 +30,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[times].freeze
 
         # @!method receive_counts(node)
-        def_node_matcher :receive_counts, <<-PATTERN
+        def_node_matcher :receive_counts, <<~PATTERN
           (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
         PATTERN
 

data/lib/rubocop/cop/rspec/receive_messages.rb

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def heredoc_or_splat?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc? ||
+          ((node.str_type? || node.dstr_type?) && node.heredoc?) ||
             node.splat_type?
         end
 

data/lib/rubocop/cop/rspec/redundant_predicate_matcher.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for redundant predicate matcher.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be_exist(bar)
+      #   expect(foo).not_to be_include(bar)
+      #   expect(foo).to be_all(bar)
+      #
+      #   # good
+      #   expect(foo).to exist(bar)
+      #   expect(foo).not_to include(bar)
+      #   expect(foo).to all be(bar)
+      #
+      class RedundantPredicateMatcher < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND =
+          %i[be_all be_cover be_end_with be_eql be_equal
+             be_exist be_exists be_include be_match
+             be_respond_to be_start_with].freeze
+
+        def on_send(node)
+          return if node.parent.block_type? || node.arguments.empty?
+          return unless replaceable_arguments?(node)
+
+          method_name = node.method_name.to_s
+          replaced = replaced_method_name(method_name)
+          add_offense(node, message: message(method_name,
+                                             replaced)) do |corrector|
+            unless node.method?(:be_all)
+              corrector.replace(node.loc.selector, replaced)
+            end
+          end
+        end
+
+        private
+
+        def message(bad_method, good_method)
+          format(MSG, bad: bad_method, good: good_method)
+        end
+
+        def replaceable_arguments?(node)
+          if node.method?(:be_all)
+            node.first_argument.send_type?
+          else
+            true
+          end
+        end
+
+        def replaced_method_name(method_name)
+          name = method_name.to_s.delete_prefix('be_')
+          if name == 'exists'
+            'exist'
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/remove_const.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that `remove_const` is not used in specs.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     Object.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      #   before do
+      #     SomeClass.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      class RemoveConst < Base
+        include RuboCop::RSpec::Language
+        extend RuboCop::RSpec::Language::NodePattern
+
+        MSG = 'Do not use remove_const in specs. ' \
+              'Consider using e.g. `stub_const`.'
+        RESTRICT_ON_SEND = %i[send __send__].freeze
+
+        # @!method remove_const(node)
+        def_node_matcher :remove_const, <<~PATTERN
+          (send _ {:send | :__send__} (sym :remove_const) _)
+        PATTERN
+
+        # Check for offenses
+        def on_send(node)
+          remove_const(node) do
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/repeated_example_group_body.rb

@@ -48,7 +48,7 @@ module RuboCop
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group_with_body? #example_group_with_body? ...>)
         PATTERN
 

data/lib/rubocop/cop/rspec/repeated_example_group_description.rb

@@ -48,12 +48,12 @@ module RuboCop
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group? #example_group? ...>)
         PATTERN
 
         # @!method doc_string_and_metadata(node)
-        def_node_matcher :doc_string_and_metadata, <<-PATTERN
+        def_node_matcher :doc_string_and_metadata, <<~PATTERN
           (block (send _ _ $_ $...) ...)
         PATTERN
 

data/lib/rubocop/cop/rspec/repeated_include_example.rb

@@ -50,7 +50,7 @@ module RuboCop
               'on line(s) %<repeat>s'
 
         # @!method several_include_examples?(node)
-        def_node_matcher :several_include_examples?, <<-PATTERN
+        def_node_matcher :several_include_examples?, <<~PATTERN
           (begin <#include_examples? #include_examples? ...>)
         PATTERN
 

data/lib/rubocop/cop/rspec/repeated_subject_call.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for repeated calls to subject missing that it is memoized.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     subject
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   it do
+      #     expect { subject }.to change { A.count }
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect { my_method }.to change { A.count }
+      #     expect { my_method }.to not_change { A.count }
+      #   end
+      #
+      #   # also good
+      #   it do
+      #     expect { subject.a }.to change { A.count }
+      #     expect { subject.b }.to not_change { A.count }
+      #   end
+      #
+      class RepeatedSubjectCall < Base
+        include TopLevelGroup
+
+        MSG = 'Calls to subject are memoized, this block is misleading'
+
+        # @!method subject?(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject?(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method subject_calls(node, method_name)
+        def_node_search :subject_calls, <<~PATTERN
+          (send nil? %)
+        PATTERN
+
+        def on_top_level_group(node)
+          @subjects_by_node = detect_subjects_in_scope(node)
+
+          detect_offenses_in_block(node)
+        end
+
+        private
+
+        def detect_offense(subject_node)
+          return if subject_node.chained?
+          return unless (block_node = expect_block(subject_node))
+
+          add_offense(block_node)
+        end
+
+        def expect_block(node)
+          node.each_ancestor(:block).find { |block| block.method?(:expect) }
+        end
+
+        def detect_offenses_in_block(node, subject_names = [])
+          subject_names = [*subject_names, *@subjects_by_node[node]]
+
+          if example?(node)
+            return detect_offenses_in_example(node, subject_names)
+          end
+
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            detect_offenses_in_block(child, subject_names)
+          end
+        end
+
+        def detect_offenses_in_example(node, subject_names)
+          return unless node.body
+
+          subjects_used = Hash.new(false)
+
+          subject_calls(node.body, Set[*subject_names, :subject]).each do |call|
+            if subjects_used[call.method_name]
+              detect_offense(call)
+            else
+              subjects_used[call.method_name] = true
+            end
+          end
+        end
+
+        def detect_subjects_in_scope(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            subject?(child) do |name|
+              outer_example_group = child.each_ancestor(:block).find do |a|
+                example_group?(a)
+              end
+
+              (h[outer_example_group] ||= []) << name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/return_from_stub.rb

@@ -48,7 +48,7 @@ module RuboCop
         def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
 
         # @!method and_return_value(node)
-        def_node_search :and_return_value, <<-PATTERN
+        def_node_search :and_return_value, <<~PATTERN
           $(send _ :and_return $(...))
         PATTERN
 

data/lib/rubocop/cop/rspec/shared_context.rb

@@ -62,7 +62,7 @@ module RuboCop
         PATTERN
 
         # @!method context?(node)
-        def_node_search :context?, <<-PATTERN
+        def_node_search :context?, <<~PATTERN
           (send nil?
             {#Subjects.all #Helpers.all #Includes.context #Hooks.all} ...
           )