rubocop-rspec 2.16.0 → 2.24.1

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

@@ -74,7 +74,7 @@ module RuboCop
             name[0..-2]
           when 'exist?', 'exists?'
             'exist'
-          when /^has_/
+          when /\Ahas_/
             name.sub('has_', 'have_')[0..-2]
           else
             "be_#{name[0..-2]}"
@@ -84,22 +84,22 @@ module RuboCop
 
         def remove_predicate(corrector, predicate)
           range = predicate.loc.dot.with(
-            end_pos: predicate.loc.expression.end_pos
+            end_pos: predicate.source_range.end_pos
           )
 
           corrector.remove(range)
 
-          block_range = block_loc(predicate)
+          block_range = LocationHelp.block_with_whitespace(predicate)
           corrector.remove(block_range) if block_range
         end
 
         def rewrite_matcher(corrector, predicate, matcher)
-          args = args_loc(predicate).source
-          block_loc = block_loc(predicate)
+          args = LocationHelp.arguments_with_whitespace(predicate).source
+          block_loc = LocationHelp.block_with_whitespace(predicate)
           block = block_loc ? block_loc.source : ''
 
           corrector.replace(
-            matcher.loc.expression,
+            matcher,
             to_predicate_matcher(predicate.method_name) + args + block
           )
         end
@@ -118,7 +118,7 @@ module RuboCop
       end
 
       # A helper for `explicit` style
-      module ExplicitHelper
+      module ExplicitHelper # rubocop:disable Metrics/ModuleLength
         include RuboCop::RSpec::Language
         extend NodePattern::Macros
 
@@ -149,12 +149,35 @@ module RuboCop
           return if part_of_ignored_node?(node)
 
           predicate_matcher?(node) do |actual, matcher|
+            next unless replaceable_matcher?(matcher)
+
             add_offense(node, message: message_explicit(matcher)) do |corrector|
+              next if uncorrectable_matcher?(node, matcher)
+
               corrector_explicit(corrector, node, actual, matcher, matcher)
             end
           end
         end
 
+        def replaceable_matcher?(matcher)
+          case matcher.method_name.to_s
+          when 'include'
+            matcher.arguments.one?
+          else
+            true
+          end
+        end
+
+        def uncorrectable_matcher?(node, matcher)
+          heredoc_argument?(matcher) && !same_line?(node, matcher)
+        end
+
+        def heredoc_argument?(matcher)
+          matcher.arguments.select do |arg|
+            %i[str dstr xstr].include?(arg.type)
+          end.any?(&:heredoc?)
+        end
+
         # @!method predicate_matcher?(node)
         def_node_matcher :predicate_matcher?, <<-PATTERN
           (send
@@ -179,7 +202,8 @@ module RuboCop
 
           return false if allowed_explicit_matchers.include?(name)
 
-          name.start_with?('be_', 'have_') && !name.end_with?('?')
+          name.start_with?('be_', 'have_') && !name.end_with?('?') ||
+            %w[include respond_to].include?(name)
         end
 
         def message_explicit(matcher)
@@ -190,20 +214,19 @@ module RuboCop
 
         def corrector_explicit(corrector, to_node, actual, matcher, block_child)
           replacement_matcher = replacement_matcher(to_node)
-          corrector.replace(matcher.loc.expression, replacement_matcher)
+          corrector.replace(matcher, replacement_matcher)
           move_predicate(corrector, actual, matcher, block_child)
           corrector.replace(to_node.loc.selector, 'to')
         end
 
         def move_predicate(corrector, actual, matcher, block_child)
           predicate = to_predicate_method(matcher.method_name)
-          args = args_loc(matcher).source
-          block_loc = block_loc(block_child)
+          args = LocationHelp.arguments_with_whitespace(matcher).source
+          block_loc = LocationHelp.block_with_whitespace(block_child)
           block = block_loc ? block_loc.source : ''
 
           corrector.remove(block_loc) if block_loc
-          corrector.insert_after(actual.loc.expression,
-                                 ".#{predicate}" + args + block)
+          corrector.insert_after(actual, ".#{predicate}" + args + block)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -217,10 +240,10 @@ module RuboCop
             'include?'
           when 'respond_to'
             'respond_to?'
-          when /^have_(.+)/
+          when /\Ahave_(.+)/
             "has_#{Regexp.last_match(1)}?"
           else
-            "#{matcher[/^be_(.+)/, 1]}?"
+            "#{matcher[/\Abe_(.+)/, 1]}?"
           end
         end
         # rubocop:enable Metrics/MethodLength
@@ -270,6 +293,17 @@ module RuboCop
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be(true)
       #
+      #   # bad - no autocorrect
+      #   expect(foo)
+      #     .to be_something(<<~TEXT)
+      #       bar
+      #     TEXT
+      #
+      #   # good
+      #   expect(foo.something?(<<~TEXT)).to be(true)
+      #     bar
+      #   TEXT
+      #
       # @example Strict: false, EnforcedStyle: explicit
       #   # bad
       #   expect(foo).to be_something
@@ -297,31 +331,6 @@ module RuboCop
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check_explicit(node) if style == :explicit
         end
-
-        private
-
-        # returns args location with whitespace
-        # @example
-        #   foo 1, 2
-        #      ^^^^^
-        def args_loc(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
-
-        # returns block location with whitespace
-        # @example
-        #   foo { bar }
-        #      ^^^^^^^^
-        def block_loc(send_node)
-          parent = send_node.parent
-          return unless parent.block_type?
-
-          send_node.loc.expression.end.with(
-            end_pos: parent.loc.expression.end_pos
-          )
-        end
       end
     end
   end

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

@@ -9,6 +9,7 @@ module RuboCop
         # @example
         #   # bad
         #   expect(response.status).to be(200)
+        #   expect(response.code).to eq("200")
         #
         #   # good
         #   expect(response).to have_http_status(200)
@@ -17,8 +18,8 @@ module RuboCop
           extend AutoCorrector
 
           MSG =
-            'Prefer `expect(response).%<to>s have_http_status(%<status>i)` ' \
-            'over `expect(response.status).%<to>s %<match>s`.'
+            'Prefer `expect(response).%<to>s have_http_status(%<status>s)` ' \
+            'over `%<bad_code>s`.'
 
           RUNNERS = %i[to to_not not_to].to_set
           RESTRICT_ON_SEND = RUNNERS
@@ -27,19 +28,23 @@ module RuboCop
           def_node_matcher :match_status, <<-PATTERN
             (send
               (send nil? :expect
-                $(send (send nil? :response) :status)
+                $(send (send nil? :response) {:status :code})
               )
               $RUNNERS
-              $(send nil? {:be :eq :eql :equal} (int $_))
+              $(send nil? {:be :eq :eql :equal} ({int str} $_))
             )
           PATTERN
 
           def on_send(node)
             match_status(node) do |response_status, to, match, status|
-              message = format(MSG, to: to, match: match.source, status: status)
+              return unless status.to_s.match?(/\A\d+\z/)
+
+              message = format(MSG, to: to, status: status,
+                                    bad_code: node.source)
               add_offense(node, message: message) do |corrector|
-                corrector.replace(response_status.source_range, 'response')
+                corrector.replace(response_status, 'response')
                 corrector.replace(match.loc.selector, 'have_http_status')
+                corrector.replace(match.first_argument, status.to_s)
               end
             end
           end

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

@@ -8,14 +8,21 @@ module RuboCop
       module Rails
         # Enforces use of symbolic or numeric value to describe HTTP status.
         #
+        # This cop inspects only `have_http_status` calls.
+        # So, this cop does not check if a method starting with `be_*` is used
+        # when setting for `EnforcedStyle: symbolic` or
+        # `EnforcedStyle: numeric`.
+        #
         # @example `EnforcedStyle: symbolic` (default)
         #   # bad
         #   it { is_expected.to have_http_status 200 }
         #   it { is_expected.to have_http_status 404 }
+        #   it { is_expected.to have_http_status "403" }
         #
         #   # good
         #   it { is_expected.to have_http_status :ok }
         #   it { is_expected.to have_http_status :not_found }
+        #   it { is_expected.to have_http_status :forbidden }
         #   it { is_expected.to have_http_status :success }
         #   it { is_expected.to have_http_status :error }
         #
@@ -23,10 +30,27 @@ module RuboCop
         #   # bad
         #   it { is_expected.to have_http_status :ok }
         #   it { is_expected.to have_http_status :not_found }
+        #   it { is_expected.to have_http_status "forbidden" }
         #
         #   # good
         #   it { is_expected.to have_http_status 200 }
         #   it { is_expected.to have_http_status 404 }
+        #   it { is_expected.to have_http_status 403 }
+        #   it { is_expected.to have_http_status :success }
+        #   it { is_expected.to have_http_status :error }
+        #
+        # @example `EnforcedStyle: be_status`
+        #   # bad
+        #   it { is_expected.to have_http_status :ok }
+        #   it { is_expected.to have_http_status :not_found }
+        #   it { is_expected.to have_http_status "forbidden" }
+        #   it { is_expected.to have_http_status 200 }
+        #   it { is_expected.to have_http_status 404 }
+        #   it { is_expected.to have_http_status "403" }
+        #
+        #   # good
+        #   it { is_expected.to be_ok }
+        #   it { is_expected.to be_not_found }
         #   it { is_expected.to have_http_status :success }
         #   it { is_expected.to have_http_status :error }
         #
@@ -37,16 +61,17 @@ module RuboCop
 
           # @!method http_status(node)
           def_node_matcher :http_status, <<-PATTERN
-            (send nil? :have_http_status ${int sym})
+            (send nil? :have_http_status ${int sym str})
           PATTERN
 
           def on_send(node)
-            http_status(node) do |ast_node|
-              checker = checker_class.new(ast_node)
+            http_status(node) do |arg|
+              checker = checker_class.new(arg)
               return unless checker.offensive?
 
-              add_offense(checker.node, message: checker.message) do |corrector|
-                corrector.replace(checker.node, checker.preferred_style)
+              add_offense(checker.offense_range,
+                          message: checker.message) do |corrector|
+                corrector.replace(checker.offense_range, checker.prefer)
               end
             end
           end
@@ -59,13 +84,16 @@ module RuboCop
               SymbolicStyleChecker
             when :numeric
               NumericStyleChecker
+            when :be_status
+              BeStatusStyleChecker
             end
           end
 
           # :nodoc:
-          class SymbolicStyleChecker
+          class StyleCheckerBase
             MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
                   'to describe HTTP status code.'
+            ALLOWED_STATUSES = %i[error success missing redirect].freeze
 
             attr_reader :node
 
@@ -73,16 +101,36 @@ module RuboCop
               @node = node
             end
 
+            def message
+              format(MSG, prefer: prefer, current: current)
+            end
+
+            def offense_range
+              node
+            end
+
+            def allowed_symbol?
+              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
+            end
+
+            def custom_http_status_code?
+              node.int_type? &&
+                !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
+            end
+          end
+
+          # :nodoc:
+          class SymbolicStyleChecker < StyleCheckerBase
             def offensive?
               !node.sym_type? && !custom_http_status_code?
             end
 
-            def message
-              format(MSG, prefer: preferred_style, current: number.to_s)
+            def prefer
+              symbol.inspect
             end
 
-            def preferred_style
-              symbol.inspect
+            def current
+              node.value.inspect
             end
 
             private
@@ -92,52 +140,77 @@ module RuboCop
             end
 
             def number
-              node.source.to_i
-            end
-
-            def custom_http_status_code?
-              node.int_type? &&
-                !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
+              node.source.delete('"').to_i
             end
           end
 
           # :nodoc:
-          class NumericStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
+          class NumericStyleChecker < StyleCheckerBase
+            def offensive?
+              !node.int_type? && !allowed_symbol?
+            end
 
-            ALLOWED_STATUSES = %i[error success missing redirect].freeze
+            def prefer
+              number.to_s
+            end
 
-            attr_reader :node
+            def current
+              symbol.inspect
+            end
 
-            def initialize(node)
-              @node = node
+            private
+
+            def symbol
+              node.value
             end
 
+            def number
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol.to_sym]
+            end
+          end
+
+          # :nodoc:
+          class BeStatusStyleChecker < StyleCheckerBase
             def offensive?
-              !node.int_type? && !allowed_symbol?
+              (!node.sym_type? && !custom_http_status_code?) ||
+                (!node.int_type? && !allowed_symbol?)
             end
 
-            def message
-              format(MSG, prefer: preferred_style, current: symbol.inspect)
+            def offense_range
+              node.parent
             end
 
-            def preferred_style
-              number.to_s
+            def prefer
+              if node.sym_type?
+                "be_#{node.value}"
+              elsif node.int_type?
+                "be_#{symbol}"
+              elsif node.str_type?
+                "be_#{normalize_str}"
+              end
+            end
+
+            def current
+              offense_range.source
             end
 
             private
 
-            def number
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
+            def symbol
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
             end
 
-            def symbol
-              node.value
+            def number
+              node.source.to_i
             end
 
-            def allowed_symbol?
-              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
+            def normalize_str
+              normalized = node.source.delete('"')
+              if normalized.match?(/\A\d+\z/)
+                ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(normalized.to_i)
+              else
+                normalized
+              end
             end
           end
         end

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

@@ -96,12 +96,12 @@ module RuboCop
           # @return [Parser::Source::Range]
           def remove_range(node)
             if node.left_sibling
-              node.loc.expression.with(
-                begin_pos: node.left_sibling.loc.expression.end_pos
+              node.source_range.with(
+                begin_pos: node.left_sibling.source_range.end_pos
               )
             elsif node.right_sibling
-              node.loc.expression.with(
-                end_pos: node.right_sibling.loc.expression.begin_pos
+              node.source_range.with(
+                end_pos: node.right_sibling.source_range.begin_pos
               )
             end
           end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Check if using Minitest matchers.
+        #
+        # @example
+        #   # bad
+        #   assert_equal(a, b)
+        #   assert_equal a, b, "must be equal"
+        #   refute_equal(a, b)
+        #
+        #   # good
+        #   expect(b).to eq(a)
+        #   expect(b).to(eq(a), "must be equal")
+        #   expect(b).not_to eq(a)
+        #
+        class MinitestAssertions < Base
+          extend AutoCorrector
+
+          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
+
+          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)
+              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})"
+            end
+          end
+
+          def message(prefer)
+            format(MSG, prefer: prefer)
+          end
+        end
+      end
+    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