rubocop-rspec 2.22.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/rails/negation_be_valid.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Enforces use of `be_invalid` or `not_to` for negated be_valid.
+        #
+        # @safety
+        #   This cop is unsafe because it cannot guarantee that
+        #   the test target is an instance of `ActiveModel::Validations``.
+        #
+        # @example EnforcedStyle: not_to (default)
+        #   # bad
+        #   expect(foo).to be_invalid
+        #
+        #   # good
+        #   expect(foo).not_to be_valid
+        #
+        #   # good (with method chain)
+        #   expect(foo).to be_invalid.and be_odd
+        #
+        # @example EnforcedStyle: be_invalid
+        #   # bad
+        #   expect(foo).not_to be_valid
+        #
+        #   # good
+        #   expect(foo).to be_invalid
+        #
+        #   # good (with method chain)
+        #   expect(foo).to be_invalid.or be_even
+        #
+        class NegationBeValid < Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+
+          MSG = 'Use `expect(...).%<runner>s %<matcher>s`.'
+          RESTRICT_ON_SEND = %i[be_valid be_invalid].freeze
+
+          # @!method not_to?(node)
+          def_node_matcher :not_to?, <<~PATTERN
+            (send ... :not_to (send nil? :be_valid ...))
+          PATTERN
+
+          # @!method be_invalid?(node)
+          def_node_matcher :be_invalid?, <<~PATTERN
+            (send ... :to (send nil? :be_invalid ...))
+          PATTERN
+
+          def on_send(node)
+            return unless offense?(node.parent)
+
+            add_offense(offense_range(node),
+                        message: message(node.method_name)) do |corrector|
+              corrector.replace(node.parent.loc.selector, replaced_runner)
+              corrector.replace(node.loc.selector, replaced_matcher)
+            end
+          end
+
+          private
+
+          def offense?(node)
+            case style
+            when :not_to
+              be_invalid?(node)
+            when :be_invalid
+              not_to?(node)
+            end
+          end
+
+          def offense_range(node)
+            node.parent.loc.selector.with(end_pos: node.loc.selector.end_pos)
+          end
+
+          def message(_matcher)
+            format(MSG,
+                   runner: replaced_runner,
+                   matcher: replaced_matcher)
+          end
+
+          def replaced_runner
+            case style
+            when :not_to
+              'not_to'
+            when :be_invalid
+              'to'
+            end
+          end
+
+          def replaced_matcher
+            case style
+            when :not_to
+              'be_valid'
+            when :be_invalid
+              'be_invalid'
+            end
+          end
+        end
+      end
+    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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for multiple messages stubbed on the same object.
+      #
+      # @safety
+      #   The autocorrection is marked as unsafe, because it may change the
+      #   order of stubs. This in turn may cause e.g. variables to be called
+      #   before they are defined.
+      #
+      # @example
+      #   # bad
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:baz).and_return(qux)
+      #   end
+      #
+      #   # good
+      #   before do
+      #     allow(Service).to receive_messages(foo: bar, baz: qux)
+      #   end
+      #
+      #   # good - ignore same message
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:foo).and_return(qux)
+      #   end
+      #
+      class ReceiveMessages < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `receive_messages` instead of multiple stubs on lines ' \
+              '%<loc>s.'
+
+        # @!method allow_receive_message?(node)
+        def_node_matcher :allow_receive_message?, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym _)) :and_return !#heredoc_or_splat?))
+        PATTERN
+
+        # @!method allow_argument(node)
+        def_node_matcher :allow_argument, <<~PATTERN
+          (send (send nil? :allow $_ ...) ...)
+        PATTERN
+
+        # @!method receive_node(node)
+        def_node_search :receive_node, <<~PATTERN
+          $(send (send nil? :receive ...) ...)
+        PATTERN
+
+        # @!method receive_arg(node)
+        def_node_search :receive_arg, <<~PATTERN
+          (send (send nil? :receive $_) ...)
+        PATTERN
+
+        # @!method receive_and_return_argument(node)
+        def_node_matcher :receive_and_return_argument, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym $_)) :and_return $_))
+        PATTERN
+
+        def on_begin(node)
+          repeated_receive_message(node).each do |item, repeated_lines, args|
+            next if repeated_lines.empty?
+
+            register_offense(item, repeated_lines, args)
+          end
+        end
+
+        private
+
+        def repeated_receive_message(node)
+          node
+            .children
+            .select { |child| allow_receive_message?(child) }
+            .group_by { |child| allow_argument(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines_and_arguments(items) }
+        end
+
+        def add_repeated_lines_and_arguments(items)
+          uniq_items = uniq_items(items)
+          repeated_lines = uniq_items.map(&:first_line)
+          uniq_items.map do |item|
+            [item, repeated_lines - [item.first_line], arguments(uniq_items)]
+          end
+        end
+
+        def uniq_items(items)
+          items.select do |item|
+            items.none? do |i|
+              receive_arg(item).first == receive_arg(i).first &&
+                !same_line?(item, i)
+            end
+          end
+        end
+
+        def arguments(items)
+          items.map do |item|
+            receive_and_return_argument(item) do |receive_arg, return_arg|
+              "#{normalize_receive_arg(receive_arg)}: " \
+                "#{normalize_return_arg(return_arg)}"
+            end
+          end
+        end
+
+        def normalize_receive_arg(receive_arg)
+          if requires_quotes?(receive_arg)
+            "'#{receive_arg}'"
+          else
+            receive_arg
+          end
+        end
+
+        def normalize_return_arg(return_arg)
+          if return_arg.hash_type? && !return_arg.braces?
+            "{ #{return_arg.source} }"
+          else
+            return_arg.source
+          end
+        end
+
+        def register_offense(item, repeated_lines, args)
+          add_offense(item, message: message(repeated_lines)) do |corrector|
+            if item.loc.line > repeated_lines.max
+              replace_to_receive_messages(corrector, item, args)
+            else
+              corrector.remove(item_range_by_whole_lines(item))
+            end
+          end
+        end
+
+        def message(repeated_lines)
+          format(MSG, loc: repeated_lines)
+        end
+
+        def replace_to_receive_messages(corrector, item, args)
+          receive_node(item) do |node|
+            corrector.replace(node,
+                              "receive_messages(#{args.join(', ')})")
+          end
+        end
+
+        def item_range_by_whole_lines(item)
+          range_by_whole_lines(item.source_range, include_final_newline: true)
+        end
+
+        def heredoc_or_splat?(node)
+          ((node.str_type? || node.dstr_type?) && node.heredoc?) ||
+            node.splat_type?
+        end
+
+        def requires_quotes?(value)
+          value.match?(/^:".*?"|=$|^\W+$/)
+        end
+      end
+    end
+  end
+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