rubocop-rspec 2.18.1 → 2.20.0

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)
@@ -18,7 +19,7 @@ module RuboCop
 
           MSG =
             'Prefer `expect(response).%<to>s have_http_status(%<status>i)` ' \
-            'over `expect(response.status).%<to>s %<match>s`.'
+            'over `%<bad_code>s`.'
 
           RUNNERS = %i[to to_not not_to].to_set
           RESTRICT_ON_SEND = RUNNERS
@@ -27,19 +28,21 @@ 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)
+              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_i.to_s)
               end
             end
           end

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

@@ -8,6 +8,11 @@ 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 }
@@ -30,6 +35,19 @@ module RuboCop
         #   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 200 }
+        #   it { is_expected.to have_http_status 404 }
+        #
+        #   # 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 }
+        #
         class HttpStatus < Base
           extend AutoCorrector
           include ConfigurableEnforcedStyle
@@ -41,12 +59,13 @@ module RuboCop
           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 +78,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 +95,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
+              number.inspect
             end
 
             private
@@ -94,50 +136,64 @@ module RuboCop
             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)
-            end
           end
 
           # :nodoc:
-          class NumericStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-
-            ALLOWED_STATUSES = %i[error success missing redirect].freeze
-
-            attr_reader :node
-
-            def initialize(node)
-              @node = node
-            end
-
+          class NumericStyleChecker < StyleCheckerBase
             def offensive?
               !node.int_type? && !allowed_symbol?
             end
 
-            def message
-              format(MSG, prefer: preferred_style, current: symbol.inspect)
+            def prefer
+              number.to_s
             end
 
-            def preferred_style
-              number.to_s
+            def current
+              symbol.inspect
             end
 
             private
 
+            def symbol
+              node.value
+            end
+
             def number
               ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
             end
+          end
+
+          # :nodoc:
+          class BeStatusStyleChecker < StyleCheckerBase
+            def offensive?
+              (!node.sym_type? && !custom_http_status_code?) ||
+                (!node.int_type? && !allowed_symbol?)
+            end
+
+            def offense_range
+              node.parent
+            end
+
+            def prefer
+              if node.sym_type?
+                "be_#{node.value}"
+              else
+                "be_#{symbol}"
+              end
+            end
+
+            def current
+              offense_range.source
+            end
+
+            private
 
             def symbol
-              node.value
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
             end
 
-            def allowed_symbol?
-              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
+            def number
+              node.source.to_i
             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

@@ -13,9 +13,9 @@ module RuboCop
         #   refute_equal(a, b)
         #
         #   # good
-        #   expect(a).to eq(b)
-        #   expect(a).to(eq(b), "must be equal")
-        #   expect(a).not_to eq(b)
+        #   expect(b).to eq(a)
+        #   expect(b).to(eq(a), "must be equal")
+        #   expect(b).not_to eq(a)
         #
         class MinitestAssertions < Base
           extend AutoCorrector
@@ -43,9 +43,9 @@ module RuboCop
           def replacement(node, expected, actual, failure_message)
             runner = node.method?(:assert_equal) ? 'to' : 'not_to'
             if failure_message.nil?
-              "expect(#{expected.source}).#{runner} eq(#{actual.source})"
+              "expect(#{actual.source}).#{runner} eq(#{expected.source})"
             else
-              "expect(#{expected.source}).#{runner}(eq(#{actual.source}), " \
+              "expect(#{actual.source}).#{runner}(eq(#{expected.source}), " \
                 "#{failure_message.source})"
             end
           end

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/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