rubocop-rspec 1.7.0 → 3.0.2

data/config/obsoletion.yml

@@ -0,0 +1,30 @@
+#
+# Configuration of obsolete/deprecated cops used by `ConfigObsoletion`.
+#
+# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
+#
+
+# Cop parameters that have been changed
+# Can be treated as a warning instead of a failure with `severity: warning`
+changed_parameters:
+  - cops:
+      - RSpec/VariableName
+    parameters: IgnoredPatterns
+    alternative: AllowedPatterns
+    severity: warning
+
+split:
+  RSpec/FilePath:
+    alternatives:
+      - RSpec/SpecFilePathFormat
+      - RSpec/SpecFilePathSuffix
+
+removed:
+  RSpec/Capybara/FeatureMethods:
+    reason: >
+      this cop has migrated to `RSpec/Dialect`. Please use `RSpec/Dialect` instead
+
+extracted:
+  RSpec/Rails/*: rubocop-rspec_rails
+  RSpec/FactoryBot/*: rubocop-factory_bot
+  RSpec/Capybara/*: rubocop-capybara

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that left braces for adjacent single line lets are aligned.
+      #
+      # @example
+      #   # bad
+      #   let(:foobar) { blahblah }
+      #   let(:baz) { bar }
+      #   let(:a) { b }
+      #
+      #   # good
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar }
+      #   let(:a)      { b }
+      #
+      class AlignLeftLetBrace < Base
+        extend AutoCorrector
+
+        MSG = 'Align left let brace'
+
+        def self.autocorrect_incompatible_with
+          [Layout::ExtraSpacing]
+        end
+
+        def on_new_investigation
+          super
+          return if processed_source.blank?
+
+          token_aligner.offending_tokens.each do |let|
+            add_offense(let.loc.begin) do |corrector|
+              corrector.insert_before(
+                let.loc.begin, token_aligner.indent_for(let)
+              )
+            end
+          end
+        end
+
+        private
+
+        def token_aligner
+          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that right braces for adjacent single line lets are aligned.
+      #
+      # @example
+      #   # bad
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar }
+      #   let(:a)      { b }
+      #
+      #   # good
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar      }
+      #   let(:a)      { b        }
+      #
+      class AlignRightLetBrace < Base
+        extend AutoCorrector
+
+        MSG = 'Align right let brace'
+
+        def self.autocorrect_incompatible_with
+          [Layout::ExtraSpacing]
+        end
+
+        def on_new_investigation
+          super
+          return if processed_source.blank?
+
+          token_aligner.offending_tokens.each do |let|
+            add_offense(let.loc.end) do |corrector|
+              corrector.insert_before(
+                let.loc.end, token_aligner.indent_for(let)
+              )
+            end
+          end
+        end
+
+        private
+
+        def token_aligner
+          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuboCop
   module Cop
     module RSpec
@@ -20,22 +22,17 @@ module RuboCop
       #       allow(my_instance).to receive(:foo)
       #     end
       #   end
-      class AnyInstance < Cop
-        include RuboCop::RSpec::SpecOnly
-
-        MESSAGE = 'Avoid stubbing using `%{method}`'.freeze
-
-        ANY_INSTANCE_METHODS = [
-          :any_instance,
-          :allow_any_instance_of,
-          :expect_any_instance_of
+      #
+      class AnyInstance < Base
+        MSG = 'Avoid stubbing using `%<method>s`.'
+        RESTRICT_ON_SEND = %i[
+          any_instance
+          allow_any_instance_of
+          expect_any_instance_of
         ].freeze
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless ANY_INSTANCE_METHODS.include?(method_name)
-
-          add_offense(node, :expression, MESSAGE % { method: method_name })
+          add_offense(node, message: format(MSG, method: node.method_name))
         end
       end
     end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that around blocks actually run the test.
+      #
+      # @example
+      #   # bad
+      #   around do
+      #     some_method
+      #   end
+      #
+      #   around do |test|
+      #     some_method
+      #   end
+      #
+      #   # good
+      #   around do |test|
+      #     some_method
+      #     test.call
+      #   end
+      #
+      #   around do |test|
+      #     some_method
+      #     test.run
+      #   end
+      #
+      class AroundBlock < Base
+        MSG_NO_ARG     = 'Test object should be passed to around block.'
+        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` ' \
+                         'or `%<arg>s.run`.'
+
+        # @!method hook_block(node)
+        def_node_matcher :hook_block, <<~PATTERN
+          (block (send nil? :around sym ?) (args $...) ...)
+        PATTERN
+
+        # @!method hook_numblock(node)
+        def_node_matcher :hook_numblock, <<~PATTERN
+          (numblock (send nil? :around sym ?) ...)
+        PATTERN
+
+        # @!method find_arg_usage(node)
+        def_node_search :find_arg_usage, <<~PATTERN
+          {(send $... {:call :run}) (send _ _ $...) (yield $...) (block-pass $...)}
+        PATTERN
+
+        def on_block(node)
+          hook_block(node) do |(example_proxy)|
+            if example_proxy.nil?
+              add_no_arg_offense(node)
+            else
+              check_for_unused_proxy(node, example_proxy)
+            end
+          end
+        end
+
+        def on_numblock(node)
+          hook_numblock(node) do
+            check_for_numblock(node)
+          end
+        end
+
+        private
+
+        def add_no_arg_offense(node)
+          add_offense(node, message: MSG_NO_ARG)
+        end
+
+        def check_for_unused_proxy(block, proxy)
+          name, = *proxy
+
+          find_arg_usage(block) do |usage|
+            return if usage.include?(s(:lvar, name))
+          end
+
+          add_offense(
+            proxy,
+            message: format(MSG_UNUSED_ARG, arg: name)
+          )
+        end
+
+        def check_for_numblock(block)
+          find_arg_usage(block) do |usage|
+            return if usage.include?(s(:lvar, :_1))
+          end
+
+          add_offense(
+            block.children.last,
+            message: format(MSG_UNUSED_ARG, arg: :_1)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # @abstract parent class to RSpec cops
+      class Base < ::RuboCop::Cop::Base
+        include RuboCop::RSpec::Language
+
+        exclude_from_registry
+
+        # Invoke the original inherited hook so our cops are recognized
+        def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
+          RuboCop::Cop::Base.inherited(subclass)
+        end
+
+        # Set the config for dynamic DSL configuration-aware helpers
+        # that have no other means of accessing the configuration.
+        def on_new_investigation
+          super
+          RuboCop::RSpec::Language.config = config['RSpec']['Language']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for expectations where `be` is used without argument.
+      #
+      # The `be` matcher is too generic, as it pass on everything that is not
+      # nil or false. If that is the exact intend, use `be_truthy`. In all other
+      # cases it's better to specify what exactly is the expected value.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be
+      #
+      #   # good
+      #   expect(foo).to be_truthy
+      #   expect(foo).to be 1.0
+      #   expect(foo).to be(true)
+      #
+      class Be < Base
+        MSG = "Don't use `be` without an argument."
+
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method be_without_args(node)
+        def_node_matcher :be_without_args, <<~PATTERN
+          (send _ #Runners.all $(send nil? :be))
+        PATTERN
+
+        def on_send(node)
+          be_without_args(node) do |matcher|
+            add_offense(matcher.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer using `be_empty` when checking for an empty array.
+      #
+      # @example
+      #   # bad
+      #   expect(array).to contain_exactly
+      #   expect(array).to match_array([])
+      #
+      #   # good
+      #   expect(array).to be_empty
+      #
+      class BeEmpty < Base
+        extend AutoCorrector
+
+        MSG = 'Use `be_empty` matchers for checking an empty array.'
+        RESTRICT_ON_SEND = %i[contain_exactly match_array].freeze
+
+        # @!method expect_array_matcher?(node)
+        def_node_matcher :expect_array_matcher?, <<~PATTERN
+          (send
+            (send nil? :expect _)
+            #Runners.all
+            ${
+              (send nil? :match_array (array))
+              (send nil? :contain_exactly)
+            }
+            _?
+          )
+        PATTERN
+
+        def on_send(node)
+          expect_array_matcher?(node.parent) do |expect|
+            add_offense(expect) do |corrector|
+              corrector.replace(expect, 'be_empty')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for expectations where `be(...)` can replace `eq(...)`.
+      #
+      # The `be` matcher compares by identity while the `eq` matcher compares
+      # using `==`. Booleans and nil can be compared by identity and therefore
+      # the `be` matcher is preferable as it is a more strict test.
+      #
+      # @safety
+      #   This cop is unsafe because it changes how values are compared.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to eq(true)
+      #   expect(foo).to eq(false)
+      #   expect(foo).to eq(nil)
+      #
+      #   # good
+      #   expect(foo).to be(true)
+      #   expect(foo).to be(false)
+      #   expect(foo).to be(nil)
+      #
+      class BeEq < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `be` over `eq`.'
+        RESTRICT_ON_SEND = %i[eq].freeze
+
+        # @!method eq_type_with_identity?(node)
+        def_node_matcher :eq_type_with_identity?, <<~PATTERN
+          (send nil? :eq {true false nil})
+        PATTERN
+
+        def on_send(node)
+          return unless eq_type_with_identity?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'be')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,21 +1,26 @@
+# frozen_string_literal: true
+
 module RuboCop
   module Cop
     module RSpec
       # Check for expectations where `be(...)` can replace `eql(...)`.
       #
       # The `be` matcher compares by identity while the `eql` matcher
-      # compares using `eql?`. Integers, floats, booleans, and symbols
+      # compares using `eql?`. Integers, floats, booleans, symbols, and nil
       # can be compared by identity and therefore the `be` matcher is
       # preferable as it is a more strict test.
       #
-      # @example
+      # @safety
+      #   This cop is unsafe because it changes how values are compared.
       #
+      # @example
       #   # bad
       #   expect(foo).to eql(1)
       #   expect(foo).to eql(1.0)
       #   expect(foo).to eql(true)
       #   expect(foo).to eql(false)
       #   expect(foo).to eql(:bar)
+      #   expect(foo).to eql(nil)
       #
       #   # good
       #   expect(foo).to be(1)
@@ -23,6 +28,7 @@ module RuboCop
       #   expect(foo).to be(true)
       #   expect(foo).to be(false)
       #   expect(foo).to be(:bar)
+      #   expect(foo).to be(nil)
       #
       # This cop only looks for instances of `expect(...).to eql(...)`. We
       # do not check `to_not` or `not_to` since `!eql?` is more strict
@@ -31,25 +37,22 @@ module RuboCop
       # necessarily the same type as `b` since the `#==` operator can
       # coerce objects for comparison.
       #
-      class BeEql < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::Cop::ConfigurableEnforcedStyle
+      class BeEql < Base
+        extend AutoCorrector
 
-        MSG = 'Prefer `be` over `eql`'.freeze
+        MSG = 'Prefer `be` over `eql`.'
+        RESTRICT_ON_SEND = %i[to].freeze
 
-        def_node_matcher :eql_type_with_identity, <<-PATTERN
-          (send _ :to $(send nil :eql {true false int float sym}))
+        # @!method eql_type_with_identity(node)
+        def_node_matcher :eql_type_with_identity, <<~PATTERN
+          (send _ :to $(send nil? :eql {true false int float sym nil}))
         PATTERN
 
         def on_send(node)
           eql_type_with_identity(node) do |eql|
-            add_offense(eql, :selector, MSG)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'be')
+            add_offense(eql.loc.selector) do |corrector|
+              corrector.replace(eql.loc.selector, 'be')
+            end
           end
         end
       end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensures a consistent style is used when matching `nil`.
+      #
+      # You can either use the more specific `be_nil` matcher, or the more
+      # generic `be` matcher with a `nil` argument.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: be_nil` (default)
+      #   # bad
+      #   expect(foo).to be(nil)
+      #
+      #   # good
+      #   expect(foo).to be_nil
+      #
+      # @example `EnforcedStyle: be`
+      #   # bad
+      #   expect(foo).to be_nil
+      #
+      #   # good
+      #   expect(foo).to be(nil)
+      #
+      class BeNil < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        BE_MSG = 'Prefer `be(nil)` over `be_nil`.'
+        BE_NIL_MSG = 'Prefer `be_nil` over `be(nil)`.'
+        RESTRICT_ON_SEND = %i[be be_nil].freeze
+
+        # @!method be_nil_matcher?(node)
+        def_node_matcher :be_nil_matcher?, <<~PATTERN
+          (send nil? :be_nil)
+        PATTERN
+
+        # @!method nil_value_expectation?(node)
+        def_node_matcher :nil_value_expectation?, <<~PATTERN
+          (send nil? :be nil)
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :be
+            check_be_style(node)
+          when :be_nil
+            check_be_nil_style(node)
+          end
+        end
+
+        private
+
+        def check_be_style(node)
+          return unless be_nil_matcher?(node)
+
+          add_offense(node, message: BE_MSG) do |corrector|
+            corrector.replace(node, 'be(nil)')
+          end
+        end
+
+        def check_be_nil_style(node)
+          return unless nil_value_expectation?(node)
+
+          add_offense(node, message: BE_NIL_MSG) do |corrector|
+            corrector.replace(node, 'be_nil')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that before/after(:all/:context) isn't being used.
+      #
+      # @example
+      #   # bad - Faster but risk of state leaking between examples
+      #   describe MyClass do
+      #     before(:all) { Widget.create }
+      #     after(:context) { Widget.delete_all }
+      #   end
+      #
+      #   # good - Slower but examples are properly isolated
+      #   describe MyClass do
+      #     before(:each) { Widget.create }
+      #     after(:each) { Widget.delete_all }
+      #   end
+      #
+      class BeforeAfterAll < Base
+        MSG = 'Beware of using `%<hook>s` as it may cause state to leak ' \
+              'between tests. If you are using `rspec-rails`, and ' \
+              '`use_transactional_fixtures` is enabled, then records created ' \
+              'in `%<hook>s` are not automatically rolled back.'
+
+        RESTRICT_ON_SEND = Set[:before, :after].freeze
+
+        # @!method before_or_after_all(node)
+        def_node_matcher :before_or_after_all, <<~PATTERN
+          $(send _ RESTRICT_ON_SEND (sym {:all :context}))
+        PATTERN
+
+        def on_send(node)
+          before_or_after_all(node) do |hook|
+            add_offense(
+              node,
+              message: format(MSG, hook: hook.source)
+            )
+          end
+        end
+      end
+    end
+  end
+end