rubocop-rspec 1.38.1 → 1.43.0

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

@@ -24,7 +24,7 @@ module RuboCop
       #   # good
       #   expect(foo).to receive(:bar)
       #
-      class MessageSpies < Cop
+      class MessageSpies < Base
         include ConfigurableEnforcedStyle
 
         MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
@@ -48,8 +48,7 @@ module RuboCop
             return correct_style_detected if preferred_style?(message_matcher)
 
             add_offense(
-              message_matcher,
-              location: :selector,
+              message_matcher.loc.selector,
               message: error_message(receiver)
             ) { opposite_style_detected }
           end

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   describe "A feature example" do
       #   end
-      class MissingExampleGroupArgument < Cop
+      class MissingExampleGroupArgument < Base
         MSG = 'The first argument to `%<method>s` should not be empty.'
 
         def on_block(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks for multiple top level describes.
+      # Checks for multiple top-level example groups.
       #
       # Multiple descriptions for the same class or module should either
       # be nested or separated into different test files.
@@ -22,17 +22,20 @@ module RuboCop
       #     describe '.do_something_else' do
       #     end
       #   end
-      class MultipleDescribes < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      class MultipleDescribes < Base
+        include RuboCop::RSpec::TopLevelGroup
 
-        MSG = 'Do not use multiple top level describes - '\
+        MSG = 'Do not use multiple top-level example groups - '\
               'try to nest them.'
 
-        def on_top_level_describe(node, _args)
-          return if single_top_level_describe?
-          return unless top_level_nodes.first.equal?(node)
+        def on_top_level_group(node)
+          top_level_example_groups =
+            top_level_groups.select(&method(:example_group?))
 
-          add_offense(node)
+          return if top_level_example_groups.one?
+          return unless top_level_example_groups.first.equal?(node)
+
+          add_offense(node.send_node)
         end
       end
     end

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

@@ -45,22 +45,18 @@ module RuboCop
       #     end
       #   end
       #
-      class MultipleExpectations < Cop
+      class MultipleExpectations < Base
         include ConfigurableMax
 
         MSG = 'Example has too many expectations [%<total>d/%<max>d].'
 
-        def_node_matcher :aggregate_failures?, <<-PATTERN
-          (block {
-              (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) true) ...>))
-            } ...)
-        PATTERN
+        ANYTHING = ->(_node) { true }
+        TRUE = ->(node) { node.true_type? }
 
-        def_node_matcher :aggregate_failures_present?, <<-PATTERN
+        def_node_matcher :aggregate_failures?, <<-PATTERN
           (block {
               (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) _) ...>))
+              (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
             } ...)
         PATTERN
 
@@ -89,12 +85,12 @@ module RuboCop
           node_with_aggregate_failures = find_aggregate_failures(example_node)
           return false unless node_with_aggregate_failures
 
-          aggregate_failures?(node_with_aggregate_failures)
+          aggregate_failures?(node_with_aggregate_failures, TRUE)
         end
 
         def find_aggregate_failures(example_node)
           example_node.send_node.each_ancestor(:block)
-            .find { |block_node| aggregate_failures_present?(block_node) }
+            .find { |block_node| aggregate_failures?(block_node, ANYTHING) }
         end
 
         def find_expectation(node, &block)

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if example groups contain too many `let` and `subject` calls.
+      #
+      # This cop is configurable using the `Max` option and the `AllowSubject`
+      # which will configure the cop to only register offenses on calls to
+      # `let` and not calls to `subject`.
+      #
+      # @example
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #
+      #     context 'when stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     context 'when stuff' do
+      #       let(:foo) { [] }
+      #       let(:bar) { [] }
+      #       let!(:booger) { [] }
+      #     end
+      #
+      #     context 'when other stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      # @example when disabling AllowSubject configuration
+      #
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   AllowSubject: false
+      #
+      #   # bad - `subject` counts towards memoized helpers
+      #   describe MyClass do
+      #     subject { {} }
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #   end
+      #
+      # @example with Max configuration
+      #
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   Max: 1
+      #
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #   end
+      #
+      class MultipleMemoizedHelpers < Base
+        include ConfigurableMax
+        include RuboCop::RSpec::Variable
+
+        MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
+
+        def on_block(node)
+          return unless spec_group?(node)
+
+          count = all_helpers(node).uniq.count
+
+          return if count <= max
+
+          self.max = count
+          add_offense(node, message: format(MSG, count: count, max: max))
+        end
+
+        def on_new_investigation
+          @example_group_memoized_helpers = {}
+        end
+
+        private
+
+        attr_reader :example_group_memoized_helpers
+
+        def all_helpers(node)
+          [
+            *helpers(node),
+            *node.each_ancestor(:block).flat_map(&method(:helpers))
+          ]
+        end
+
+        def helpers(node)
+          @example_group_memoized_helpers[node] ||=
+            variable_nodes(node).map do |variable_node|
+              if variable_node.block_type?
+                variable_definition?(variable_node.send_node)
+              else # block-pass (`let(:foo, &bar)`)
+                variable_definition?(variable_node)
+              end
+            end
+        end
+
+        def variable_nodes(node)
+          example_group = RuboCop::RSpec::ExampleGroup.new(node)
+          if allow_subject?
+            example_group.lets
+          else
+            example_group.lets + example_group.subjects
+          end
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_subject?
+          cop_config['AllowSubject']
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,8 @@ module RuboCop
       #   - If subjects are defined with `subject!` then we don't autocorrect.
       #     This is enough of an edge case that people can just move this to
       #     a `before` hook on their own
-      class MultipleSubjects < Cop
+      class MultipleSubjects < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Do not set more than one subject per example group'
@@ -44,38 +45,36 @@ module RuboCop
           subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
 
           subjects[0...-1].each do |subject|
-            add_offense(subject)
+            add_offense(subject) do |corrector|
+              autocorrect(corrector, subject)
+            end
           end
         end
 
-        def autocorrect(node)
-          return unless node.method_name.equal?(:subject) # Ignore `subject!`
+        private
+
+        def autocorrect(corrector, subject)
+          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
 
-          if named_subject?(node)
-            rename_autocorrect(node)
+          if named_subject?(subject)
+            rename_autocorrect(corrector, subject)
           else
-            remove_autocorrect(node)
+            remove_autocorrect(corrector, subject)
           end
         end
 
-        private
-
         def named_subject?(node)
           node.send_node.arguments?
         end
 
-        def rename_autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'let')
-          end
+        def rename_autocorrect(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'let')
         end
 
-        def remove_autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(node.source_range,
-                                         include_final_newline: true)
-            corrector.remove(range)
-          end
+        def remove_autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range,
+                                       include_final_newline: true)
+          corrector.remove(range)
         end
       end
     end

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

@@ -6,11 +6,11 @@ module RuboCop
       # Checks for explicitly referenced test subjects.
       #
       # RSpec lets you declare an "implicit subject" using `subject { ... }`
-      # which allows for tests like `it { should be_valid }`. If you need to
-      # reference your test subject you should explicitly name it using
-      # `subject(:your_subject_name) { ... }`. Your test subjects should be
-      # the most important object in your tests so they deserve a descriptive
-      # name.
+      # which allows for tests like `it { is_expected.to be_valid }`.
+      # If you need to reference your test subject you should explicitly
+      # name it using `subject(:your_subject_name) { ... }`. Your test subjects
+      # should be the most important object in your tests so they deserve
+      # a descriptive name.
       #
       # This cop can be configured in your configuration using the
       # `IgnoreSharedExamples` which will not report offenses for implicit
@@ -39,9 +39,9 @@ module RuboCop
       #   RSpec.describe Foo do
       #     subject(:user) { described_class.new }
       #
-      #     it { should be_valid }
+      #     it { is_expected.to be_valid }
       #   end
-      class NamedSubject < Cop
+      class NamedSubject < Base
         MSG = 'Name your test subject if you need '\
               'to reference it explicitly.'
 
@@ -62,7 +62,7 @@ module RuboCop
           return if !rspec_block?(node) || ignored_shared_example?(node)
 
           subject_usage(node) do |subject_node|
-            add_offense(subject_node, location: :selector)
+            add_offense(subject_node.loc.selector)
           end
         end
 

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

@@ -85,9 +85,9 @@ module RuboCop
       #     end
       #   end
       #
-      class NestedGroups < Cop
+      class NestedGroups < Base
         include ConfigurableMax
-        include RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::RSpec::TopLevelGroup
 
         MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
 
@@ -97,13 +97,11 @@ module RuboCop
           "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
           'deprecated in favor of `Max`. Please use that instead.'
 
-        def_node_search :find_contexts, ExampleGroups::ALL.block_pattern
-
-        def on_top_level_describe(node, _args)
-          find_nested_contexts(node.parent) do |context, nesting|
+        def on_top_level_group(node)
+          find_nested_example_groups(node) do |example_group, nesting|
             self.max = nesting
             add_offense(
-              context.send_node,
+              example_group.send_node,
               message: message(nesting)
             )
           end
@@ -111,13 +109,14 @@ module RuboCop
 
         private
 
-        def find_nested_contexts(node, nesting: 1, &block)
-          find_contexts(node) do |nested_context|
-            yield(nested_context, nesting) 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 = example_group ? nesting + 1 : nesting
 
-            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
 

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

@@ -15,7 +15,8 @@ module RuboCop
       #   it '...' do
       #     expect(false).not_to be_true
       #   end
-      class NotToNot < Cop
+      class NotToNot < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
@@ -24,14 +25,12 @@ module RuboCop
 
         def on_send(node)
           not_to_not_offense(node, alternative_style) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)

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

@@ -21,7 +21,7 @@ module RuboCop
       #   let(:foo) { bar }
       #   let(:baz) { baz }
       #   let!(:other) { other }
-      class OverwritingSetup < Cop
+      class OverwritingSetup < Base
         MSG = '`%<name>s` is already defined.'
 
         def_node_matcher :setup?, (Helpers::ALL + Subject::ALL).block_pattern

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

@@ -31,7 +31,7 @@ module RuboCop
       #   # good
       #   describe MyClass do
       #   end
-      class Pending < Cop
+      class Pending < Base
         MSG = 'Pending spec found.'
 
         PENDING = Examples::PENDING + Examples::SKIPPED + ExampleGroups::SKIPPED