rubocop-rspec 1.7.0 → 3.0.2

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

@@ -3,55 +3,83 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks for `subject` definitions that come after `let` definitions.
+      # Enforce that subject is the first definition in the test.
       #
       # @example
       #   # bad
-      #   RSpec.describe User do
-      #     let(:params) { blah }
-      #     subject { described_class.new(params) }
+      #   let(:params) { blah }
+      #   subject { described_class.new(params) }
       #
-      #     it 'is valid' do
-      #       expect(subject.valid?).to be(true)
-      #     end
-      #   end
+      #   before { do_something }
+      #   subject { described_class.new(params) }
+      #
+      #   it { expect_something }
+      #   subject { described_class.new(params) }
+      #   it { expect_something_else }
+      #
+      #
+      #   # good
+      #   subject { described_class.new(params) }
+      #   let(:params) { blah }
       #
       #   # good
-      #   RSpec.describe User do
-      #     subject { described_class.new(params) }
+      #   subject { described_class.new(params) }
+      #   before { do_something }
       #
-      #     let(:params) { blah }
+      #   # good
+      #   subject { described_class.new(params) }
+      #   it { expect_something }
+      #   it { expect_something_else }
       #
-      #     it 'is valid' do
-      #       expect(subject.valid?).to be(true)
-      #     end
-      #   end
-      class LeadingSubject < Cop
-        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
+      class LeadingSubject < Base
+        extend AutoCorrector
+        include InsideExampleGroup
 
-        MSG = 'Declare `subject` above any other `let` declarations'.freeze
+        MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
-        def_node_matcher :subject?, '(block $(send nil :subject ...) args ...)'
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless subject?(node)
+          return unless inside_example_group?(node)
 
-        def on_block(node)
-          return unless subject?(node) && !in_spec_block?(node)
+          check_previous_nodes(node)
+        end
 
-          node.parent.each_child_node do |sibling|
-            break if sibling.equal?(node)
+        private
 
-            if sibling.method_name.equal?(:let)
-              break add_offense(node, :expression)
+        def check_previous_nodes(node)
+          offending_node(node) do |offender|
+            msg = format(MSG, offending: offender.method_name)
+            add_offense(node, message: msg) do |corrector|
+              autocorrect(corrector, node, offender)
             end
           end
         end
 
-        private
+        def offending_node(node)
+          parent(node).each_child_node.find do |sibling|
+            break if sibling.equal?(node)
 
-        def in_spec_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            Examples::ALL.include?(ancestor.method_name)
+            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(sibling)
+        end
+
+        def offending?(node)
+          let?(node) ||
+            hook?(node) ||
+            example?(node) ||
+            spec_group?(node) ||
+            include?(node)
+        end
       end
     end
   end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that no class, module, or constant is declared.
+      #
+      # Constants, including classes and modules, when declared in a block
+      # scope, are defined in global namespace, and leak between examples.
+      #
+      # If several examples may define a `DummyClass`, instead of being a
+      # blank slate class as it will be in the first example, subsequent
+      # examples will be reopening it and modifying its behavior in
+      # unpredictable ways.
+      # Even worse when a class that exists in the codebase is reopened.
+      #
+      # Anonymous classes are fine, since they don't result in global
+      # namespace name clashes.
+      #
+      # @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants
+      #
+      # @example Constants leak between examples
+      #   # bad
+      #   describe SomeClass do
+      #     OtherClass = Struct.new
+      #     CONSTANT_HERE = 'I leak into global namespace'
+      #   end
+      #
+      #   # good
+      #   describe SomeClass do
+      #     before do
+      #       stub_const('OtherClass', Struct.new)
+      #       stub_const('CONSTANT_HERE', 'I only exist during this example')
+      #     end
+      #   end
+      #
+      # @example
+      #   # bad
+      #   describe SomeClass do
+      #     class FooClass < described_class
+      #       def double_that
+      #         some_base_method * 2
+      #       end
+      #     end
+      #
+      #     it { expect(FooClass.new.double_that).to eq(4) }
+      #   end
+      #
+      #   # good - anonymous class, no constant needs to be defined
+      #   describe SomeClass do
+      #     let(:foo_class) do
+      #       Class.new(described_class) do
+      #         def double_that
+      #           some_base_method * 2
+      #         end
+      #       end
+      #     end
+      #
+      #     it { expect(foo_class.new.double_that).to eq(4) }
+      #   end
+      #
+      #   # good - constant is stubbed
+      #   describe SomeClass do
+      #     before do
+      #       foo_class = Class.new(described_class) do
+      #                     def do_something
+      #                     end
+      #                   end
+      #       stub_const('FooClass', foo_class)
+      #     end
+      #
+      #     it { expect(FooClass.new.double_that).to eq(4) }
+      #   end
+      #
+      # @example
+      #   # bad
+      #   describe SomeClass do
+      #     module SomeModule
+      #       class SomeClass
+      #         def do_something
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe SomeClass do
+      #     before do
+      #       foo_class = Class.new(described_class) do
+      #                     def do_something
+      #                     end
+      #                   end
+      #       stub_const('SomeModule::SomeClass', foo_class)
+      #     end
+      #   end
+      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.'
+
+        def on_casgn(node)
+          return unless inside_describe_block?(node)
+
+          add_offense(node, message: MSG_CONST)
+        end
+
+        def on_class(node)
+          return unless inside_describe_block?(node)
+
+          add_offense(node, message: MSG_CLASS)
+        end
+
+        def on_module(node)
+          return unless inside_describe_block?(node)
+
+          add_offense(node, message: MSG_MODULE)
+        end
+
+        private
+
+        def inside_describe_block?(node)
+          node.each_ancestor(:block).any? { |ancestor| spec_group?(ancestor) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `let` definitions that come after an example.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) { bar }
+      #
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      #   let(:some) { other }
+      #
+      #   it 'checks what some does' do
+      #     expect(some).to be
+      #   end
+      #
+      #   # good
+      #   let(:foo) { bar }
+      #   let(:some) { other }
+      #
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      #   it 'checks what some does' do
+      #     expect(some).to be
+      #   end
+      class LetBeforeExamples < Base
+        extend AutoCorrector
+
+        MSG = 'Move `let` before the examples in the group.'
+
+        # @!method example_or_group?(node)
+        def_node_matcher :example_or_group?, <<~PATTERN
+          {
+            (block (send nil? {#ExampleGroups.all #Examples.all} ...) ...)
+            (send nil? #Includes.examples ...)
+          }
+        PATTERN
+
+        # @!method include_examples?(node)
+        def_node_matcher :include_examples?, <<~PATTERN
+          {
+            (block (send nil? :include_examples ...) ...)
+            (send nil? :include_examples ...)
+          }
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [RSpec::ScatteredLet]
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group_with_body?(node)
+
+          check_let_declarations(node.body) if multiline_block?(node.body)
+        end
+
+        private
+
+        def example_group_with_include_examples?(body)
+          body.children.any? { |sibling| include_examples?(sibling) }
+        end
+
+        def multiline_block?(block)
+          block.begin_type?
+        end
+
+        def check_let_declarations(node)
+          first_example = find_first_example(node)
+          return unless first_example
+
+          correct = !example_group_with_include_examples?(node)
+
+          first_example.right_siblings.each do |sibling|
+            next unless let?(sibling)
+
+            add_offense(sibling) do |corrector|
+              autocorrect(corrector, sibling, first_example) if correct
+            end
+          end
+        end
+
+        def find_first_example(node)
+          node.children.find { |sibling| example_or_group?(sibling) }
+        end
+
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
+        end
+      end
+    end
+  end
+end

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

@@ -6,50 +6,66 @@ module RuboCop
       # Checks unreferenced `let!` calls being used for test setup.
       #
       # @example
-      #   # Bad
+      #   # bad
       #   let!(:my_widget) { create(:widget) }
       #
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
       #
-      #   # Good
+      #   # good
       #   it 'counts widgets' do
       #     create(:widget)
       #     expect(Widget.count).to eq(1)
       #   end
       #
-      #   # Good
+      #   # good
       #   before { create(:widget) }
       #
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
-      class LetSetup < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Language,
-                RuboCop::RSpec::Language::NodePattern
+      class LetSetup < Base
+        MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
-        MSG = 'Do not use `let!` for test setup.'.freeze
+        # @!method example_or_shared_group_or_including?(node)
+        def_node_matcher :example_or_shared_group_or_including?, <<~PATTERN
+          (block {
+            (send #rspec? {#SharedGroups.all #ExampleGroups.all} ...)
+            (send nil? #Includes.all ...)
+          } ...)
+        PATTERN
 
-        def_node_search :let_bang, '(block $(send nil :let! (sym $_)) args ...)'
+        # @!method let_bang(node)
+        def_node_matcher :let_bang, <<~PATTERN
+          {
+            (block $(send nil? :let! {(sym $_) (str $_)}) ...)
+            $(send nil? :let! {(sym $_) (str $_)} block_pass)
+          }
+        PATTERN
 
-        def_node_search :method_called?, '(send nil %)'
+        # @!method method_called?(node)
+        def_node_search :method_called?, '(send nil? %)'
 
-        def on_block(node)
-          return unless example_group?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_or_shared_group_or_including?(node)
 
           unused_let_bang(node) do |let|
-            add_offense(let, :expression)
+            add_offense(let)
           end
         end
 
         private
 
         def unused_let_bang(node)
-          let_bang(node) do |method_send, method_name|
-            yield(method_send) unless method_called?(node, method_name)
+          child_let_bang(node) do |method_send, method_name|
+            yield(method_send) unless method_called?(node, method_name.to_sym)
+          end
+        end
+
+        def child_let_bang(node, &block)
+          RuboCop::RSpec::ExampleGroup.new(node).lets.each do |let|
+            let_bang(let, &block)
           end
         end
       end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks where `match_array` is used.
+      #
+      # This cop checks for the following:
+      # - Prefer `contain_exactly` when matching an array with values.
+      # - Prefer `eq` when using `match_array` with an empty array literal.
+      #
+      # @example
+      #   # bad
+      #   it { is_expected.to match_array([content1, content2]) }
+      #
+      #   # good
+      #   it { is_expected.to contain_exactly(content1, content2) }
+      #
+      #   # good
+      #   it { is_expected.to match_array([content] + array) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+      #
+      class MatchArray < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `contain_exactly` when matching an array literal.'
+        RESTRICT_ON_SEND = %i[match_array].freeze
+
+        # @!method match_array_with_empty_array?(node)
+        def_node_matcher :match_array_with_empty_array?, <<~PATTERN
+          (send nil? :match_array (array))
+        PATTERN
+
+        def on_send(node)
+          return unless node.first_argument&.array_type?
+          return if match_array_with_empty_array?(node)
+
+          check_populated_array(node)
+        end
+
+        private
+
+        def check_populated_array(node)
+          return if node.first_argument.percent_literal?
+
+          add_offense(node) do |corrector|
+            array_contents = node.arguments.flat_map(&:to_a)
+            corrector.replace(
+              node,
+              "contain_exactly(#{array_contents.map(&:source).join(', ')})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuboCop
   module Cop
     module RSpec
@@ -7,25 +9,18 @@ module RuboCop
       #   # bad
       #   allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
       #
-      #   # better
+      #   # good
       #   thing = Thing.new(baz: 42)
-      #   allow(foo).to receive(bar: thing)
+      #   allow(foo).to receive(:bar).and_return(thing)
       #
-      class MessageChain < Cop
-        include RuboCop::RSpec::SpecOnly
-
-        MESSAGE = 'Avoid stubbing using `%<method>s`'.freeze
-
-        MESSAGE_CHAIN_METHODS = [
-          :receive_message_chain,
-          :stub_chain
-        ].freeze
+      class MessageChain < Base
+        MSG = 'Avoid stubbing using `%<method>s`.'
+        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless MESSAGE_CHAIN_METHODS.include?(method_name)
-
-          add_offense(node, :selector, MESSAGE % { method: method_name })
+          add_offense(
+            node.loc.selector, message: format(MSG, method: node.method_name)
+          )
         end
       end
     end

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

@@ -8,7 +8,7 @@ module RuboCop
       # This cop can be configured in your configuration using the
       # `EnforcedStyle` option and supports `--auto-gen-config`.
       #
-      # @example `EnforcedStyle: allow`
+      # @example `EnforcedStyle: allow` (default)
       #
       #   # bad
       #   expect(foo).to receive(:bar)
@@ -24,24 +24,27 @@ module RuboCop
       #   # good
       #   expect(foo).to receive(:bar)
       #
-      class MessageExpectation < Cop
-        include RuboCop::RSpec::SpecOnly, ConfigurableEnforcedStyle
+      class MessageExpectation < Base
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%s` for setting message expectations.'.freeze
+        MSG = 'Prefer `%<style>s` for setting message expectations.'
 
-        SUPPORTED_STYLES = %w(allow expect).freeze
+        RESTRICT_ON_SEND = %i[to].freeze
 
-        def_node_matcher :message_expectation, <<-PATTERN
-          (send $(send nil {:expect :allow} ...) :to #receive_message?)
+        # @!method message_expectation(node)
+        def_node_matcher :message_expectation, <<~PATTERN
+          (send $(send nil? {:expect :allow} ...) :to #receive_message?)
         PATTERN
 
-        def_node_search :receive_message?, '(send nil :receive ...)'
+        # @!method receive_message?(node)
+        def_node_search :receive_message?, '(send nil? :receive ...)'
 
         def on_send(node)
           message_expectation(node) do |match|
             return correct_style_detected if preferred_style?(match)
 
-            add_offense(match, :selector, MSG % style) do
+            message = format(MSG, style: style)
+            add_offense(match.loc.selector, message: message) do
               opposite_style_detected
             end
           end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that message expectations are set using spies.
+      #
+      # This cop can be configured in your configuration using the
+      # `EnforcedStyle` option and supports `--auto-gen-config`.
+      #
+      # @example `EnforcedStyle: have_received` (default)
+      #
+      #   # bad
+      #   expect(foo).to receive(:bar)
+      #   do_something
+      #
+      #   # good
+      #   allow(foo).to receive(:bar) # or use instance_spy
+      #   do_something
+      #   expect(foo).to have_received(:bar)
+      #
+      # @example `EnforcedStyle: receive`
+      #
+      #   # bad
+      #   allow(foo).to receive(:bar)
+      #   do_something
+      #   expect(foo).to have_received(:bar)
+      #
+      #   # good
+      #   expect(foo).to receive(:bar)
+      #   do_something
+      #
+      class MessageSpies < Base
+        include ConfigurableEnforcedStyle
+
+        MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
+
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
+                            'expectations. Setup `%<source>s` as a spy using ' \
+                            '`allow` or `instance_spy`.'
+
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method message_expectation(node)
+        def_node_matcher :message_expectation, %(
+          (send (send nil? :expect $_) #Runners.all ...)
+        )
+
+        # @!method receive_message(node)
+        def_node_search :receive_message, %(
+          $(send nil? {:receive :have_received} ...)
+        )
+
+        def on_send(node)
+          receive_message_matcher(node) do |receiver, message_matcher|
+            return correct_style_detected if preferred_style?(message_matcher)
+
+            add_offense(
+              message_matcher.loc.selector,
+              message: error_message(receiver)
+            ) { opposite_style_detected }
+          end
+        end
+
+        private
+
+        def receive_message_matcher(node)
+          return unless (receiver = message_expectation(node))
+
+          receive_message(node) { |match| yield(receiver, match) }
+        end
+
+        def preferred_style?(expectation)
+          expectation.method_name.equal?(style)
+        end
+
+        def error_message(receiver)
+          case style
+          when :receive
+            MSG_RECEIVE
+          when :have_received
+            format(MSG_HAVE_RECEIVED, source: receiver.source)
+          end
+        end
+      end
+    end
+  end
+end