rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Sort RSpec metadata alphabetically.
+      #
+      # @example
+      #   # bad
+      #   describe 'Something', :b, :a
+      #   context 'Something', foo: 'bar', baz: true
+      #   it 'works', :b, :a, foo: 'bar', baz: true
+      #
+      #   # good
+      #   describe 'Something', :a, :b
+      #   context 'Something', baz: true, foo: 'bar'
+      #   it 'works', :a, :b, baz: true, foo: 'bar'
+      #
+      class SortMetadata < Base
+        extend AutoCorrector
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Sort metadata alphabetically.'
+
+        def on_metadata(symbols, hash)
+          pairs = hash&.pairs || []
+          return if sorted?(symbols, pairs)
+
+          crime_scene = crime_scene(symbols, pairs)
+          add_offense(crime_scene) do |corrector|
+            corrector.replace(crime_scene, replacement(symbols, pairs))
+          end
+        end
+
+        private
+
+        def crime_scene(symbols, pairs)
+          metadata = symbols + pairs
+
+          range_between(
+            metadata.first.source_range.begin_pos,
+            metadata.last.source_range.end_pos
+          )
+        end
+
+        def replacement(symbols, pairs)
+          (sort_symbols(symbols) + sort_pairs(pairs)).map(&:source).join(', ')
+        end
+
+        def sorted?(symbols, pairs)
+          symbols == sort_symbols(symbols) && pairs == sort_pairs(pairs)
+        end
+
+        def sort_pairs(pairs)
+          pairs.sort_by { |pair| pair.key.source.downcase }
+        end
+
+        def sort_symbols(symbols)
+          symbols.sort_by do |symbol|
+            if symbol.str_type? || symbol.sym_type?
+              symbol.value.to_s.downcase
+            else
+              symbol.source.downcase
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that spec file paths are consistent and well-formed.
+      #
+      # @example
+      #   # bad
+      #   whatever_spec.rb         # describe MyClass
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      #   # good
+      #   my_class_spec.rb         # describe MyClass
+      #   my_class_method_spec.rb  # describe MyClass, '#method'
+      #   my_class/method_spec.rb  # describe MyClass, '#method'
+      #
+      # @example `CustomTransform: {RuboCop=>rubocop, RSpec=>rspec}` (default)
+      #   # good
+      #   rubocop_spec.rb          # describe RuboCop
+      #   rspec_spec.rb            # describe RSpec
+      #
+      # @example `IgnoreMethods: false` (default)
+      #   # bad
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      # @example `IgnoreMethods: true`
+      #   # good
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      # @example `IgnoreMetadata: {type=>routing}` (default)
+      #   # good
+      #   whatever_spec.rb         # describe MyClass, type: :routing do; end
+      #
+      class SpecFilePathFormat < Base
+        include TopLevelGroup
+        include Namespace
+        include FileHelp
+
+        MSG = 'Spec path should end with `%<suffix>s`.'
+
+        # @!method example_group_arguments(node)
+        def_node_matcher :example_group_arguments, <<~PATTERN
+          (block $(send #rspec? #ExampleGroups.all $_ $...) ...)
+        PATTERN
+
+        # @!method metadata_key_value(node)
+        def_node_search :metadata_key_value, '(pair (sym $_key) (sym $_value))'
+
+        def on_top_level_example_group(node)
+          return unless top_level_groups.one?
+
+          example_group_arguments(node) do |send_node, class_name, arguments|
+            next if !class_name.const_type? || ignore_metadata?(arguments)
+
+            ensure_correct_file_path(send_node, class_name, arguments)
+          end
+        end
+
+        private
+
+        def ensure_correct_file_path(send_node, class_name, arguments)
+          pattern = correct_path_pattern(class_name, arguments)
+          return if filename_ends_with?(pattern)
+
+          # For the suffix shown in the offense message, modify the regular
+          # expression pattern to resemble a glob pattern for clearer error
+          # messages.
+          suffix = pattern.sub('.*', '*').sub('[^/]*', '*').sub('\.', '.')
+          add_offense(send_node, message: format(MSG, suffix: suffix))
+        end
+
+        def ignore_metadata?(arguments)
+          arguments.any? do |argument|
+            metadata_key_value(argument).any? do |key, value|
+              ignore_metadata.values_at(key.to_s).include?(value.to_s)
+            end
+          end
+        end
+
+        def correct_path_pattern(class_name, arguments)
+          path = [expected_path(class_name)]
+          path << '.*' unless ignore?(arguments.first)
+          path << [name_pattern(arguments.first), '[^/]*_spec\.rb']
+          path.join
+        end
+
+        def name_pattern(method_name)
+          return if ignore?(method_name)
+
+          method_name.str_content.gsub(/\s/, '_').gsub(/\W/, '')
+        end
+
+        def ignore?(method_name)
+          !method_name&.str_type? || ignore_methods?
+        end
+
+        def expected_path(constant)
+          constants = namespace(constant) + constant.const_name.split('::')
+
+          File.join(
+            constants.map do |name|
+              custom_transform.fetch(name) { camel_to_snake_case(name) }
+            end
+          )
+        end
+
+        def camel_to_snake_case(string)
+          string
+            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
+            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+            .downcase
+        end
+
+        def custom_transform
+          cop_config.fetch('CustomTransform', {})
+        end
+
+        def ignore_methods?
+          cop_config['IgnoreMethods']
+        end
+
+        def ignore_metadata
+          cop_config.fetch('IgnoreMetadata', {})
+        end
+
+        def filename_ends_with?(pattern)
+          expanded_file_path.match?("#{pattern}$")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that spec file paths suffix are consistent and well-formed.
+      #
+      # @example
+      #   # bad
+      #   my_class/foo_specorb.rb   # describe MyClass
+      #   spec/models/user.rb       # describe User
+      #   spec/models/user_specxrb  # describe User
+      #
+      #   # good
+      #   my_class_spec.rb          # describe MyClass
+      #
+      #   # good - shared examples are allowed
+      #   spec/models/user.rb       # shared_examples_for 'foo'
+      #
+      class SpecFilePathSuffix < Base
+        include TopLevelGroup
+        include FileHelp
+
+        MSG = 'Spec path should end with `_spec.rb`.'
+
+        def on_top_level_example_group(node)
+          example_group?(node) do
+            add_global_offense(MSG) unless correct_path?
+          end
+        end
+
+        private
+
+        def correct_path?
+          expanded_file_path.end_with?('_spec.rb')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# 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
+
+        # @!method configured_response?(node)
+        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
+
+        RESTRICT_ON_SEND = %i[to].freeze
+
+        def on_send(node)
+          expectation(node) do |expectation, method_name, matcher|
+            on_expectation(expectation, method_name, matcher)
+          end
+        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_declaration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensure that subject is defined using subject helper.
+      #
+      # @example
+      #   # bad
+      #   let(:subject) { foo }
+      #   let!(:subject) { foo }
+      #   subject(:subject) { foo }
+      #   subject!(:subject) { foo }
+      #
+      #   # bad
+      #   block = -> {}
+      #   let(:subject, &block)
+      #
+      #   # good
+      #   subject(:test_subject) { foo }
+      #
+      class SubjectDeclaration < Base
+        MSG_LET = 'Use subject explicitly rather than using let'
+        MSG_REDUNDANT = 'Ambiguous declaration of subject'
+
+        # @!method offensive_subject_declaration?(node)
+        def_node_matcher :offensive_subject_declaration?, <<~PATTERN
+          (send nil? ${#Subjects.all #Helpers.all} ({sym str} #Subjects.all) ...)
+        PATTERN
+
+        def on_send(node)
+          offense = offensive_subject_declaration?(node)
+          return unless offense
+
+          add_offense(node, message: message_for(offense))
+        end
+
+        private
+
+        def message_for(offense)
+          Helpers.all(offense) ? MSG_LET : MSG_REDUNDANT
+        end
+      end
+    end
+  end
+end

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

@@ -1,51 +1,86 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     module RSpec
       # Checks for stubbed test subjects.
       #
+      # Checks nested subject stubs for innermost subject definition
+      # when subject is also defined in parent example groups.
+      #
       # @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
+      # @see https://penelope.zone/2015/12/27/introducing-rspec-smells-and-where-to-find-them.html#smell-1-stubjec
       #
       # @example
       #   # bad
-      #   describe Foo do
-      #     subject(:bar) { baz }
+      #   describe Article do
+      #     subject(:article) { Article.new }
+      #
+      #     it 'indicates that the author is unknown' do
+      #       allow(article).to receive(:author).and_return(nil)
+      #       expect(article.description).to include('by an unknown author')
+      #     end
+      #   end
+      #
+      #   # bad
+      #   describe Article do
+      #     subject(:foo) { Article.new }
+      #
+      #     context 'nested subject' do
+      #       subject(:article) { Article.new }
       #
-      #     before do
-      #       allow(bar).to receive(:qux?).and_return(true)
+      #       it 'indicates that the author is unknown' do
+      #         allow(article).to receive(:author).and_return(nil)
+      #         expect(article.description).to include('by an unknown author')
+      #       end
       #     end
       #   end
       #
-      class SubjectStub < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Language,
-                RuboCop::RSpec::Language::NodePattern
+      #   # good
+      #   describe Article do
+      #     subject(:article) { Article.new(author: nil) }
+      #
+      #     it 'indicates that the author is unknown' do
+      #       expect(article.description).to include('by an unknown author')
+      #     end
+      #   end
+      #
+      class SubjectStub < Base
+        include TopLevelGroup
 
-        MSG = 'Do not stub your test subject.'.freeze
+        MSG = 'Do not stub methods of the object under test.'
 
-        # @!method subject(node)
+        # @!method subject?(node)
         #   Find a named or unnamed subject definition
         #
         #   @example anonymous subject
-        #     subject(parse('subject { foo }').ast) do |name|
+        #     subject?(parse('subject { foo }').ast) do |name|
         #       name # => :subject
         #     end
         #
         #   @example named subject
-        #     subject(parse('subject(:thing) { foo }').ast) do |name|
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
         #       name # => :thing
         #     end
         #
-        #   @param node [RuboCop::Node]
+        #   @param node [RuboCop::AST::Node]
         #
         #   @yield [Symbol] subject name
-        def_node_matcher :subject, <<-PATTERN
-        {
-          (block (send nil :subject (sym $_)) args ...)
-          (block (send nil $:subject) args ...)
-        }
+        def_node_matcher :subject?, <<~PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method let?(node)
+        #   Find a memoized helper
+        def_node_matcher :let?, <<~PATTERN
+          (block
+            (send nil? :let (sym $_)
+            ) args ...)
         PATTERN
 
         # @!method message_expectation?(node, method_name)
@@ -58,76 +93,60 @@ module RuboCop
         #     expect(foo).to receive(:bar)
         #     expect(foo).to receive(:bar).with(1)
         #     expect(foo).to receive(:bar).with(1).and_return(2)
-        def_node_matcher :message_expectation?, <<-PATTERN
-          {
-            (send nil :allow (send nil %))
-            (send (send nil :expect (send nil %)) :to #receive_message?)
-          }
+        #
+        def_node_matcher :message_expectation?, <<~PATTERN
+          (send
+            {
+              (send nil? { :expect :allow } (send nil? %))
+              (send nil? :is_expected)
+            }
+            #Runners.all
+            #message_expectation_matcher?
+          )
         PATTERN
 
-        def_node_search :receive_message?, '(send nil :receive ...)'
+        # @!method message_expectation_matcher?(node)
+        def_node_search :message_expectation_matcher?, <<~PATTERN
+          (send nil? {
+            :receive :receive_messages :receive_message_chain :have_received
+            } ...)
+        PATTERN
 
-        def on_block(node)
-          return unless example_group?(node)
+        def on_top_level_group(node)
+          @explicit_subjects = find_all_explicit(node) { |n| subject?(n) }
+          @subject_overrides = find_all_explicit(node) { |n| let?(n) }
 
-          find_subject_stub(node) { |stub| add_offense(stub, :expression) }
+          find_subject_expectations(node) do |stub|
+            add_offense(stub)
+          end
         end
 
         private
 
-        # Find subjects within tree and then find (send) nodes for that subject
-        #
-        # @param node [RuboCop::Node] example group
-        #
-        # @yield [RuboCop::Node] message expectations for subject
-        def find_subject_stub(node, &block)
-          find_subject(node) do |subject_name, context|
-            find_subject_expectation(context, subject_name, &block)
-          end
-        end
+        def find_all_explicit(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            name = yield(child)
+            next unless name
 
-        # Find a subject message expectation
-        #
-        # @param node [RuboCop::Node]
-        # @param subject_name [Symbol] name of subject
-        #
-        # @yield [RuboCop::Node] message expectation
-        def find_subject_expectation(node, subject_name, &block)
-          # Do not search node if it is an example group with its own subject.
-          return if example_group?(node) && redefines_subject?(node)
+            outer_example_group = child.each_ancestor(:block).find do |a|
+              example_group?(a)
+            end
 
-          # Yield the current node if it is a message expectation.
-          yield(node) if message_expectation?(node, subject_name)
-
-          # Recurse through node's children looking for a message expectation.
-          node.each_child_node do |child|
-            find_subject_expectation(child, subject_name, &block)
+            h[outer_example_group] ||= []
+            h[outer_example_group] << name
           end
         end
 
-        # Check if node's children contain a subject definition
-        #
-        # @param node [RuboCop::Node]
-        #
-        # @return [Boolean]
-        def redefines_subject?(node)
-          node.each_child_node.any? do |child|
-            subject(child) || redefines_subject?(child)
-          end
-        end
+        def find_subject_expectations(node, subject_names = [], &block)
+          subject_names = [*subject_names, *@explicit_subjects[node]]
+          subject_names -= @subject_overrides[node] if @subject_overrides[node]
 
-        # Find a subject definition
-        #
-        # @param node [RuboCop::Node]
-        # @param parent [RuboCop::Node,nil]
-        #
-        # @yieldparam subject_name [Symbol] name of subject being defined
-        # @yieldparam parent [RuboCop::Node] parent of subject definition
-        def find_subject(node, parent: nil, &block)
-          subject(node) { |name| yield(name, parent) }
+          names = Set[*subject_names, :subject]
+          expectation_detected = message_expectation?(node, names)
+          return yield(node) if expectation_detected
 
-          node.each_child_node do |child|
-            find_subject(child, parent: node, &block)
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            find_subject_expectations(child, subject_names, &block)
           end
         end
       end