rubocop-rspec 1.43.1 → 2.0.0

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

@@ -59,14 +59,24 @@ module RuboCop
         MSG_CONTEXT  = "Use `shared_context` when you don't "\
                        'define examples.'
 
-        examples = (Examples::ALL + Includes::EXAMPLES)
-        def_node_search :examples?, examples.send_pattern
+        def_node_search :examples?,
+                        send_pattern('{#Includes.examples #Examples.all}')
 
-        context = (Hooks::ALL + Helpers::ALL + Includes::CONTEXT + Subject::ALL)
-        def_node_search :context?, context.send_pattern
+        def_node_search :context?, <<-PATTERN
+          (
+            send #rspec? {
+              #Subjects.all
+              #Helpers.all
+              #Includes.context
+              #Hooks.all
+            } ...
+          )
+        PATTERN
 
-        def_node_matcher :shared_context, SharedGroups::CONTEXT.block_pattern
-        def_node_matcher :shared_example, SharedGroups::EXAMPLES.block_pattern
+        def_node_matcher :shared_context,
+                         block_pattern('#SharedGroups.context')
+        def_node_matcher :shared_example,
+                         block_pattern('#SharedGroups.examples')
 
         def on_block(node)
           context_with_only_examples(node) do

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

@@ -24,7 +24,9 @@ module RuboCop
         extend AutoCorrector
 
         def_node_matcher :shared_examples,
-                         (SharedGroups::ALL + Includes::ALL).send_pattern
+                         send_pattern(
+                           '{#SharedGroups.all #Includes.all}'
+                         )
 
         def on_send(node)
           shared_examples(node) do

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that message expectations do not have a configured response.
+      #
+      # @example
+      #
+      #   # bad
+      #   expect(foo).to receive(:bar).with(42).and_return("hello world")
+      #
+      #   # good (without spies)
+      #   allow(foo).to receive(:bar).with(42).and_return("hello world")
+      #   expect(foo).to receive(:bar).with(42)
+      #
+      class StubbedMock < Base
+        MSG = 'Prefer `%<replacement>s` over `%<method_name>s` when ' \
+              'configuring a response.'
+
+        # @!method message_expectation?(node)
+        #   Match message expectation matcher
+        #
+        #   @example source that matches
+        #     receive(:foo)
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, :bar)
+        #
+        #   @example source that matches
+        #     receive(:foo).with('bar')
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :message_expectation?, <<-PATTERN
+          {
+            (send nil? { :receive :receive_message_chain } ...)  # receive(:foo)
+            (send (send nil? :receive ...) :with ...)            # receive(:foo).with('bar')
+          }
+        PATTERN
+
+        def_node_matcher :configured_response?, <<~PATTERN
+          { :and_return :and_raise :and_throw :and_yield
+            :and_call_original :and_wrap_original }
+        PATTERN
+
+        # @!method expectation(node)
+        #   Match expectation
+        #
+        #   @example source that matches
+        #     is_expected.to be_in_the_bar
+        #
+        #   @example source that matches
+        #     expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari)
+        #
+        #   @example source that matches
+        #     expect_any_instance_of(Officer).to be_alert
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] expectation, method name, matcher
+        def_node_matcher :expectation, <<~PATTERN
+          (send
+            $(send nil? $#Expectations.all ...)
+            :to $_)
+        PATTERN
+
+        # @!method matcher_with_configured_response(node)
+        #   Match matcher with a configured response
+        #
+        #   @example source that matches
+        #     receive(:foo).and_return('bar')
+        #
+        #   @example source that matches
+        #     receive(:lower).and_raise(SomeError)
+        #
+        #   @example source that matches
+        #     receive(:redirect).and_call_original
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_configured_response, <<~PATTERN
+          (send #message_expectation? #configured_response? _)
+        PATTERN
+
+        # @!method matcher_with_return_block(node)
+        #   Match matcher with a return block
+        #
+        #   @example source that matches
+        #     receive(:foo) { 'bar' }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_return_block, <<~PATTERN
+          (block #message_expectation? args _)  # receive(:foo) { 'bar' }
+        PATTERN
+
+        # @!method matcher_with_hash(node)
+        #   Match matcher with a configured response defined as a hash
+        #
+        #   @example source that matches
+        #     receive_messages(foo: 'bar', baz: 'qux')
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, bar: 'baz')
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_hash, <<~PATTERN
+          {
+            (send nil? :receive_messages hash)           # receive_messages(foo: 'bar', baz: 'qux')
+            (send nil? :receive_message_chain ... hash)  # receive_message_chain(:foo, bar: 'baz')
+          }
+        PATTERN
+
+        # @!method matcher_with_blockpass(node)
+        #   Match matcher with a configured response in block-pass
+        #
+        #   @example source that matches
+        #     receive(:foo, &canned)
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, :bar, &canned)
+        #
+        #   @example source that matches
+        #     receive(:foo).with('bar', &canned)
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_blockpass, <<~PATTERN
+          {
+            (send nil? { :receive :receive_message_chain } ... block_pass)  # receive(:foo, &canned)
+            (send (send nil? :receive ...) :with ... block_pass)            # receive(:foo).with('foo', &canned)
+          }
+        PATTERN
+
+        def on_send(node)
+          expectation(node, &method(:on_expectation))
+        end
+
+        private
+
+        def on_expectation(expectation, method_name, matcher)
+          flag_expectation = lambda do
+            add_offense(expectation, message: msg(method_name))
+          end
+
+          matcher_with_configured_response(matcher, &flag_expectation)
+          matcher_with_return_block(matcher, &flag_expectation)
+          matcher_with_hash(matcher, &flag_expectation)
+          matcher_with_blockpass(matcher, &flag_expectation)
+        end
+
+        def msg(method_name)
+          format(MSG,
+                 method_name: method_name,
+                 replacement: replacement(method_name))
+        end
+
+        def replacement(method_name)
+          case method_name
+          when :expect
+            :allow
+          when :is_expected
+            'allow(subject)'
+          when :expect_any_instance_of
+            :allow_any_instance_of
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module RuboCop
       #   end
       #
       class SubjectStub < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Do not stub methods of the object under test.'
 
@@ -43,10 +43,10 @@ module RuboCop
         #
         #   @yield [Symbol] subject name
         def_node_matcher :subject, <<-PATTERN
-          {
-            (block (send nil? :subject (sym $_)) args ...)
-            (block (send nil? $:subject) args ...)
-          }
+            (block
+              (send nil?
+                {:subject (sym $_) | $:subject}
+              ) args ...)
         PATTERN
 
         # @!method message_expectation?(node, method_name)
@@ -66,7 +66,7 @@ module RuboCop
               (send nil? { :expect :allow } (send nil? {% :subject}))
               (send nil? :is_expected)
             }
-            #{Runners::ALL.node_pattern_union}
+            #Runners.all
             #message_expectation_matcher?
           )
         PATTERN

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

@@ -24,7 +24,7 @@ module RuboCop
       #   let('user_name') { 'Adam' }
       class VariableDefinition < Base
         include ConfigurableEnforcedStyle
-        include RuboCop::RSpec::Variable
+        include Variable
 
         MSG = 'Use %<style>s for variable names.'
 

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

@@ -42,7 +42,7 @@ module RuboCop
       class VariableName < Base
         include ConfigurableNaming
         include IgnoredPattern
-        include RuboCop::RSpec::Variable
+        include Variable
 
         MSG = 'Use %<style>s for variable names.'
 

data/lib/rubocop/cop/rspec_cops.rb

@@ -52,7 +52,6 @@ require_relative 'rspec/implicit_expect'
 require_relative 'rspec/implicit_subject'
 require_relative 'rspec/instance_spy'
 require_relative 'rspec/instance_variable'
-require_relative 'rspec/invalid_predicate_matcher'
 require_relative 'rspec/it_behaves_like'
 require_relative 'rspec/iterated_expectation'
 require_relative 'rspec/leading_subject'
@@ -79,12 +78,14 @@ require_relative 'rspec/repeated_description'
 require_relative 'rspec/repeated_example'
 require_relative 'rspec/repeated_example_group_body'
 require_relative 'rspec/repeated_example_group_description'
+require_relative 'rspec/repeated_include_example'
 require_relative 'rspec/return_from_stub'
 require_relative 'rspec/scattered_let'
 require_relative 'rspec/scattered_setup'
 require_relative 'rspec/shared_context'
 require_relative 'rspec/shared_examples'
 require_relative 'rspec/single_argument_message_chain'
+require_relative 'rspec/stubbed_mock'
 require_relative 'rspec/subject_stub'
 require_relative 'rspec/unspecified_exception'
 require_relative 'rspec/variable_definition'

data/lib/rubocop/rspec/align_let_brace.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Shared behavior for aligning braces for single line lets
     class AlignLetBrace
-      include RuboCop::RSpec::Language::NodePattern
+      include RuboCop::RSpec::Language
 
       def initialize(root, token)
         @root  = root

data/lib/rubocop/rspec/concept.rb

@@ -4,9 +4,9 @@ module RuboCop
   module RSpec
     # Wrapper for RSpec DSL methods
     class Concept
+      extend RuboCop::NodePattern::Macros
+      extend Language::NodePattern
       include Language
-      include Language::NodePattern
-      extend NodePattern::Macros
 
       def initialize(node)
         @node = node

data/lib/rubocop/rspec/config_formatter.rb

@@ -6,7 +6,7 @@ module RuboCop
   module RSpec
     # Builds a YAML config file from two config hashes
     class ConfigFormatter
-      NAMESPACES = /^(RSpec|Capybara|FactoryBot|Rails)/.freeze
+      EXTENSION_ROOT_DEPARTMENT = %r{^(RSpec/)}.freeze
       STYLE_GUIDE_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/'
 
       def initialize(config, descriptions)
@@ -15,7 +15,7 @@ module RuboCop
       end
 
       def dump
-        YAML.dump(unified_config).gsub(NAMESPACES, "\n\\1")
+        YAML.dump(unified_config).gsub(EXTENSION_ROOT_DEPARTMENT, "\n\\1")
       end
 
       private
@@ -29,7 +29,7 @@ module RuboCop
       end
 
       def cops
-        (descriptions.keys | config.keys).grep(NAMESPACES)
+        (descriptions.keys | config.keys).grep(EXTENSION_ROOT_DEPARTMENT)
       end
 
       attr_reader :config, :descriptions

data/lib/rubocop/rspec/corrector/move_node.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Helper methods to move a node
       class MoveNode
         include RuboCop::Cop::RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
+        include RuboCop::Cop::RSpec::FinalEndLocation
 
         attr_reader :original, :corrector, :processed_source
 

data/lib/rubocop/rspec/example_group.rb

@@ -10,9 +10,14 @@ module RuboCop
       #
       #   Selectors which indicate that we should stop searching
       #
-      def_node_matcher :scope_change?, (
-        ExampleGroups::ALL + SharedGroups::ALL + Includes::ALL
-      ).block_pattern
+      def_node_matcher :scope_change?,
+                       block_pattern(<<~PATTERN)
+                         {
+                           #SharedGroups.all
+                           #ExampleGroups.all
+                           #Includes.all
+                         }
+                       PATTERN
 
       def lets
         find_all_in_scope(node, :let?)
@@ -23,11 +28,15 @@ module RuboCop
       end
 
       def examples
-        find_all_in_scope(node, :example?).map(&Example.public_method(:new))
+        find_all_in_scope(node, :example?).map do |node|
+          Example.new(node)
+        end
       end
 
       def hooks
-        find_all_in_scope(node, :hook?).map(&Hook.public_method(:new))
+        find_all_in_scope(node, :hook?).map do |node|
+          Hook.new(node)
+        end
       end
 
       private
@@ -37,6 +46,7 @@ module RuboCop
       # Searches node and halts when a scope change is detected
       #
       # @param node [RuboCop::AST::Node] node to recursively search
+      # @param predicate [Symbol] method to call with node as argument
       #
       # @return [Array<RuboCop::AST::Node>] discovered nodes
       def find_all_in_scope(node, predicate)

data/lib/rubocop/rspec/hook.rb

@@ -6,11 +6,7 @@ module RuboCop
     class Hook < Concept
       def_node_matcher :extract_metadata, <<~PATTERN
         (block
-          {
-            (send _ _ #valid_scope? $...)
-            (send _ _ $...)
-          }
-          ...
+          (send _ _ #valid_scope? ? $...) ...
         )
       PATTERN
 
@@ -48,7 +44,7 @@ module RuboCop
       private
 
       def valid_scope?(node)
-        node&.sym_type? && Hooks::Scopes::ALL.include?(node.value)
+        node&.sym_type? && Language::HookScopes.all(node.value)
       end
 
       def transform_metadata(meta)

data/lib/rubocop/rspec/inject.rb

@@ -6,9 +6,11 @@ module RuboCop
     # bit of our configuration.
     module Inject
       def self.defaults!
-        path = CONFIG_DEFAULT.to_s
+        project_root = Pathname.new(__dir__).parent.parent.parent.expand_path
+        config_default = project_root.join('config', 'default.yml')
+        path = config_default.to_s
         hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path)
+        config = RuboCop::Config.new(hash, path)
         puts "configuration from #{path}" if ConfigLoader.debug?
         config = ConfigLoader.merge_with_default(config, path)
         ConfigLoader.instance_variable_set(:@default_configuration, config)

data/lib/rubocop/rspec/language.rb

@@ -2,147 +2,186 @@
 
 module RuboCop
   module RSpec
-    # RSpec public API methods that are commonly used in cops
+    # Contains node matchers for common RSpec DSL.
+    #
+    # RSpec allows for configuring aliases for commonly used DSL elements, e.g.
+    # example groups and hooks. It is possible to configure RuboCop RSpec to
+    # be able to properly detect these elements in the `RSpec/Language` section
+    # of the RuboCop YAML configuration file.
+    #
+    # In addition to providing useful matchers, this class is responsible for
+    # using the configured aliases.
     module Language
-      # Set of method selectors
-      class SelectorSet
-        def initialize(selectors)
-          @selectors = selectors
-        end
+      extend RuboCop::NodePattern::Macros
+      extend NodePattern
 
-        def ==(other)
-          selectors.eql?(other.selectors)
-        end
+      class << self
+        attr_accessor :config
+      end
 
-        def +(other)
-          self.class.new(selectors + other.selectors)
-        end
+      def_node_matcher :rspec?, '{(const {nil? cbase} :RSpec) nil?}'
 
-        def include?(selector)
-          selectors.include?(selector)
-        end
+      def_node_matcher :example_group?, block_pattern('#ExampleGroups.all')
 
-        def block_pattern
-          "(block #{send_pattern} ...)"
-        end
+      def_node_matcher :shared_group?, block_pattern('#SharedGroups.all')
 
-        def block_pass_pattern
-          "(send #rspec? #{node_pattern_union} _ block_pass)"
-        end
+      def_node_matcher :spec_group?,
+                       block_pattern('{#SharedGroups.all #ExampleGroups.all}')
 
-        def block_or_block_pass_pattern
-          "{#{block_pattern} #{block_pass_pattern}}"
-        end
+      def_node_matcher :example_group_with_body?, <<-PATTERN
+        (block #{send_pattern('#ExampleGroups.all')} args !nil?)
+      PATTERN
 
-        def send_pattern
-          "(send #rspec? #{node_pattern_union} ...)"
-        end
+      def_node_matcher :example?, block_pattern('#Examples.all')
 
-        def send_or_block_or_block_pass_pattern
-          "{#{send_pattern} #{block_pattern} #{block_pass_pattern}}"
-        end
+      def_node_matcher :hook?, block_pattern('#Hooks.all')
 
-        def node_pattern_union
-          "{#{node_pattern}}"
-        end
+      def_node_matcher :let?, <<-PATTERN
+        {
+          #{block_pattern('#Helpers.all')}
+          (send #rspec? #Helpers.all _ block_pass)
+        }
+      PATTERN
 
-        def node_pattern
-          selectors.map(&:inspect).join(' ')
-        end
+      def_node_matcher :include?, <<-PATTERN
+        {
+          #{send_pattern('#Includes.all')}
+          #{block_pattern('#Includes.all')}
+        }
+      PATTERN
 
-        protected
+      def_node_matcher :subject?, block_pattern('#Subjects.all')
 
-        attr_reader :selectors
-      end
+      module ExampleGroups # :nodoc:
+        class << self
+          def all(element)
+            regular(element) ||
+              skipped(element) ||
+              focused(element)
+          end
+
+          def regular(element)
+            Language.config['ExampleGroups']['Regular'].include?(element.to_s)
+          end
 
-      module ExampleGroups
-        GROUPS  = SelectorSet.new(%i[describe context feature example_group])
-        SKIPPED = SelectorSet.new(%i[xdescribe xcontext xfeature])
-        FOCUSED = SelectorSet.new(%i[fdescribe fcontext ffeature])
+          def focused(element)
+            Language.config['ExampleGroups']['Focused'].include?(element.to_s)
+          end
 
-        ALL = GROUPS + SKIPPED + FOCUSED
+          def skipped(element)
+            Language.config['ExampleGroups']['Skipped'].include?(element.to_s)
+          end
+        end
       end
 
-      module SharedGroups
-        EXAMPLES = SelectorSet.new(%i[shared_examples shared_examples_for])
-        CONTEXT = SelectorSet.new(%i[shared_context])
+      module Examples # :nodoc:
+        class << self
+          def all(element)
+            regular(element) ||
+              focused(element) ||
+              skipped(element) ||
+              pending(element)
+          end
+
+          def regular(element)
+            Language.config['Examples']['Regular'].include?(element.to_s)
+          end
+
+          def focused(element)
+            Language.config['Examples']['Focused'].include?(element.to_s)
+          end
+
+          def skipped(element)
+            Language.config['Examples']['Skipped'].include?(element.to_s)
+          end
+
+          def pending(element)
+            Language.config['Examples']['Pending'].include?(element.to_s)
+          end
+        end
+      end
 
-        ALL = EXAMPLES + CONTEXT
+      module Expectations # :nodoc:
+        def self.all(element)
+          Language.config['Expectations'].include?(element.to_s)
+        end
       end
 
-      module Includes
-        EXAMPLES = SelectorSet.new(
-          %i[
-            it_behaves_like
-            it_should_behave_like
-            include_examples
-          ]
-        )
-        CONTEXT = SelectorSet.new(%i[include_context])
-
-        ALL = EXAMPLES + CONTEXT
+      module Helpers # :nodoc:
+        def self.all(element)
+          Language.config['Helpers'].include?(element.to_s)
+        end
       end
 
-      module Examples
-        EXAMPLES = SelectorSet.new(%i[it specify example scenario its])
-        FOCUSED  = SelectorSet.new(%i[fit fspecify fexample fscenario focus])
-        SKIPPED  = SelectorSet.new(%i[xit xspecify xexample xscenario skip])
-        PENDING  = SelectorSet.new(%i[pending])
+      module Hooks # :nodoc:
+        def self.all(element)
+          Language.config['Hooks'].include?(element.to_s)
+        end
+      end
 
-        ALL = EXAMPLES + FOCUSED + SKIPPED + PENDING
+      module HookScopes # :nodoc:
+        def self.all(element)
+          Language.config['HookScopes'].include?(element.to_s)
+        end
       end
 
-      module Hooks
-        ALL = SelectorSet.new(
-          %i[
-            prepend_before
-            before
-            append_before
-            around
-            prepend_after
-            after
-            append_after
-          ]
-        )
-
-        module Scopes
-          ALL = SelectorSet.new(
-            %i[
-              each
-              example
-              context
-              all
-              suite
-            ]
-          )
+      module Includes # :nodoc:
+        class << self
+          def all(element)
+            examples(element) ||
+              context(element)
+          end
+
+          def examples(element)
+            Language.config['Includes']['Examples'].include?(element.to_s)
+          end
+
+          def context(element)
+            Language.config['Includes']['Context'].include?(element.to_s)
+          end
         end
       end
 
-      module Helpers
-        ALL = SelectorSet.new(%i[let let!])
+      module Runners # :nodoc:
+        def self.all(element)
+          Language.config['Runners'].include?(element.to_s)
+        end
       end
 
-      module Subject
-        ALL = SelectorSet.new(%i[subject subject!])
+      module SharedGroups # :nodoc:
+        class << self
+          def all(element)
+            examples(element) ||
+              context(element)
+          end
+
+          def examples(element)
+            Language.config['SharedGroups']['Examples'].include?(element.to_s)
+          end
+
+          def context(element)
+            Language.config['SharedGroups']['Context'].include?(element.to_s)
+          end
+        end
       end
 
-      module Expectations
-        ALL = SelectorSet.new(%i[expect is_expected expect_any_instance_of])
+      module Subjects # :nodoc:
+        def self.all(element)
+          Language.config['Subjects'].include?(element.to_s)
+        end
       end
 
-      module Runners
-        ALL = SelectorSet.new(%i[to to_not not_to])
+      # This is used in Dialect and DescribeClass cops to detect RSpec blocks.
+      module ALL # :nodoc:
+        def self.all(element)
+          [ExampleGroups, Examples, Expectations, Helpers, Hooks, Includes,
+           Runners, SharedGroups, Subjects]
+            .find { |concept| concept.all(element) }
+        end
       end
 
-      ALL =
-        ExampleGroups::ALL +
-        SharedGroups::ALL  +
-        Examples::ALL      +
-        Hooks::ALL         +
-        Helpers::ALL       +
-        Subject::ALL       +
-        Expectations::ALL  +
-        Runners::ALL
+      private_constant :ExampleGroups, :Examples, :Expectations, :Hooks,
+                       :Includes, :Runners, :SharedGroups, :ALL
     end
   end
 end