rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for usage of implicit subject (`is_expected` / `should`).
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: single_line_only` (default)
+      #   # bad
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #   it do
+      #     expect(subject).to be_truthy
+      #   end
+      #
+      # @example `EnforcedStyle: single_statement_only`
+      #   # bad
+      #   it do
+      #     foo = 1
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it do
+      #     foo = 1
+      #     expect(subject).to be_truthy
+      #   end
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
+      # @example `EnforcedStyle: disallow`
+      #   # bad
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { expect(subject).to be_truthy }
+      #
+      # @example `EnforcedStyle: require_implicit`
+      #   # bad
+      #   it { expect(subject).to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # bad
+      #   it do
+      #     expect(subject).to be_truthy
+      #   end
+      #
+      #   # good
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it { expect(named_subject).to be_truthy }
+      #
+      class ImplicitSubject < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG_REQUIRE_EXPLICIT = "Don't use implicit subject."
+
+        MSG_REQUIRE_IMPLICIT = "Don't use explicit subject."
+
+        RESTRICT_ON_SEND = %i[
+          expect
+          is_expected
+          should
+          should_not
+        ].freeze
+
+        # @!method explicit_unnamed_subject?(node)
+        def_node_matcher :explicit_unnamed_subject?, <<~PATTERN
+          (send nil? :expect (send nil? :subject))
+        PATTERN
+
+        # @!method implicit_subject?(node)
+        def_node_matcher :implicit_subject?, <<~PATTERN
+          (send nil? {:should :should_not :is_expected} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless invalid?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          case node.method_name
+          when :expect
+            corrector.replace(node, 'is_expected')
+          when :is_expected
+            corrector.replace(node.location.selector, 'expect(subject)')
+          when :should
+            corrector.replace(node.location.selector, 'expect(subject).to')
+          when :should_not
+            corrector.replace(node.location.selector, 'expect(subject).not_to')
+          end
+        end
+
+        def message(_node)
+          case style
+          when :require_implicit
+            MSG_REQUIRE_IMPLICIT
+          else
+            MSG_REQUIRE_EXPLICIT
+          end
+        end
+
+        def invalid?(node)
+          case style
+          when :require_implicit
+            explicit_unnamed_subject?(node)
+          when :disallow
+            implicit_subject_in_non_its?(node)
+          when :single_line_only
+            implicit_subject_in_non_its_and_non_single_line?(node)
+          when :single_statement_only
+            implicit_subject_in_non_its_and_non_single_statement?(node)
+          end
+        end
+
+        def implicit_subject_in_non_its?(node)
+          implicit_subject?(node) && !its?(node)
+        end
+
+        def implicit_subject_in_non_its_and_non_single_line?(node)
+          implicit_subject_in_non_its?(node) && !single_line?(node)
+        end
+
+        def implicit_subject_in_non_its_and_non_single_statement?(node)
+          implicit_subject_in_non_its?(node) && !single_statement?(node)
+        end
+
+        def its?(node)
+          example_of(node)&.method?(:its)
+        end
+
+        def single_line?(node)
+          example_of(node)&.single_line?
+        end
+
+        def single_statement?(node)
+          !example_of(node)&.body&.begin_type?
+        end
+
+        def example_of(node)
+          node.each_ancestor.find do |ancestor|
+            example?(ancestor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+      #
+      # It makes reading the test harder because it's not clear what exactly
+      # is tested by this particular example.
+      #
+      # The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+      # will also read those set in `Naming/VariableNumber`.
+      #
+      # @example `Max: 1 (default)`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      #   let(:item1) { create(:item) }
+      #   let(:item2) { create(:item) }
+      #
+      #   # good
+      #
+      #   let(:visible_item) { create(:item, visible: true) }
+      #   let(:invisible_item) { create(:item, visible: false) }
+      #
+      # @example `Max: 2`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #   let(:item_3) { create(:item) }
+      #
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedIdentifiers: ['item_1', 'item_2']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedPatterns: ['item']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      class IndexedLet < Base
+        include AllowedIdentifiers
+        include AllowedPattern
+
+        MSG = 'This `let` statement uses index in its name. Please give it ' \
+              'a meaningful name.'
+
+        # @!method let_name(node)
+        def_node_matcher :let_name, <<~PATTERN
+          {
+            (block (send nil? #Helpers.all ({str sym} $_) ...) ...)
+            (send nil? #Helpers.all ({str sym} $_) block_pass)
+          }
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
+
+          children = node.body&.child_nodes
+          return unless children
+
+          filter_indexed_lets(children).each do |let_node|
+            add_offense(let_node)
+          end
+        end
+
+        private
+
+        SUFFIX_INDEX_REGEX = /_?\d+$/.freeze
+        INDEX_REGEX = /\d+/.freeze
+
+        def filter_indexed_lets(candidates)
+          candidates
+            .filter { |node| indexed_let?(node) }
+            .group_by { |node| let_name_stripped_index(node) }
+            .values
+            .filter { |lets| lets.length > cop_config['Max'] }
+            .flatten
+        end
+
+        def indexed_let?(node)
+          let?(node) &&
+            SUFFIX_INDEX_REGEX.match?(let_name(node)) &&
+            !allowed_identifier?(let_name(node).to_s) &&
+            !matches_allowed_pattern?(let_name(node).to_s)
+        end
+
+        def let_name_stripped_index(node)
+          let_name(node).to_s.gsub(INDEX_REGEX, '')
+        end
+
+        def cop_config_patterns_values
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedPatterns', [])) +
+            Array(cop_config.fetch('AllowedPatterns', []))
+        end
+
+        def allowed_identifiers
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedIdentifiers', [])) +
+            Array(cop_config.fetch('AllowedIdentifiers', []))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `instance_double` used with `have_received`.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     foo = instance_double(Foo).as_null_object
+      #     expect(foo).to have_received(:bar)
+      #   end
+      #
+      #   # good
+      #   it do
+      #     foo = instance_spy(Foo)
+      #     expect(foo).to have_received(:bar)
+      #   end
+      #
+      class InstanceSpy < Base
+        extend AutoCorrector
+
+        MSG = 'Use `instance_spy` when you check your double ' \
+              'with `have_received`.'
+
+        # @!method null_double(node)
+        def_node_search :null_double, <<~PATTERN
+          (lvasgn $_
+            (send
+              $(send nil? :instance_double
+                ...) :as_null_object))
+        PATTERN
+
+        # @!method have_received_usage(node)
+        def_node_search :have_received_usage, <<~PATTERN
+          (send
+            (send nil? :expect
+            (lvar $_)) :to
+            (send nil? :have_received
+            ...)
+          ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example?(node)
+
+          null_double(node) do |var, receiver|
+            have_received_usage(node) do |expected|
+              next if expected != var
+
+              add_offense(receiver) do |corrector|
+                autocorrect(corrector, receiver)
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          replacement = 'instance_spy'
+          corrector.replace(node.loc.selector, replacement)
+
+          double_source_map = node.parent.loc
+          as_null_object_range = double_source_map
+            .dot
+            .join(double_source_map.selector)
+          corrector.remove(as_null_object_range)
+        end
+      end
+    end
+  end
+end

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

@@ -24,10 +24,9 @@ module RuboCop
       #   end
       #
       # @example with AssignmentOnly configuration
-      #
       #   # rubocop.yml
-      #   RSpec/InstanceVariable:
-      #     AssignmentOnly: false
+      #   # RSpec/InstanceVariable:
+      #   #   AssignmentOnly: true
       #
       #   # bad
       #   describe MyClass do
@@ -46,33 +45,48 @@ module RuboCop
       #     it { expect(foo).to be_empty }
       #   end
       #
-      class InstanceVariable < Cop
-        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
+      class InstanceVariable < Base
+        include TopLevelGroup
 
-        MESSAGE = 'Use `let` instead of an instance variable'.freeze
+        MSG = 'Avoid instance variables - use let, ' \
+              'a method call, or a local variable (if possible).'
 
-        EXAMPLE_GROUP_METHODS = ExampleGroups::ALL + SharedGroups::ALL
+        # @!method dynamic_class?(node)
+        def_node_matcher :dynamic_class?, <<~PATTERN
+          (block (send (const nil? :Class) :new ...) ...)
+        PATTERN
 
-        def_node_matcher :spec_group?, <<-PATTERN
-          (block (send _ {#{EXAMPLE_GROUP_METHODS.to_node_pattern}} ...) ...)
+        # @!method custom_matcher?(node)
+        def_node_matcher :custom_matcher?, <<~PATTERN
+          (block {
+            (send nil? :matcher sym)
+            (send (const (const nil? :RSpec) :Matchers) :define sym)
+          } ...)
         PATTERN
 
+        # @!method ivar_usage(node)
         def_node_search :ivar_usage, '$(ivar $_)'
 
+        # @!method ivar_assigned?(node)
         def_node_search :ivar_assigned?, '(ivasgn % ...)'
 
-        def on_block(node)
-          return unless spec_group?(node)
-
+        def on_top_level_group(node)
           ivar_usage(node) do |ivar, name|
-            return if assignment_only? && !ivar_assigned?(node, name)
+            next if valid_usage?(ivar)
+            next if assignment_only? && !ivar_assigned?(node, name)
 
-            add_offense(ivar, :expression, MESSAGE)
+            add_offense(ivar)
           end
         end
 
         private
 
+        def valid_usage?(node)
+          node.each_ancestor(:block).any? do |block|
+            dynamic_class?(block) || custom_matcher?(block)
+          end
+        end
+
         def assignment_only?
           cop_config['AssignmentOnly']
         end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `specify` with `is_expected` and one-liner expectations.
+      #
+      # @example
+      #   # bad
+      #   specify { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   specify do
+      #     # ...
+      #   end
+      #   specify { expect(sqrt(4)).to eq(2) }
+      #
+      class IsExpectedSpecify < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[specify].freeze
+        IS_EXPECTED_METHODS = ::Set[:is_expected, :are_expected].freeze
+        MSG = 'Use `it` instead of `specify`.'
+
+        # @!method offense?(node)
+        def_node_matcher :offense?, <<~PATTERN
+          (block (send _ :specify) _ (send (send _ IS_EXPECTED_METHODS) ...))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.single_line? && offense?(block_node)
+
+          selector = node.loc.selector
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that only one `it_behaves_like` style is used.
+      #
+      # @example `EnforcedStyle: it_behaves_like` (default)
+      #   # bad
+      #   it_should_behave_like 'a foo'
+      #
+      #   # good
+      #   it_behaves_like 'a foo'
+      #
+      # @example `EnforcedStyle: it_should_behave_like`
+      #   # bad
+      #   it_behaves_like 'a foo'
+      #
+      #   # good
+      #   it_should_behave_like 'a foo'
+      #
+      class ItBehavesLike < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including ' \
+              'examples in a nested context.'
+        RESTRICT_ON_SEND = %i[it_behaves_like it_should_behave_like].freeze
+
+        # @!method example_inclusion_offense(node)
+        def_node_matcher :example_inclusion_offense, '(send _ % ...)'
+
+        def on_send(node)
+          example_inclusion_offense(node, alternative_style) do
+            add_offense(node) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
+          end
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, replacement: style, original: alternative_style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that `all` matcher is used instead of iterating over an array.
+      #
+      # @example
+      #   # bad
+      #   it 'validates users' do
+      #     [user1, user2, user3].each { |user| expect(user).to be_valid }
+      #   end
+      #
+      #   # good
+      #   it 'validates users' do
+      #     expect([user1, user2, user3]).to all(be_valid)
+      #   end
+      #
+      class IteratedExpectation < Base
+        MSG = 'Prefer using the `all` matcher instead ' \
+              'of iterating over an array.'
+
+        # @!method each?(node)
+        def_node_matcher :each?, <<~PATTERN
+          (block
+            (send ... :each)
+            (args (arg $_))
+            $(...)
+          )
+        PATTERN
+
+        # @!method each_numblock?(node)
+        def_node_matcher :each_numblock?, <<~PATTERN
+          (numblock
+            (send ... :each) _ $(...)
+          )
+        PATTERN
+
+        # @!method expectation?(node)
+        def_node_matcher :expectation?, <<~PATTERN
+          (send (send nil? :expect (lvar %)) :to ...)
+        PATTERN
+
+        def on_block(node)
+          each?(node) do |arg, body|
+            if single_expectation?(body, arg) || only_expectations?(body, arg)
+              add_offense(node.send_node)
+            end
+          end
+        end
+
+        def on_numblock(node)
+          each_numblock?(node) do |body|
+            if single_expectation?(body, :_1) || only_expectations?(body, :_1)
+              add_offense(node.send_node)
+            end
+          end
+        end
+
+        private
+
+        def single_expectation?(body, arg)
+          expectation?(body, arg)
+        end
+
+        def only_expectations?(body, arg)
+          return false unless body.each_child_node.any?
+
+          body.each_child_node.all? { |child| expectation?(child, arg) }
+        end
+      end
+    end
+  end
+end