rubocop-rspec 1.7.0 → 3.0.2

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.
@@ -15,25 +15,27 @@ module RuboCop
       #   describe MyClass, '.do_something_else' do
       #   end
       #
-      #   #good
-      #   describe MyClass
+      #   # good
+      #   describe MyClass do
       #     describe '.do_something' do
       #     end
       #     describe '.do_something_else' do
       #     end
       #   end
-      class MultipleDescribes < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe
+      #
+      class MultipleDescribes < Base
+        include TopLevelGroup
+
+        MSG = 'Do not use multiple top-level example groups - try to nest them.'
 
-        MSG = 'Do not use multiple top level describes - ' \
-              'try to nest them.'.freeze
+        def on_top_level_group(node)
+          top_level_example_groups =
+            top_level_groups.select { |group| example_group?(group) }
 
-        def on_top_level_describe(node, _args)
-          return if single_top_level_describe?
-          return unless top_level_nodes.first.equal?(node)
+          return if top_level_example_groups.one?
+          return unless top_level_example_groups.first.equal?(node)
 
-          add_offense(node, :expression)
+          add_offense(node.send_node)
         end
       end
     end

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

@@ -11,7 +11,6 @@ module RuboCop
       # and works with `--auto-gen-config`.
       #
       # @example
-      #
       #   # bad
       #   describe UserCreator do
       #     it 'builds a user' do
@@ -26,18 +25,31 @@ module RuboCop
       #       expect(user.name).to eq("John")
       #     end
       #
-      #     it 'sets the users age'
+      #     it 'sets the users age' do
       #       expect(user.age).to eq(22)
       #     end
       #   end
       #
-      # @example configuration
+      # @example `aggregate_failures: true` (default)
+      #   # good - the cop ignores when RSpec aggregates failures
+      #   describe UserCreator do
+      #     it 'builds a user', :aggregate_failures do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # .rubocop.yml
-      #   RSpec/MultipleExpectations:
-      #     Max: 2
+      # @example `aggregate_failures: false`
+      #   # Detected as an offense
+      #   describe UserCreator do
+      #     it 'builds a user', aggregate_failures: false do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # not flagged by rubocop
+      # @example `Max: 1` (default)
+      #   # bad
       #   describe UserCreator do
       #     it 'builds a user' do
       #       expect(user.name).to eq("John")
@@ -45,43 +57,91 @@ module RuboCop
       #     end
       #   end
       #
-      class MultipleExpectations < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::Language,
-                ConfigurableMax
+      # @example `Max: 2`
+      #   # good
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
+      #
+      class MultipleExpectations < Base
+        include ConfigurableMax
+
+        MSG = 'Example has too many expectations [%<total>d/%<max>d].'
 
-        MSG = 'Too many expectations.'.freeze
+        ANYTHING = ->(_node) { true }
+        TRUE_NODE = lambda(&:true_type?)
 
-        def_node_matcher :example?, <<-PATTERN
-          (block (send _ {#{Examples::ALL.to_node_pattern}} ...) ...)
+        # @!method aggregate_failures?(node)
+        def_node_matcher :aggregate_failures?, <<~PATTERN
+          (block {
+              (send _ _ <(sym :aggregate_failures) ...>)
+              (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
+            } ...)
         PATTERN
 
-        def_node_search :expect, '(send _ :expect ...)'
+        # @!method expect?(node)
+        def_node_matcher :expect?, '(send nil? #Expectations.all ...)'
+
+        # @!method aggregate_failures_block?(node)
+        def_node_matcher :aggregate_failures_block?, <<~PATTERN
+          (block (send nil? :aggregate_failures ...) ...)
+        PATTERN
 
-        def on_block(node)
-          return unless example?(node) && (expectations = expect(node))
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example?(node)
 
-          return if expectations.count <= max_expectations
+          return if example_with_aggregate_failures?(node)
 
-          self.max = expectations.count
+          expectations_count = to_enum(:find_expectation, node).count
 
-          flag_example(node, expectation_count: expectations.count)
+          return if expectations_count <= max_expectations
+
+          self.max = expectations_count
+
+          flag_example(node, expectation_count: expectations_count)
         end
 
         private
 
-        def flag_example(node, expectation_count:)
-          method, = *node
+        def example_with_aggregate_failures?(example_node)
+          node_with_aggregate_failures = find_aggregate_failures(example_node)
+          return false unless node_with_aggregate_failures
 
+          aggregate_failures?(node_with_aggregate_failures, TRUE_NODE)
+        end
+
+        def find_aggregate_failures(example_node)
+          example_node.send_node.each_ancestor(:block)
+            .find { |block_node| aggregate_failures?(block_node, ANYTHING) }
+        end
+
+        def find_expectation(node, &block)
+          yield if expect?(node) || aggregate_failures_block?(node)
+
+          # do not search inside of aggregate_failures block
+          return if aggregate_failures_block?(node)
+
+          node.each_child_node do |child|
+            find_expectation(child, &block)
+          end
+        end
+
+        def flag_example(node, expectation_count:)
           add_offense(
-            method,
-            :expression,
-            MSG % { total: expectation_count, max: max_expectations }
+            node.send_node,
+            message: format(
+              MSG,
+              total: expectation_count,
+              max: max_expectations
+            )
           )
         end
 
         def max_expectations
-          Integer(cop_config.fetch(parameter_name, 1))
+          Integer(cop_config.fetch('Max', 1))
         end
       end
     end

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

@@ -0,0 +1,146 @@
+# 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 Variable
+
+        MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          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
+          super
+          @example_group_memoized_helpers = {}
+        end
+
+        private
+
+        attr_reader :example_group_memoized_helpers
+
+        def all_helpers(node)
+          helpers(node) +
+            node.each_ancestor(:block).flat_map { |ancestor| helpers(ancestor) }
+        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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if an example group defines `subject` multiple times.
+      #
+      # @example
+      #   # bad
+      #   describe Foo do
+      #     subject(:user) { User.new }
+      #     subject(:post) { Post.new }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     let(:user) { User.new }
+      #     subject(:post) { Post.new }
+      #   end
+      #
+      #   # bad (does not support autocorrection)
+      #   describe Foo do
+      #     subject!(:user) { User.new }
+      #     subject!(:post) { Post.new }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     before do
+      #       User.new
+      #       Post.new
+      #     end
+      #   end
+      #
+      # This cop does not support autocorrection in some cases.
+      # The autocorrect behavior for this cop depends on the type of
+      # duplication:
+      #
+      #   - If multiple named subjects are defined then this probably indicates
+      #     that the overwritten subjects (all subjects except the last
+      #     definition) are effectively being used to define helpers. In this
+      #     case they are replaced with `let`.
+      #
+      #   - If multiple unnamed subjects are defined though then this can *only*
+      #     be dead code and we remove the overwritten subject definitions.
+      #
+      #   - 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 < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Do not set more than one subject per example group'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group?(node)
+
+          subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
+
+          subjects[0...-1].each do |subject|
+            add_offense(subject) do |corrector|
+              autocorrect(corrector, subject)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, subject)
+          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
+
+          if named_subject?(subject)
+            rename_autocorrect(corrector, subject)
+          else
+            remove_autocorrect(corrector, subject)
+          end
+        end
+
+        def named_subject?(node)
+          node.send_node.arguments?
+        end
+
+        def rename_autocorrect(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'let')
+        end
+
+        def remove_autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range,
+                                       include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

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

@@ -6,13 +6,17 @@ 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.
       #
-      # @example
+      # This cop can be configured in your configuration using `EnforcedStyle`,
+      # and `IgnoreSharedExamples` which will not report offenses for implicit
+      # subjects in shared example groups.
+      #
+      # @example `EnforcedStyle: always` (default)
       #   # bad
       #   RSpec.describe User do
       #     subject { described_class.new }
@@ -23,7 +27,7 @@ module RuboCop
       #   end
       #
       #   # good
-      #   RSpec.describe Foo do
+      #   RSpec.describe User do
       #     subject(:user) { described_class.new }
       #
       #     it 'is valid' do
@@ -32,44 +36,120 @@ module RuboCop
       #   end
       #
       #   # also good
-      #   RSpec.describe Foo do
+      #   RSpec.describe User do
+      #     subject(:user) { described_class.new }
+      #
+      #     it { is_expected.to be_valid }
+      #   end
+      #
+      # @example `EnforcedStyle: named_only`
+      #   # bad
+      #   RSpec.describe User do
+      #     subject(:user) { described_class.new }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe User do
       #     subject(:user) { described_class.new }
       #
-      #     it { should be_valid }
+      #     it 'is valid' do
+      #       expect(user.valid?).to be(true)
+      #     end
+      #   end
+      #
+      #   # also good
+      #   RSpec.describe User do
+      #     subject { described_class.new }
+      #
+      #     it { is_expected.to be_valid }
       #   end
-      class NamedSubject < Cop
-        include RuboCop::RSpec::SpecOnly
+      #
+      #   # acceptable
+      #   RSpec.describe User do
+      #     subject { described_class.new }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      class NamedSubject < Base
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Name your test subject if '\
-              'you need to reference it explicitly.'.freeze
+        MSG = 'Name your test subject if you need to reference it explicitly.'
 
-        def_node_matcher :rspec_block?, <<-PATTERN
-          (block
-            (send nil {:it :specify :before :after :around} ...)
-            ...)
+        # @!method example_or_hook_block?(node)
+        def_node_matcher :example_or_hook_block?, <<~PATTERN
+          (block (send nil? {#Examples.all #Hooks.all} ...) ...)
         PATTERN
 
-        def_node_matcher :unnamed_subject, '$(send nil :subject)'
+        # @!method shared_example?(node)
+        def_node_matcher :shared_example?, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
+        PATTERN
+
+        # @!method subject_usage(node)
+        def_node_search :subject_usage, '$(send nil? :subject)'
 
-        def on_block(node)
-          return unless rspec_block?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          if !example_or_hook_block?(node) || ignored_shared_example?(node)
+            return
+          end
 
           subject_usage(node) do |subject_node|
-            add_offense(subject_node, :selector)
+            check_explicit_subject(subject_node)
           end
         end
 
         private
 
-        def subject_usage(node, &block)
-          return unless node.instance_of?(Node)
-
-          unnamed_subject(node, &block)
+        def ignored_shared_example?(node)
+          return false unless cop_config['IgnoreSharedExamples']
 
-          node.children.each do |child|
-            subject_usage(child, &block)
+          node.each_ancestor(:block).any? do |ancestor|
+            shared_example?(ancestor)
           end
         end
+
+        def check_explicit_subject(node)
+          return if allow_explicit_subject?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        def allow_explicit_subject?(node)
+          !always? && !named_only?(node)
+        end
+
+        def always?
+          style == :always
+        end
+
+        def named_only?(node)
+          style == :named_only &&
+            subject_definition_is_named?(node)
+        end
+
+        def subject_definition_is_named?(node)
+          subject = nearest_subject(node)
+
+          subject&.send_node&.arguments?
+        end
+
+        def nearest_subject(node)
+          node
+            .each_ancestor(:block)
+            .lazy
+            .map { |block_node| find_subject(block_node) }
+            .find(&:itself)
+        end
+
+        def find_subject(block_node)
+          block_node.body&.child_nodes&.find { |send_node| subject?(send_node) }
+        end
       end
     end
   end