rubocop-rspec 2.22.0 → 2.25.0

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

@@ -8,6 +8,9 @@ module RuboCop
       # It makes reading the test harder because it's not clear what exactly
       # is tested by this particular example.
       #
+      # The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+      # will also read those set in `Naming/VariableNumber`.
+      #
       # @example `Max: 1 (default)`
       #   # bad
       #   let(:item_1) { create(:item) }
@@ -31,7 +34,20 @@ module RuboCop
       #   let(:item_1) { create(:item) }
       #   let(:item_2) { create(:item) }
       #
+      # @example `AllowedIdentifiers: ['item_1', 'item_2']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedPatterns: ['item']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
       class IndexedLet < Base
+        include AllowedIdentifiers
+        include AllowedPattern
+
         MSG = 'This `let` statement uses index in its name. Please give it ' \
               'a meaningful name.'
 
@@ -69,12 +85,27 @@ module RuboCop
         end
 
         def indexed_let?(node)
-          let?(node) && SUFFIX_INDEX_REGEX.match?(let_name(node))
+          let?(node) &&
+            SUFFIX_INDEX_REGEX.match?(let_name(node)) &&
+            !allowed_identifier?(let_name(node).to_s) &&
+            !matches_allowed_pattern?(let_name(node).to_s)
         end
 
         def let_name_stripped_index(node)
           let_name(node).to_s.gsub(INDEX_REGEX, '')
         end
+
+        def cop_config_patterns_values
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedPatterns', [])) +
+            Array(cop_config.fetch('AllowedPatterns', []))
+        end
+
+        def allowed_identifiers
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedIdentifiers', [])) +
+            Array(cop_config.fetch('AllowedIdentifiers', []))
+        end
       end
     end
   end

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

@@ -48,7 +48,7 @@ module RuboCop
       class InstanceVariable < Base
         include TopLevelGroup
 
-        MSG = 'Avoid instance variables – use let, ' \
+        MSG = 'Avoid instance variables - use let, ' \
               'a method call, or a local variable (if possible).'
 
         # @!method dynamic_class?(node)

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

@@ -17,7 +17,7 @@ module RuboCop
       # Anonymous classes are fine, since they don't result in global
       # namespace name clashes.
       #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/mutating-constants
+      # @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants
       #
       # @example Constants leak between examples
       #   # bad

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

@@ -51,6 +51,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [RSpec::ScatteredLet]
+        end
+
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use consistent metadata style.
+      #
+      # This cop does not support autocorrection in the case of
+      # `EnforcedStyle: hash` where the trailing metadata type is ambiguous.
+      # (e.g. `describe 'Something', :a, b`)
+      #
+      # @example EnforcedStyle: symbol (default)
+      #   # bad
+      #   describe 'Something', a: true
+      #
+      #   # good
+      #   describe 'Something', :a
+      #
+      # @example EnforcedStyle: hash
+      #   # bad
+      #   describe 'Something', :a
+      #
+      #   # good
+      #   describe 'Something', a: true
+      class MetadataStyle < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+
+        include ConfigurableEnforcedStyle
+        include Metadata
+        include RangeHelp
+
+        # @!method extract_metadata_hash(node)
+        def_node_matcher :extract_metadata_hash, <<~PATTERN
+          (send _ _ _ ... $hash)
+        PATTERN
+
+        # @!method match_boolean_metadata_pair?(node)
+        def_node_matcher :match_boolean_metadata_pair?, <<~PATTERN
+          (pair sym true)
+        PATTERN
+
+        # @!method match_ambiguous_trailing_metadata?(node)
+        def_node_matcher :match_ambiguous_trailing_metadata?, <<~PATTERN
+          (send _ _ _ ... !{hash sym})
+        PATTERN
+
+        def on_metadata(symbols, hash)
+          # RSpec example groups accept two string arguments. In such a case,
+          # the rspec_metadata matcher will interpret the second string
+          # argument as a metadata symbol.
+          symbols.shift if symbols.first&.str_type?
+
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol)
+          end
+
+          return unless hash
+
+          hash.pairs.each do |pair|
+            on_metadata_pair(pair)
+          end
+        end
+
+        private
+
+        def autocorrect_pair(corrector, node)
+          remove_pair(corrector, node)
+          insert_symbol(corrector, node)
+        end
+
+        def autocorrect_symbol(corrector, node)
+          return if match_ambiguous_trailing_metadata?(node.parent)
+
+          remove_symbol(corrector, node)
+          insert_pair(corrector, node)
+        end
+
+        def bad_metadata_pair?(node)
+          style == :symbol && match_boolean_metadata_pair?(node)
+        end
+
+        def bad_metadata_symbol?(_node)
+          style == :hash
+        end
+
+        def format_symbol_to_pair_source(node)
+          "#{node.value}: true"
+        end
+
+        def insert_pair(corrector, node)
+          hash_node = extract_metadata_hash(node.parent)
+          if hash_node.nil?
+            insert_pair_as_last_argument(corrector, node)
+          elsif hash_node.pairs.any?
+            insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          else
+            insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          end
+        end
+
+        def insert_pair_as_last_argument(corrector, node)
+          corrector.insert_before(
+            node.parent.location.end || node.parent.source_range.with(
+              begin_pos: node.parent.source_range.end_pos
+            ),
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.location.begin,
+            " #{format_symbol_to_pair_source(node)} "
+          )
+        end
+
+        def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.children.last,
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_symbol(corrector, node)
+          corrector.insert_after(
+            node.parent.left_sibling,
+            ", #{node.key.value.inspect}"
+          )
+        end
+
+        def message_for_style
+          format(
+            'Use %<style>s style for metadata.',
+            style: style
+          )
+        end
+
+        def on_metadata_pair(node)
+          return unless bad_metadata_pair?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_pair(corrector, node)
+          end
+        end
+
+        def on_metadata_symbol(node)
+          return unless bad_metadata_symbol?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_symbol(corrector, node)
+          end
+        end
+
+        def remove_pair(corrector, node)
+          if !node.parent.braces? || node.left_siblings.any?
+            remove_pair_following(corrector, node)
+          elsif node.right_siblings.any?
+            remove_pair_preceding(corrector, node)
+          else
+            corrector.remove(node)
+          end
+        end
+
+        def remove_pair_following(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def remove_pair_preceding(corrector, node)
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+        end
+
+        def remove_symbol(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/file_help.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for file.
+      module FileHelp
+        def expanded_file_path
+          File.expand_path(processed_source.file_path)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/metadata.rb

@@ -13,7 +13,7 @@ module RuboCop
         def_node_matcher :rspec_metadata, <<~PATTERN
           (block
             (send
-              #rspec? {#Examples.all #ExampleGroups.all #SharedGroups.all #Hooks.all} _ ${send str sym}* (hash $...)?)
+              #rspec? {#Examples.all #ExampleGroups.all #SharedGroups.all #Hooks.all} _ $...)
             ...)
         PATTERN
 
@@ -24,25 +24,39 @@ module RuboCop
 
         # @!method metadata_in_block(node)
         def_node_search :metadata_in_block, <<~PATTERN
-          (send (lvar %) #Hooks.all _ ${send str sym}* (hash $...)?)
+          (send (lvar %) #Hooks.all _ $...)
         PATTERN
 
         def on_block(node)
           rspec_configure(node) do |block_var|
-            metadata_in_block(node, block_var) do |symbols, pairs|
-              on_metadata(symbols, pairs.flatten)
+            metadata_in_block(node, block_var) do |metadata_arguments|
+              on_metadata_arguments(metadata_arguments)
             end
           end
 
-          rspec_metadata(node) do |symbols, pairs|
-            on_metadata(symbols, pairs.flatten)
+          rspec_metadata(node) do |metadata_arguments|
+            on_metadata_arguments(metadata_arguments)
           end
         end
         alias on_numblock on_block
 
-        def on_metadata(_symbols, _pairs)
+        def on_metadata(_symbols, _hash)
           raise ::NotImplementedError
         end
+
+        private
+
+        def on_metadata_arguments(metadata_arguments)
+          *symbols, last = metadata_arguments
+          hash = nil
+          case last&.type
+          when :hash
+            hash = last
+          when :sym
+            symbols << last
+          end
+          on_metadata(symbols, hash)
+        end
       end
     end
   end

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def find_subject(block_node)
-          block_node.body.child_nodes.find { |send_node| subject?(send_node) }
+          block_node.body&.child_nodes&.find { |send_node| subject?(send_node) }
         end
       end
     end

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

@@ -41,10 +41,15 @@ module RuboCop
         def_node_matcher :skippable?, <<~PATTERN
           {
             (send #rspec? #ExampleGroups.regular ...)
-            (send nil? #Examples.regular ...)
+            #skippable_example?
           }
         PATTERN
 
+        # @!method skippable_example?(node)
+        def_node_matcher :skippable_example?, <<~PATTERN
+          (send nil? #Examples.regular ...)
+        PATTERN
+
         # @!method pending_block?(node)
         def_node_matcher :pending_block?, <<~PATTERN
           {
@@ -62,7 +67,12 @@ module RuboCop
         private
 
         def skipped?(node)
-          skippable?(node) && skipped_in_metadata?(node)
+          skippable?(node) && skipped_in_metadata?(node) ||
+            skipped_regular_example_without_body?(node)
+        end
+
+        def skipped_regular_example_without_body?(node)
+          skippable_example?(node) && !node.block_node
         end
       end
     end

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]}"
@@ -240,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

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

@@ -17,10 +17,12 @@ module RuboCop
         #   # 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 }
         #
@@ -28,10 +30,12 @@ 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 }
         #
@@ -39,8 +43,10 @@ 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" }
         #   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 }
@@ -55,11 +61,13 @@ 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 |arg|
+              return if arg.str_type? && arg.heredoc?
+
               checker = checker_class.new(arg)
               return unless checker.offensive?
 
@@ -99,6 +107,10 @@ module RuboCop
               format(MSG, prefer: prefer, current: current)
             end
 
+            def current
+              offense_range.source
+            end
+
             def offense_range
               node
             end
@@ -123,10 +135,6 @@ module RuboCop
               symbol.inspect
             end
 
-            def current
-              number.inspect
-            end
-
             private
 
             def symbol
@@ -134,7 +142,7 @@ module RuboCop
             end
 
             def number
-              node.source.to_i
+              node.value.to_i
             end
           end
 
@@ -148,10 +156,6 @@ module RuboCop
               number.to_s
             end
 
-            def current
-              symbol.inspect
-            end
-
             private
 
             def symbol
@@ -159,7 +163,7 @@ module RuboCop
             end
 
             def number
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol.to_sym]
             end
           end
 
@@ -177,15 +181,13 @@ module RuboCop
             def prefer
               if node.sym_type?
                 "be_#{node.value}"
-              else
+              elsif node.int_type?
                 "be_#{symbol}"
+              elsif node.str_type?
+                "be_#{normalize_str}"
               end
             end
 
-            def current
-              offense_range.source
-            end
-
             private
 
             def symbol
@@ -193,7 +195,16 @@ module RuboCop
             end
 
             def number
-              node.source.to_i
+              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)
+              else
+                str
+              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