rubocop-rspec 1.42.0 → 1.44.1

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

@@ -15,7 +15,7 @@ module RuboCop
       #   it 'validates users' do
       #     expect([user1, user2, user3]).to all(be_valid)
       #   end
-      class IteratedExpectation < Cop
+      class IteratedExpectation < Base
         MSG = 'Prefer using the `all` matcher instead ' \
                   'of iterating over an array.'
 

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

@@ -31,7 +31,7 @@ module RuboCop
       #     it { expect_something }
       #     it { expect_something_else }
       #
-      class LeadingSubject < Cop
+      class LeadingSubject < Base
         extend AutoCorrector
 
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
@@ -43,33 +43,40 @@ module RuboCop
         end
 
         def check_previous_nodes(node)
-          node.parent.each_child_node do |sibling|
-            if offending?(sibling)
-              msg = format(MSG, offending: sibling.method_name)
-              add_offense(node, message: msg) do |corrector|
-                autocorrect(corrector, node)
-              end
+          offending_node(node) do |offender|
+            msg = format(MSG, offending: offender.method_name)
+            add_offense(node, message: msg) do |corrector|
+              autocorrect(corrector, node, offender)
             end
-
-            break if offending?(sibling) || sibling.equal?(node)
           end
         end
 
         private
 
-        def autocorrect(corrector, node)
-          first_node = find_first_offending_node(node)
+        def offending_node(node)
+          parent(node).each_child_node.find do |sibling|
+            break if sibling.equal?(node)
+
+            yield sibling if offending?(sibling)
+          end
+        end
+
+        def parent(node)
+          node.each_ancestor(:block).first.body
+        end
+
+        def autocorrect(corrector, node, sibling)
           RuboCop::RSpec::Corrector::MoveNode.new(
             node, corrector, processed_source
-          ).move_before(first_node)
+          ).move_before(sibling)
         end
 
         def offending?(node)
-          let?(node) || hook?(node) || example?(node)
-        end
-
-        def find_first_offending_node(node)
-          node.parent.children.find { |sibling| offending?(sibling) }
+          let?(node) ||
+            hook?(node) ||
+            example?(node) ||
+            spec_group?(node) ||
+            include?(node)
         end
 
         def in_spec_block?(node)

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

@@ -93,7 +93,7 @@ module RuboCop
       #       stub_const('SomeModule::SomeClass', foo_class)
       #     end
       #   end
-      class LeakyConstantDeclaration < Cop
+      class LeakyConstantDeclaration < Base
         MSG_CONST = 'Stub constant instead of declaring explicitly.'
         MSG_CLASS = 'Stub class constant instead of declaring explicitly.'
         MSG_MODULE = 'Stub module constant instead of declaring explicitly.'

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

@@ -30,7 +30,7 @@ module RuboCop
       #   it 'checks what some does' do
       #     expect(some).to be
       #   end
-      class LetBeforeExamples < Cop
+      class LetBeforeExamples < Base
         extend AutoCorrector
 
         MSG = 'Move `let` before the examples in the group.'

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

@@ -25,7 +25,7 @@ module RuboCop
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
-      class LetSetup < Cop
+      class LetSetup < Base
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
         def_node_matcher :example_or_shared_group_or_including?,
@@ -35,7 +35,10 @@ module RuboCop
                          ).block_pattern
 
         def_node_matcher :let_bang, <<-PATTERN
-          (block $(send nil? :let! (sym $_)) args ...)
+          {
+            (block $(send nil? :let! {(sym $_) (str $_)}) ...)
+            $(send nil? :let! {(sym $_) (str $_)} block_pass)
+          }
         PATTERN
 
         def_node_search :method_called?, '(send nil? %)'
@@ -52,7 +55,7 @@ module RuboCop
 
         def unused_let_bang(node)
           child_let_bang(node) do |method_send, method_name|
-            yield(method_send) unless method_called?(node, method_name)
+            yield(method_send) unless method_called?(node, method_name.to_sym)
           end
         end
 

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

@@ -13,7 +13,7 @@ module RuboCop
       #   thing = Thing.new(baz: 42)
       #   allow(foo).to receive(:bar).and_return(thing)
       #
-      class MessageChain < Cop
+      class MessageChain < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
 
         def_node_matcher :message_chain, <<-PATTERN

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

@@ -24,7 +24,7 @@ module RuboCop
       #   # good
       #   expect(foo).to receive(:bar)
       #
-      class MessageExpectation < Cop
+      class MessageExpectation < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'

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.'

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,7 @@ 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
 

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

@@ -41,7 +41,7 @@ module RuboCop
       #
       #     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.'
 

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,8 +97,8 @@ module RuboCop
           "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
           'deprecated in favor of `Max`. Please use that instead.'
 
-        def on_top_level_describe(node, _args)
-          find_nested_example_groups(node.parent) do |example_group, nesting|
+        def on_top_level_group(node)
+          find_nested_example_groups(node) do |example_group, nesting|
             self.max = nesting
             add_offense(
               example_group.send_node,

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

@@ -15,7 +15,7 @@ module RuboCop
       #   it '...' do
       #     expect(false).not_to be_true
       #   end
-      class NotToNot < Cop
+      class NotToNot < Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 

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