rubocop-rspec 1.6.0 → 1.7.0

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `subject` definitions that come after `let` definitions.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe User do
+      #     let(:params) { blah }
+      #     subject { described_class.new(params) }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe User do
+      #     subject { described_class.new(params) }
+      #
+      #     let(:params) { blah }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      class LeadingSubject < Cop
+        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
+
+        MSG = 'Declare `subject` above any other `let` declarations'.freeze
+
+        def_node_matcher :subject?, '(block $(send nil :subject ...) args ...)'
+
+        def on_block(node)
+          return unless subject?(node) && !in_spec_block?(node)
+
+          node.parent.each_child_node do |sibling|
+            break if sibling.equal?(node)
+
+            if sibling.method_name.equal?(:let)
+              break add_offense(node, :expression)
+            end
+          end
+        end
+
+        private
+
+        def in_spec_block?(node)
+          node.each_ancestor(:block).any? do |ancestor|
+            Examples::ALL.include?(ancestor.method_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks unreferenced `let!` calls being used for test setup.
+      #
+      # @example
+      #   # Bad
+      #   let!(:my_widget) { create(:widget) }
+      #
+      #   it 'counts widgets' do
+      #     expect(Widget.count).to eq(1)
+      #   end
+      #
+      #   # Good
+      #   it 'counts widgets' do
+      #     create(:widget)
+      #     expect(Widget.count).to eq(1)
+      #   end
+      #
+      #   # 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
+
+        MSG = 'Do not use `let!` for test setup.'.freeze
+
+        def_node_search :let_bang, '(block $(send nil :let! (sym $_)) args ...)'
+
+        def_node_search :method_called?, '(send nil %)'
+
+        def on_block(node)
+          return unless example_group?(node)
+
+          unused_let_bang(node) do |let|
+            add_offense(let, :expression)
+          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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that chains of messages are not being stubbed.
+      #
+      # @example
+      #   # bad
+      #   allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
+      #
+      #   # better
+      #   thing = Thing.new(baz: 42)
+      #   allow(foo).to receive(bar: thing)
+      #
+      class MessageChain < Cop
+        include RuboCop::RSpec::SpecOnly
+
+        MESSAGE = 'Avoid stubbing using `%<method>s`'.freeze
+
+        MESSAGE_CHAIN_METHODS = [
+          :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 })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for consistent message expectation style.
+      #
+      # This cop can be configured in your configuration using the
+      # `EnforcedStyle` option and supports `--auto-gen-config`.
+      #
+      # @example `EnforcedStyle: allow`
+      #
+      #   # bad
+      #   expect(foo).to receive(:bar)
+      #
+      #   # good
+      #   allow(foo).to receive(:bar)
+      #
+      # @example `EnforcedStyle: expect`
+      #
+      #   # bad
+      #   allow(foo).to receive(:bar)
+      #
+      #   # good
+      #   expect(foo).to receive(:bar)
+      #
+      class MessageExpectation < Cop
+        include RuboCop::RSpec::SpecOnly, ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%s` for setting message expectations.'.freeze
+
+        SUPPORTED_STYLES = %w(allow expect).freeze
+
+        def_node_matcher :message_expectation, <<-PATTERN
+          (send $(send nil {:expect :allow} ...) :to #receive_message?)
+        PATTERN
+
+        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
+              opposite_style_detected
+            end
+          end
+        end
+
+        private
+
+        def preferred_style?(expectation)
+          expectation.method_name.equal?(style)
+        end
+      end
+    end
+  end
+end

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

@@ -3,25 +3,28 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks for multiple top level describes. They should be nested if it is
-      # for the same class or module or seperated into different files.
+      # Checks for multiple top level describes.
+      #
+      # Multiple descriptions for the same class or module should either
+      # be nested or separated into different test files.
       #
       # @example
       #   # bad
-      #   describe MyClass, '.do_someting' do
+      #   describe MyClass, '.do_something' do
       #   end
-      #   describe MyClass, '.do_someting_else' do
+      #   describe MyClass, '.do_something_else' do
       #   end
       #
       #   #good
       #   describe MyClass
-      #     describe '.do_someting' do
+      #     describe '.do_something' do
       #     end
-      #     describe '.do_someting_else' do
+      #     describe '.do_something_else' do
       #     end
       #   end
       class MultipleDescribes < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::RSpec::TopLevelDescribe
 
         MSG = 'Do not use multiple top level describes - ' \
               'try to nest them.'.freeze

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if examples contain too many `expect` calls.
+      #
+      # @see http://betterspecs.org/#single Single expectation test
+      #
+      # This cop is configurable using the `Max` option
+      # and works with `--auto-gen-config`.
+      #
+      # @example
+      #
+      #   # bad
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe UserCreator do
+      #     it 'sets the users name' do
+      #       expect(user.name).to eq("John")
+      #     end
+      #
+      #     it 'sets the users age'
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
+      #
+      # @example configuration
+      #
+      #   # .rubocop.yml
+      #   RSpec/MultipleExpectations:
+      #     Max: 2
+      #
+      #   # not flagged by rubocop
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
+      #
+      class MultipleExpectations < Cop
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::RSpec::Language,
+                ConfigurableMax
+
+        MSG = 'Too many expectations.'.freeze
+
+        def_node_matcher :example?, <<-PATTERN
+          (block (send _ {#{Examples::ALL.to_node_pattern}} ...) ...)
+        PATTERN
+
+        def_node_search :expect, '(send _ :expect ...)'
+
+        def on_block(node)
+          return unless example?(node) && (expectations = expect(node))
+
+          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
+
+          add_offense(
+            method,
+            :expression,
+            MSG % { total: expectation_count, max: max_expectations }
+          )
+        end
+
+        def max_expectations
+          Integer(cop_config.fetch(parameter_name, 1))
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,14 @@
 module RuboCop
   module Cop
     module RSpec
-      # Give `subject` a descriptive name if you reference it directly
+      # 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.
       #
       # @example
       #   # bad
@@ -31,6 +38,8 @@ module RuboCop
       #     it { should be_valid }
       #   end
       class NamedSubject < Cop
+        include RuboCop::RSpec::SpecOnly
+
         MSG = 'Name your test subject if '\
               'you need to reference it explicitly.'.freeze
 

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for nested example groups.
+      #
+      # This cop is configurable using the `MaxNesting` option
+      #
+      # @example
+      #   # bad
+      #   context 'when using some feature' do
+      #     let(:some)    { :various }
+      #     let(:feature) { :setup   }
+      #
+      #     context 'when user is signed in' do  # flagged by rubocop
+      #       let(:user) do
+      #         UserCreate.call(user_attributes)
+      #       end
+      #
+      #       let(:user_attributes) do
+      #         {
+      #           name: 'John',
+      #           age:  22
+      #           role: role
+      #         }
+      #       end
+      #
+      #       context 'when user is an admin' do # flagged by rubocop
+      #         let(:role) { 'admin' }
+      #
+      #         it 'blah blah'
+      #         it 'yada yada'
+      #       end
+      #     end
+      #   end
+      #
+      #   # better
+      #   context 'using some feature as an admin' do
+      #     let(:some)    { :various }
+      #     let(:feature) { :setup   }
+      #
+      #     let(:user) do
+      #       UserCreate.call(
+      #         name: 'John',
+      #         age:  22
+      #         role: 'admin'
+      #       )
+      #     end
+      #
+      #     it 'blah blah'
+      #     it 'yada yada'
+      #   end
+      #
+      # @example configuration
+      #
+      #   # .rubocop.yml
+      #   RSpec/NestedGroups:
+      #     MaxNesting: 2
+      #
+      #   context 'when using some feature' do
+      #     let(:some)    { :various }
+      #     let(:feature) { :setup   }
+      #
+      #     context 'when user is signed in' do
+      #       let(:user) do
+      #         UserCreate.call(user_attributes)
+      #       end
+      #
+      #       let(:user_attributes) do
+      #         {
+      #           name: 'John',
+      #           age:  22
+      #           role: role
+      #         }
+      #       end
+      #
+      #       context 'when user is an admin' do # flagged by rubocop
+      #         let(:role) { 'admin' }
+      #
+      #         it 'blah blah'
+      #         it 'yada yada'
+      #       end
+      #     end
+      #   end
+      #
+      class NestedGroups < Cop
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::RSpec::TopLevelDescribe,
+                RuboCop::RSpec::Language
+
+        MSG = 'Maximum example group nesting exceeded'.freeze
+
+        def_node_search :find_contexts, <<-PATTERN
+          (block (send nil {#{ExampleGroups::ALL.to_node_pattern}} ...) (args) ...)
+        PATTERN
+
+        def on_block(node)
+          describe, = described_constant(node)
+          return unless describe
+
+          find_nested_contexts(node) do |context|
+            add_offense(context.children.first, :expression)
+          end
+        end
+
+        private
+
+        def find_nested_contexts(node, nesting: 1, &block)
+          find_contexts(node) do |nested_context|
+            yield(nested_context) if nesting > max_nesting
+
+            nested_context.each_child_node do |child|
+              find_nested_contexts(child, nesting: nesting + 1, &block)
+            end
+          end
+        end
+
+        def max_nesting
+          Integer(cop_config.fetch('MaxNesting', 2))
+        end
+      end
+    end
+  end
+end