rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Description should be descriptive.
+      #
+      # If example group or example contains only `execute string`, numbers
+      # and regular expressions, the description is not clear.
+      #
+      # @example
+      #   # bad
+      #   describe `time` do
+      #    # ...
+      #   end
+      #
+      #   # bad
+      #   context /when foo/ do
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   it 10000 do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe '#foo' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context "when #{foo} is bar" do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     # ...
+      #   end
+      #
+      class UndescriptiveLiteralsDescription < Base
+        MSG = 'Description should be descriptive.'
+
+        # @!method example_groups_or_example?(node)
+        def_node_matcher :example_groups_or_example?, <<~PATTERN
+          (block (send #rspec? {#ExampleGroups.all #Examples.all} $_) ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          example_groups_or_example?(node) do |arg|
+            add_offense(arg) if offense?(arg)
+          end
+        end
+
+        private
+
+        def offense?(node)
+          %i[xstr int regexp].include?(node.type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for a specified error in checking raised errors.
+      #
+      # Enforces one of an Exception type, a string, or a regular
+      # expression to match against the exception message as a parameter
+      # to `raise_error`
+      #
+      # @example
+      #   # bad
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error
+      #
+      #   # good
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error(StandardError)
+      #
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error('error')
+      #
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error(/err/)
+      #
+      #   expect { do_something }.not_to raise_error
+      #
+      class UnspecifiedException < Base
+        MSG = 'Specify the exception being captured'
+        RESTRICT_ON_SEND = %i[to].freeze
+
+        # @!method empty_raise_error_or_exception(node)
+        def_node_matcher :empty_raise_error_or_exception, <<~PATTERN
+          (send
+            (block
+                (send nil? :expect) ...)
+            :to
+            (send nil? {:raise_error :raise_exception})
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless empty_exception_matcher?(node)
+
+          add_offense(node.children.last)
+        end
+
+        private
+
+        def empty_exception_matcher?(node)
+          empty_raise_error_or_exception(node) && !block_with_args?(node.parent)
+        end
+
+        def block_with_args?(node)
+          return false unless node&.block_type?
+
+          node.arguments?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that memoized helpers names are symbols or strings.
+      #
+      # @example EnforcedStyle: symbols (default)
+      #   # bad
+      #   subject('user') { create_user }
+      #   let('user_name') { 'Adam' }
+      #
+      #   # good
+      #   subject(:user) { create_user }
+      #   let(:user_name) { 'Adam' }
+      #
+      # @example EnforcedStyle: strings
+      #   # bad
+      #   subject(:user) { create_user }
+      #   let(:user_name) { 'Adam' }
+      #
+      #   # good
+      #   subject('user') { create_user }
+      #   let('user_name') { 'Adam' }
+      #
+      class VariableDefinition < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include Variable
+        include InsideExampleGroup
+
+        MSG = 'Use %<style>s for variable names.'
+
+        def on_send(node)
+          return unless inside_example_group?(node)
+
+          variable_definition?(node) do |variable|
+            next unless style_offense?(variable)
+
+            add_offense(
+              variable,
+              message: format(MSG, style: style)
+            ) do |corrector|
+              corrector.replace(variable, correct_variable(variable))
+            end
+          end
+        end
+
+        private
+
+        def correct_variable(variable)
+          case variable.type
+          when :dsym
+            variable.source[1..]
+          when :sym
+            variable.value.to_s.inspect
+          else
+            variable.value.to_sym.inspect
+          end
+        end
+
+        def style_offense?(variable)
+          (style == :symbols && string?(variable)) ||
+            (style == :strings && symbol?(variable))
+        end
+
+        def string?(node)
+          node.str_type?
+        end
+
+        def symbol?(node)
+          node.sym_type? || node.dsym_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that memoized helper names use the configured style.
+      #
+      # Variables can be excluded from checking using the `AllowedPatterns`
+      # option.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   subject(:userName1) { 'Adam' }
+      #   let(:userName2) { 'Adam' }
+      #
+      #   # good
+      #   subject(:user_name_1) { 'Adam' }
+      #   let(:user_name_2) { 'Adam' }
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   subject(:user_name_1) { 'Adam' }
+      #   let(:user_name_2) { 'Adam' }
+      #
+      #   # good
+      #   subject(:userName1) { 'Adam' }
+      #   let(:userName2) { 'Adam' }
+      #
+      # @example AllowedPatterns configuration
+      #   # rubocop.yml
+      #   # RSpec/VariableName:
+      #   #   EnforcedStyle: snake_case
+      #   #   AllowedPatterns:
+      #   #     - ^userFood
+      #
+      # @example
+      #   # okay because it matches the `^userFood` regex in `AllowedPatterns`
+      #   subject(:userFood_1) { 'spaghetti' }
+      #   let(:userFood_2) { 'fettuccine' }
+      #
+      class VariableName < Base
+        include ConfigurableNaming
+        include AllowedPattern
+        include Variable
+        include InsideExampleGroup
+
+        MSG = 'Use %<style>s for variable names.'
+
+        def on_send(node)
+          return unless inside_example_group?(node)
+
+          variable_definition?(node) do |variable|
+            return if variable.dstr_type? || variable.dsym_type?
+            return if matches_allowed_pattern?(variable.value)
+
+            check_name(node, variable.value, variable.source_range)
+          end
+        end
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for consistent verified double reference style.
+      #
+      # Only investigates references that are one of the supported styles.
+      #
+      # @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+      #
+      # This cop can be configured in your configuration using the
+      # `EnforcedStyle` option and supports `--auto-gen-config`.
+      #
+      # @example `EnforcedStyle: constant` (default)
+      #   # bad
+      #   let(:foo) do
+      #     instance_double('ClassName', method_name: 'returned_value')
+      #   end
+      #
+      #   # good
+      #   let(:foo) do
+      #     instance_double(ClassName, method_name: 'returned_value')
+      #   end
+      #
+      # @example `EnforcedStyle: string`
+      #   # bad
+      #   let(:foo) do
+      #     instance_double(ClassName, method_name: 'returned_value')
+      #   end
+      #
+      #   # good
+      #   let(:foo) do
+      #     instance_double('ClassName', method_name: 'returned_value')
+      #   end
+      #
+      # @example Reference is not in the supported style list. No enforcement
+      #
+      #   # good
+      #   let(:foo) do
+      #     instance_double(@klass, method_name: 'returned_value')
+      #   end
+      class VerifiedDoubleReference < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use a %<style>s class reference for verified doubles.'
+
+        RESTRICT_ON_SEND = Set[
+          :class_double,
+          :class_spy,
+          :instance_double,
+          :instance_spy,
+          :mock_model,
+          :object_double,
+          :object_spy,
+          :stub_model
+        ].freeze
+
+        REFERENCE_TYPE_STYLES = {
+          str: :string,
+          const: :constant
+        }.freeze
+
+        # @!method verified_double(node)
+        def_node_matcher :verified_double, <<~PATTERN
+          (send
+            nil?
+            RESTRICT_ON_SEND
+            $_class_reference
+            ...)
+        PATTERN
+
+        def on_send(node)
+          verified_double(node) do |class_reference|
+            break correct_style_detected unless opposing_style?(class_reference)
+
+            message = format(MSG, style: style)
+            expression = class_reference.source_range
+
+            add_offense(expression, message: message) do |corrector|
+              offense = class_reference.source
+              corrector.replace(expression, correct_style(offense))
+
+              opposite_style_detected
+            end
+          end
+        end
+
+        private
+
+        def opposing_style?(class_reference)
+          class_reference_style = REFERENCE_TYPE_STYLES[class_reference.type]
+
+          # Only enforce supported styles
+          return false unless class_reference_style
+
+          class_reference_style != style
+        end
+
+        def correct_style(offense)
+          if style == :string
+            "'#{offense}'"
+          else
+            offense.gsub(/^['"]|['"]$/, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,32 +5,46 @@ module RuboCop
     module RSpec
       # Prefer using verifying doubles over normal doubles.
       #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
+      # @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
       #
       # @example
       #   # bad
-      #   it '...' do
-      #     widget = double("Widget")
+      #   let(:foo) do
+      #     double(method_name: 'returned value')
+      #   end
+      #
+      #   # bad
+      #   let(:foo) do
+      #     double("ClassName", method_name: 'returned value')
       #   end
       #
       #   # good
-      #   it '...' do
-      #     widget = instance_double("Widget")
+      #   let(:foo) do
+      #     instance_double("ClassName", method_name: 'returned value')
       #   end
-      class VerifiedDoubles < Cop
-        include RuboCop::RSpec::SpecOnly
-
-        MSG = 'Prefer using verifying doubles over normal doubles.'.freeze
+      #
+      class VerifiedDoubles < Base
+        MSG = 'Prefer using verifying doubles over normal doubles.'
+        RESTRICT_ON_SEND = %i[double spy].freeze
 
-        def_node_matcher :unverified_double, <<-PATTERN
-          {(send nil {:double :spy} $_ ...) }
+        # @!method unverified_double(node)
+        def_node_matcher :unverified_double, <<~PATTERN
+          {(send nil? {:double :spy} $...)}
         PATTERN
 
         def on_send(node)
-          return unless (name = unverified_double(node))
-          return if name.type.equal?(:sym) && cop_config['IgnoreSymbolicNames']
+          unverified_double(node) do |name, *_args|
+            return if name.nil? && cop_config['IgnoreNameless']
+            return if symbol?(name) && cop_config['IgnoreSymbolicNames']
+
+            add_offense(node)
+          end
+        end
+
+        private
 
-          add_offense(node, :expression)
+        def symbol?(name)
+          name&.sym_type?
         end
       end
     end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks void `expect()`.
+      #
+      # @example
+      #   # bad
+      #   expect(something)
+      #
+      #   # good
+      #   expect(something).to be(1)
+      #
+      class VoidExpect < Base
+        MSG = 'Do not use `expect()` without `.to` or `.not_to`. ' \
+              'Chain the methods or remove it.'
+        RESTRICT_ON_SEND = %i[expect].freeze
+
+        # @!method expect?(node)
+        def_node_matcher :expect?, <<~PATTERN
+          (send nil? :expect ...)
+        PATTERN
+
+        # @!method expect_block?(node)
+        def_node_matcher :expect_block?, <<~PATTERN
+          (block #expect? (args) _body)
+        PATTERN
+
+        def on_send(node)
+          return unless expect?(node)
+
+          check_expect(node)
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless expect_block?(node)
+
+          check_expect(node)
+        end
+
+        private
+
+        def check_expect(node)
+          return unless void?(node)
+
+          add_offense(node)
+        end
+
+        def void?(expect)
+          parent = expect.parent
+          return true unless parent
+          return true if parent.begin_type?
+
+          parent.block_type? && parent.body == expect
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for calling a block within a stub.
+      #
+      # @example
+      #   # bad
+      #   allow(foo).to receive(:bar) { |&block| block.call(1) }
+      #
+      #   # good
+      #   expect(foo).to receive(:bar).and_yield(1)
+      #
+      class Yield < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `.and_yield`.'
+
+        # @!method method_on_stub?(node)
+        def_node_search :method_on_stub?, '(send nil? :receive ...)'
+
+        # @!method block_arg(node)
+        def_node_matcher :block_arg, '(args (blockarg $_))'
+
+        # @!method block_call?(node)
+        def_node_matcher :block_call?, '(send (lvar %) :call ...)'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless method_on_stub?(node.send_node)
+
+          block_arg(node.arguments) do |block|
+            if calling_block?(node.body, block)
+              range = block_range(node)
+
+              add_offense(range) do |corrector|
+                autocorrect(corrector, node, range)
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, range)
+          corrector.replace(
+            range_with_surrounding_space(range, side: :left),
+            generate_replacement(node.body)
+          )
+        end
+
+        def calling_block?(node, block)
+          if node.begin_type?
+            node.each_child_node.all? { |child| block_call?(child, block) }
+          else
+            block_call?(node, block)
+          end
+        end
+
+        def block_range(node)
+          node.loc.begin.with(end_pos: node.loc.end.end_pos)
+        end
+
+        def generate_replacement(node)
+          if node.begin_type?
+            node.children.map { |child| convert_block_to_yield(child) }.join
+          else
+            convert_block_to_yield(node)
+          end
+        end
+
+        def convert_block_to_yield(node)
+          args = node.arguments
+          replacement = '.and_yield'
+          replacement += "(#{args.map(&:source).join(', ')})" if args.any?
+          replacement
+        end
+      end
+    end
+  end
+end