rubocop-rspec 1.7.0 → 3.0.2

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

@@ -5,7 +5,8 @@ module RuboCop
     module RSpec
       # Checks for nested example groups.
       #
-      # This cop is configurable using the `MaxNesting` option
+      # This cop is configurable using the `Max` option
+      # and supports `--auto-gen-config`.
       #
       # @example
       #   # bad
@@ -21,7 +22,7 @@ module RuboCop
       #       let(:user_attributes) do
       #         {
       #           name: 'John',
-      #           age:  22
+      #           age:  22,
       #           role: role
       #         }
       #       end
@@ -35,7 +36,7 @@ module RuboCop
       #     end
       #   end
       #
-      #   # better
+      #   # good
       #   context 'using some feature as an admin' do
       #     let(:some)    { :various }
       #     let(:feature) { :setup   }
@@ -43,7 +44,7 @@ module RuboCop
       #     let(:user) do
       #       UserCreate.call(
       #         name: 'John',
-      #         age:  22
+      #         age:  22,
       #         role: 'admin'
       #       )
       #     end
@@ -52,72 +53,108 @@ module RuboCop
       #     it 'yada yada'
       #   end
       #
-      # @example configuration
-      #
-      #   # .rubocop.yml
-      #   RSpec/NestedGroups:
-      #     MaxNesting: 2
-      #
-      #   context 'when using some feature' do
-      #     let(:some)    { :various }
-      #     let(:feature) { :setup   }
-      #
-      #     context 'when user is signed in' do
-      #       let(:user) do
-      #         UserCreate.call(user_attributes)
+      # @example `Max: 3` (default)
+      #   # bad
+      #   describe Foo do
+      #     context 'foo' do
+      #       context 'bar' do
+      #         context 'baz' do # flagged by rubocop
+      #         end
       #       end
+      #     end
+      #   end
       #
-      #       let(:user_attributes) do
-      #         {
-      #           name: 'John',
-      #           age:  22
-      #           role: role
-      #         }
+      # @example `Max: 2`
+      #   # bad
+      #   describe Foo do
+      #     context 'foo' do
+      #       context 'bar' do # flagged by rubocop
+      #         context 'baz' do # flagged by rubocop
+      #         end
       #       end
+      #     end
+      #   end
       #
-      #       context 'when user is an admin' do # flagged by rubocop
-      #         let(:role) { 'admin' }
+      # @example `AllowedGroups: [] (default)`
+      #   describe Foo do # <-- nested groups 1
+      #     context 'foo' do # <-- nested groups 2
+      #       context 'bar' do # <-- nested groups 3
+      #       end
+      #     end
+      #   end
       #
-      #         it 'blah blah'
-      #         it 'yada yada'
+      # @example `AllowedGroups: [path]`
+      #   describe Foo do # <-- nested groups 1
+      #     path '/foo' do # <-- nested groups 1 (not counted)
+      #       context 'bar' do # <-- nested groups 2
       #       end
       #     end
       #   end
       #
-      class NestedGroups < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Language
+      class NestedGroups < Base
+        include ConfigurableMax
+        include TopLevelGroup
 
-        MSG = 'Maximum example group nesting exceeded'.freeze
+        MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
 
-        def_node_search :find_contexts, <<-PATTERN
-          (block (send nil {#{ExampleGroups::ALL.to_node_pattern}} ...) (args) ...)
-        PATTERN
+        DEPRECATED_MAX_KEY = 'MaxNesting'
 
-        def on_block(node)
-          describe, = described_constant(node)
-          return unless describe
+        DEPRECATION_WARNING =
+          "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
+          'deprecated in favor of `Max`. Please use that instead.'
 
-          find_nested_contexts(node) do |context|
-            add_offense(context.children.first, :expression)
+        def on_top_level_group(node)
+          find_nested_example_groups(node) do |example_group, nesting|
+            self.max = nesting
+            add_offense(
+              example_group.send_node,
+              message: message(nesting)
+            )
           end
         end
 
         private
 
-        def find_nested_contexts(node, nesting: 1, &block)
-          find_contexts(node) do |nested_context|
-            yield(nested_context) if nesting > max_nesting
+        def find_nested_example_groups(node, nesting: 1, &block)
+          example_group = example_group?(node)
+          yield node, nesting if example_group && nesting > max_nesting
+
+          next_nesting = if count_up_nesting?(node, example_group)
+                           nesting + 1
+                         else
+                           nesting
+                         end
 
-            nested_context.each_child_node do |child|
-              find_nested_contexts(child, nesting: nesting + 1, &block)
-            end
+          node.each_child_node(:block, :begin) do |child|
+            find_nested_example_groups(child, nesting: next_nesting, &block)
           end
         end
 
+        def count_up_nesting?(node, example_group)
+          example_group &&
+            (node.block_type? &&
+            !allowed_groups.include?(node.method_name.to_s))
+        end
+
+        def message(nesting)
+          format(MSG, total: nesting, max: max_nesting)
+        end
+
         def max_nesting
-          Integer(cop_config.fetch('MaxNesting', 2))
+          @max_nesting ||= Integer(max_nesting_config)
+        end
+
+        def max_nesting_config
+          if cop_config.key?(DEPRECATED_MAX_KEY)
+            warn DEPRECATION_WARNING
+            cop_config.fetch(DEPRECATED_MAX_KEY)
+          else
+            cop_config.fetch('Max', 3)
+          end
+        end
+
+        def allowed_groups
+          @allowed_groups ||= cop_config.fetch('AllowedGroups', [])
         end
       end
     end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if an example contains any expectation.
+      #
+      # All RSpec's example and expectation methods are covered by default.
+      # If you are using your own custom methods,
+      # add the following configuration:
+      #
+      #   RSpec:
+      #     Language:
+      #       Examples:
+      #         Regular:
+      #           - custom_it
+      #       Expectations:
+      #         - custom_expect
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     a?
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect(a?).to be(true)
+      #   end
+      #
+      # This cop can be customized with an allowed expectation methods pattern
+      # with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed
+      # by default.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/NoExpectationExample:
+      #   #   AllowedPatterns:
+      #   #     - ^expect_
+      #   #     - ^assert_
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     not_expect_something
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect_something
+      #   end
+      #
+      #   it do
+      #     assert_something
+      #   end
+      #
+      class NoExpectationExample < Base
+        include AllowedPattern
+        include SkipOrPending
+
+        MSG = 'No expectation found in this example.'
+
+        # @!method regular_or_focused_example?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_matcher :regular_or_focused_example?, <<~PATTERN
+          ({block numblock} (send nil? {#Examples.regular #Examples.focused} ...) ...)
+        PATTERN
+
+        # @!method includes_expectation?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_search :includes_expectation?, <<~PATTERN
+          {
+            (send nil? #Expectations.all ...)
+            (send nil? `#matches_allowed_pattern? ...)
+          }
+        PATTERN
+
+        # @!method includes_skip_example?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_search :includes_skip_example?, <<~PATTERN
+          (send nil? {:pending :skip} ...)
+        PATTERN
+
+        # @param [RuboCop::AST::BlockNode] node
+        def on_block(node)
+          return unless regular_or_focused_example?(node)
+          return if includes_expectation?(node)
+          return if includes_skip_example?(node)
+          return if skipped_in_metadata?(node.send_node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+      end
+    end
+  end
+end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module RuboCop
   module Cop
     module RSpec
       # Checks for consistent method usage for negating expectations.
       #
-      # @example
+      # @example `EnforcedStyle: not_to` (default)
       #   # bad
       #   it '...' do
       #     expect(false).to_not be_true
@@ -13,39 +15,40 @@ module RuboCop
       #   it '...' do
       #     expect(false).not_to be_true
       #   end
-      class NotToNot < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::Cop::ConfigurableEnforcedStyle
+      #
+      # @example `EnforcedStyle: to_not`
+      #   # bad
+      #   it '...' do
+      #     expect(false).not_to be_true
+      #   end
+      #
+      #   # good
+      #   it '...' do
+      #     expect(false).to_not be_true
+      #   end
+      #
+      class NotToNot < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%s` over `%s`'.freeze
+        MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
+        RESTRICT_ON_SEND = %i[not_to to_not].freeze
 
-        METHOD_NAMES = [:not_to, :to_not].freeze
+        # @!method not_to_not_offense(node)
+        def_node_matcher :not_to_not_offense, '(send _ % ...)'
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-
-          return unless METHOD_NAMES.include?(method_name)
-
-          return if style.equal?(method_name)
-          add_offense(node, :expression)
-        end
-
-        def message(node)
-          _receiver, method_name, *_args = *node
-
-          if method_name.equal?(:not_to)
-            format(MSG, 'to_not', 'not_to')
-          else
-            format(MSG, 'not_to', 'to_not')
+          not_to_not_offense(node, alternative_style) do
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          _receiver, method_name, *_args = *node
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              method_name.equal?(:not_to) ? 'to_not' : 'not_to')
-          end
+        private
+
+        def message(_node)
+          format(MSG, replacement: style, original: alternative_style)
         end
       end
     end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is a let/subject that overwrites an existing one.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) { bar }
+      #   let(:foo) { baz }
+      #
+      #   subject(:foo) { bar }
+      #   let(:foo) { baz }
+      #
+      #   let(:foo) { bar }
+      #   let!(:foo) { baz }
+      #
+      #   # good
+      #   subject(:test) { something }
+      #   let(:foo) { bar }
+      #   let(:baz) { baz }
+      #   let!(:other) { other }
+      #
+      class OverwritingSetup < Base
+        MSG = '`%<name>s` is already defined.'
+
+        # @!method setup?(node)
+        def_node_matcher :setup?, <<~PATTERN
+          (block (send nil? {#Helpers.all #Subjects.all} ...) ...)
+        PATTERN
+
+        # @!method first_argument_name(node)
+        def_node_matcher :first_argument_name, '(send _ _ ({str sym} $_))'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group_with_body?(node)
+
+          find_duplicates(node.body) do |duplicate, name|
+            add_offense(
+              duplicate,
+              message: format(MSG, name: name)
+            )
+          end
+        end
+
+        private
+
+        def find_duplicates(node)
+          setup_expressions = Set.new
+          node.each_child_node(:block) do |child|
+            next unless common_setup?(child)
+
+            name = if child.send_node.arguments?
+                     first_argument_name(child.send_node).to_sym
+                   else
+                     :subject
+                   end
+
+            yield child, name unless setup_expressions.add?(name)
+          end
+        end
+
+        def common_setup?(node)
+          return false unless setup?(node)
+
+          # Search only for setup with basic_literal arguments (e.g. :sym, :str)
+          # or no arguments at all.
+          node.send_node.arguments.all?(&:basic_literal?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for any pending or skipped examples.
+      #
+      # @example
+      #   # bad
+      #   describe MyClass do
+      #     it "should be true"
+      #   end
+      #
+      #   describe MyClass do
+      #     it "should be true", skip: true do
+      #       expect(1).to eq(2)
+      #     end
+      #   end
+      #
+      #   describe MyClass do
+      #     it "should be true" do
+      #       pending
+      #     end
+      #   end
+      #
+      #   describe MyClass do
+      #     xit "should be true" do
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #   end
+      #
+      class Pending < Base
+        include SkipOrPending
+
+        MSG = 'Pending spec found.'
+
+        # @!method skippable?(node)
+        def_node_matcher :skippable?, <<~PATTERN
+          {
+            (send #rspec? #ExampleGroups.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
+          {
+            (send #rspec? #ExampleGroups.skipped ...)
+            (send nil? {#Examples.skipped #Examples.pending} ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless pending_block?(node) || skipped?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def skipped?(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
+  end
+end

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for pending or skipped examples without reason.
+      #
+      # @example
+      #   # bad
+      #   pending 'does something' do
+      #   end
+      #
+      #   # bad
+      #   it 'does something', :pending do
+      #   end
+      #
+      #   # bad
+      #   it 'does something' do
+      #     pending
+      #   end
+      #
+      #   # bad
+      #   xdescribe 'something' do
+      #   end
+      #
+      #   # bad
+      #   skip 'does something' do
+      #   end
+      #
+      #   # bad
+      #   it 'does something', :skip do
+      #   end
+      #
+      #   # bad
+      #   it 'does something' do
+      #     skip
+      #   end
+      #
+      #   # bad
+      #   it 'does something'
+      #
+      #   # good
+      #   it 'does something' do
+      #     pending 'reason'
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     skip 'reason'
+      #   end
+      #
+      #   # good
+      #   it 'does something', pending: 'reason' do
+      #   end
+      #
+      #   # good
+      #   it 'does something', skip: 'reason' do
+      #   end
+      class PendingWithoutReason < Base
+        MSG = 'Give the reason for pending or skip.'
+
+        # @!method skipped_in_example?(node)
+        def_node_matcher :skipped_in_example?, <<~PATTERN
+          {
+            (send nil? ${#Examples.skipped #Examples.pending})
+            (block (send nil? ${#Examples.skipped}) ...)
+            (numblock (send nil? ${#Examples.skipped}) ...)
+          }
+        PATTERN
+
+        # @!method skipped_by_example_method?(node)
+        def_node_matcher :skipped_by_example_method?, <<~PATTERN
+          (send nil? ${#Examples.skipped #Examples.pending})
+        PATTERN
+
+        # @!method skipped_by_example_method_with_block?(node)
+        def_node_matcher :skipped_by_example_method_with_block?, <<~PATTERN
+          ({block numblock} (send nil? ${#Examples.skipped #Examples.pending} ...) ...)
+        PATTERN
+
+        # @!method metadata_without_reason?(node)
+        def_node_matcher :metadata_without_reason?, <<~PATTERN
+          (send #rspec?
+            {#ExampleGroups.all #Examples.all} ...
+            {
+              <(sym ${:pending :skip}) ...>
+              (hash <(pair (sym ${:pending :skip}) true) ...>)
+            }
+          )
+        PATTERN
+
+        # @!method skipped_by_example_group_method?(node)
+        def_node_matcher :skipped_by_example_group_method?, <<~PATTERN
+          (send #rspec? ${#ExampleGroups.skipped} ...)
+        PATTERN
+
+        # @!method pending_step_without_reason?(node)
+        def_node_matcher :pending_step_without_reason?, <<~PATTERN
+          (send nil? {:skip :pending})
+        PATTERN
+
+        def on_send(node)
+          on_pending_by_metadata(node)
+          return unless (parent = parent_node(node))
+
+          if spec_group?(parent) || block_node_example_group?(node)
+            on_skipped_by_example_method(node)
+            on_skipped_by_example_group_method(node)
+          elsif example?(parent)
+            on_skipped_by_in_example_method(node)
+          end
+        end
+
+        private
+
+        def parent_node(node)
+          node_or_block = node.block_node || node
+          return unless (parent = node_or_block.parent)
+
+          parent.begin_type? && parent.parent ? parent.parent : parent
+        end
+
+        def block_node_example_group?(node)
+          node.block_node &&
+            example_group?(node.block_node) &&
+            explicit_rspec?(node.receiver)
+        end
+
+        def on_skipped_by_in_example_method(node)
+          skipped_in_example?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_pending_by_metadata(node)
+          metadata_without_reason?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_method(node)
+          skipped_by_example_method?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+
+          skipped_by_example_method_with_block?(node.parent) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_group_method(node)
+          skipped_by_example_group_method?(node) do
+            add_offense(node, message: 'Give the reason for skip.')
+          end
+        end
+      end
+    end
+  end
+end