rubocop-rspec 2.16.0 → 2.24.1

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Prefer to travel in `before` rather than `around`.
+        #
+        # @safety
+        #   This cop is unsafe because the automatic `travel_back` is only run
+        #   on test cases that are considered as Rails related.
+        #
+        #   And also, this cop's autocorrection is unsafe because the order of
+        #   execution will change if other steps exist before traveling in
+        #   `around`.
+        #
+        # @example
+        #   # bad
+        #   around do |example|
+        #     freeze_time do
+        #       example.run
+        #     end
+        #   end
+        #
+        #   # good
+        #   before { freeze_time }
+        class TravelAround < Base
+          extend AutoCorrector
+
+          MSG = 'Prefer to travel in `before` rather than `around`.'
+
+          TRAVEL_METHOD_NAMES = %i[
+            freeze_time
+            travel
+            travel_to
+          ].to_set.freeze
+
+          # @!method extract_run_in_travel(node)
+          def_node_matcher :extract_run_in_travel, <<~PATTERN
+            (block
+              $(send nil? TRAVEL_METHOD_NAMES ...)
+              (args ...)
+              (send _ :run)
+            )
+          PATTERN
+
+          # @!method match_around_each?(node)
+          def_node_matcher :match_around_each?, <<~PATTERN
+            (block
+              (send _ :around (sym :each)?)
+              ...
+            )
+          PATTERN
+
+          def on_block(node)
+            run_node = extract_run_in_travel(node)
+            return unless run_node
+
+            around_node = extract_surrounding_around_block(run_node)
+            return unless around_node
+
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node, run_node, around_node)
+            end
+          end
+          alias on_numblock on_block
+
+          private
+
+          def autocorrect(corrector, node, run_node, around_node)
+            corrector.replace(
+              node,
+              node.body.source
+            )
+            corrector.insert_before(
+              around_node,
+              "before { #{run_node.source} }\n\n"
+            )
+          end
+
+          # @param node [RuboCop::AST::BlockNode]
+          # @return [RuboCop::AST::BlockNode, nil]
+          def extract_surrounding_around_block(node)
+            node.each_ancestor(:block).find do |ancestor|
+              match_around_each?(ancestor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module RuboCop
 
         def range(node, offending_node)
           offending_node.loc.dot.with(
-            end_pos: node.loc.expression.end_pos
+            end_pos: node.source_range.end_pos
           )
         end
       end

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_around.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Remove redundant `around` hook.
+      #
+      # @example
+      #   # bad
+      #   around do |example|
+      #     example.run
+      #   end
+      #
+      #   # good
+      #
+      class RedundantAround < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `around` hook.'
+
+        RESTRICT_ON_SEND = %i[around].freeze
+
+        def on_block(node)
+          return unless match_redundant_around_hook_block?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless match_redundant_around_hook_send?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method match_redundant_around_hook_block?(node)
+        def_node_matcher :match_redundant_around_hook_block?, <<~PATTERN
+          ({block numblock} (send _ :around ...) ... (send _ :run))
+        PATTERN
+
+        # @!method match_redundant_around_hook_send?(node)
+        def_node_matcher :match_redundant_around_hook_send?, <<~PATTERN
+          (send
+            _
+            :around
+            ...
+            (block-pass
+              (sym :run)
+            )
+          )
+        PATTERN
+
+        def autocorrect(corrector, node)
+          corrector.remove(node)
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,8 @@ module RuboCop
       #   end
       #
       class RepeatedExampleGroupBody < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
@@ -59,11 +61,6 @@ module RuboCop
         # @!method const_arg(node)
         def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
 
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending} ...) ...>)
-        PATTERN
-
         def on_begin(node)
           return unless several_example_groups?(node)
 
@@ -78,7 +75,7 @@ module RuboCop
           node
             .children
             .select { |child| example_group_with_body?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .group_by { |group| signature_keys(group) }
             .values
             .reject(&:one?)

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

@@ -43,6 +43,8 @@ module RuboCop
       #   end
       #
       class RepeatedExampleGroupDescription < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
@@ -55,11 +57,6 @@ module RuboCop
           (block (send _ _ $_ $...) ...)
         PATTERN
 
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending}) ...>)
-        PATTERN
-
         # @!method empty_description?(node)
         def_node_matcher :empty_description?, '(block (send _ _) ...)'
 
@@ -77,7 +74,7 @@ module RuboCop
           node
             .children
             .select { |child| example_group?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .reject { |child| empty_description?(child) }
             .group_by { |group| doc_string_and_metadata(group) }
             .values

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

@@ -56,12 +56,11 @@ module RuboCop
 
         # @!method include_examples?(node)
         def_node_matcher :include_examples?,
-                         send_pattern('#Includes.examples')
+                         '(send nil? #Includes.examples ...)'
 
         # @!method shared_examples_name(node)
-        def_node_matcher :shared_examples_name, <<-PATTERN
-          (send _ #Includes.examples $_ ...)
-        PATTERN
+        def_node_matcher :shared_examples_name,
+                         '(send nil? #Includes.examples $_name ...)'
 
         def on_begin(node)
           return unless several_include_examples?(node)

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

@@ -23,6 +23,9 @@ module RuboCop
       #   end
       #
       class ScatteredSetup < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Do not define multiple `%<hook_name>s` hooks in the same ' \
               'example group (also defined on %<lines>s).'
 
@@ -30,13 +33,11 @@ module RuboCop
           return unless example_group?(node)
 
           repeated_hooks(node).each do |occurrences|
-            lines = occurrences.map(&:first_line)
-
             occurrences.each do |occurrence|
-              lines_except_current = lines - [occurrence.first_line]
-              message = format(MSG, hook_name: occurrences.first.method_name,
-                                    lines: lines_msg(lines_except_current))
-              add_offense(occurrence, message: message)
+              message = message(occurrences, occurrence)
+              add_offense(occurrence, message: message) do |corrector|
+                autocorrect(corrector, occurrences.first, occurrence)
+              end
             end
           end
         end
@@ -63,6 +64,22 @@ module RuboCop
             "lines #{numbers.join(', ')}"
           end
         end
+
+        def message(occurrences, occurrence)
+          lines = occurrences.map(&:first_line)
+          lines_except_current = lines - [occurrence.first_line]
+          format(MSG, hook_name: occurrences.first.method_name,
+                      lines: lines_msg(lines_except_current))
+        end
+
+        def autocorrect(corrector, first_occurrence, occurrence)
+          return if first_occurrence == occurrence || !first_occurrence.body
+
+          corrector.insert_after(first_occurrence.body,
+                                 "\n#{occurrence.body.source}")
+          corrector.remove(range_by_whole_lines(occurrence.source_range,
+                                                include_final_newline: true))
+        end
       end
     end
   end

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

@@ -57,27 +57,26 @@ module RuboCop
         MSG_CONTEXT  = "Use `shared_context` when you don't define examples."
 
         # @!method examples?(node)
-        def_node_search :examples?,
-                        send_pattern('{#Includes.examples #Examples.all}')
+        def_node_search :examples?, <<~PATTERN
+          (send nil? {#Includes.examples #Examples.all} ...)
+        PATTERN
 
         # @!method context?(node)
         def_node_search :context?, <<-PATTERN
-          (
-            send #rspec? {
-              #Subjects.all
-              #Helpers.all
-              #Includes.context
-              #Hooks.all
-            } ...
+          (send nil?
+            {#Subjects.all #Helpers.all #Includes.context #Hooks.all} ...
           )
         PATTERN
 
         # @!method shared_context(node)
-        def_node_matcher :shared_context,
-                         block_pattern('#SharedGroups.context')
+        def_node_matcher :shared_context, <<~PATTERN
+          (block (send #rspec? #SharedGroups.context ...) ...)
+        PATTERN
+
         # @!method shared_example(node)
-        def_node_matcher :shared_example,
-                         block_pattern('#SharedGroups.examples')
+        def_node_matcher :shared_example, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
+        PATTERN
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           context_with_only_examples(node) do

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

@@ -24,10 +24,12 @@ module RuboCop
         extend AutoCorrector
 
         # @!method shared_examples(node)
-        def_node_matcher :shared_examples,
-                         send_pattern(
-                           '{#SharedGroups.all #Includes.all}'
-                         )
+        def_node_matcher :shared_examples, <<~PATTERN
+          {
+            (send #rspec? #SharedGroups.all ...)
+            (send nil? #Includes.all ...)
+          }
+        PATTERN
 
         def on_send(node)
           shared_examples(node) do

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for passing a block to `skip` within examples.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     skip 'not yet implemented' do
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     skip 'not yet implemented'
+      #     do_something
+      #   end
+      #
+      #   # good - when outside example
+      #   skip 'not yet implemented' do
+      #   end
+      #
+      class SkipBlockInsideExample < Base
+        MSG = "Don't pass a block to `skip` inside examples."
+
+        def on_block(node)
+          return unless node.method?(:skip)
+          return unless inside_example?(node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def inside_example?(node)
+          node.each_ancestor(:block).any? { |ancestor| example?(ancestor) }
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,8 @@ module RuboCop
 
         MSG = 'Sort metadata alphabetically.'
 
-        def on_metadata(symbols, pairs)
+        def on_metadata(symbols, hash)
+          pairs = hash&.pairs || []
           return if sorted?(symbols, pairs)
 
           crime_scene = crime_scene(symbols, pairs)
@@ -38,8 +39,8 @@ module RuboCop
           metadata = symbols + pairs
 
           range_between(
-            metadata.first.loc.expression.begin_pos,
-            metadata.last.loc.expression.end_pos
+            metadata.first.source_range.begin_pos,
+            metadata.last.source_range.end_pos
           )
         end