rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for consistent style of stub's return setting.
+      #
+      # Enforces either `and_return` or block-style return in the cases
+      # where the returned value is constant. Ignores dynamic returned values
+      # are the result would be different
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: and_return` (default)
+      #   # bad
+      #   allow(Foo).to receive(:bar) { "baz" }
+      #   expect(Foo).to receive(:bar) { "baz" }
+      #
+      #   # good
+      #   allow(Foo).to receive(:bar).and_return("baz")
+      #   expect(Foo).to receive(:bar).and_return("baz")
+      #   # also good as the returned value is dynamic
+      #   allow(Foo).to receive(:bar) { bar.baz }
+      #
+      # @example `EnforcedStyle: block`
+      #   # bad
+      #   allow(Foo).to receive(:bar).and_return("baz")
+      #   expect(Foo).to receive(:bar).and_return("baz")
+      #
+      #   # good
+      #   allow(Foo).to receive(:bar) { "baz" }
+      #   expect(Foo).to receive(:bar) { "baz" }
+      #   # also good as the returned value is dynamic
+      #   allow(Foo).to receive(:bar).and_return(bar.baz)
+      #
+      class ReturnFromStub < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG_AND_RETURN = 'Use `and_return` for static values.'
+        MSG_BLOCK = 'Use block for static values.'
+        RESTRICT_ON_SEND = %i[and_return].freeze
+
+        # @!method contains_stub?(node)
+        def_node_search :contains_stub?, '(send nil? :receive (...))'
+
+        # @!method stub_with_block?(node)
+        def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
+
+        # @!method and_return_value(node)
+        def_node_search :and_return_value, <<~PATTERN
+          $(send _ :and_return $(...))
+        PATTERN
+
+        def on_send(node)
+          return unless style == :block
+          return unless contains_stub?(node)
+
+          check_and_return_call(node)
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless style == :and_return
+          return unless stub_with_block?(node)
+
+          check_block_body(node)
+        end
+
+        private
+
+        def check_and_return_call(node)
+          and_return_value(node) do |and_return, args|
+            unless dynamic?(args)
+              add_offense(and_return.loc.selector, message: MSG_BLOCK) do |corr|
+                AndReturnCallCorrector.new(and_return).call(corr)
+              end
+            end
+          end
+        end
+
+        def check_block_body(block)
+          body = block.body
+          unless dynamic?(body) # rubocop:disable Style/GuardClause
+            add_offense(block.loc.begin, message: MSG_AND_RETURN) do |corrector|
+              BlockBodyCorrector.new(block).call(corrector)
+            end
+          end
+        end
+
+        def dynamic?(node)
+          node && !node.recursive_literal_or_const?
+        end
+
+        # :nodoc:
+        class AndReturnCallCorrector
+          def initialize(node)
+            @node = node
+            @receiver = node.receiver
+            @arg = node.first_argument
+          end
+
+          def call(corrector)
+            # Heredoc autocorrection is not yet implemented.
+            return if heredoc?
+
+            corrector.replace(range, " { #{replacement} }")
+          end
+
+          private
+
+          attr_reader :node, :receiver, :arg
+
+          def heredoc?
+            arg.loc.is_a?(Parser::Source::Map::Heredoc)
+          end
+
+          def range
+            Parser::Source::Range.new(
+              node.source_range.source_buffer,
+              receiver.source_range.end_pos,
+              node.source_range.end_pos
+            )
+          end
+
+          def replacement
+            if hash_without_braces?
+              "{ #{arg.source} }"
+            else
+              arg.source
+            end
+          end
+
+          def hash_without_braces?
+            arg.hash_type? && !arg.braces?
+          end
+        end
+
+        # :nodoc:
+        class BlockBodyCorrector
+          def initialize(block)
+            @block = block
+            @node = block.parent
+            @body = block.body || NULL_BLOCK_BODY
+          end
+
+          def call(corrector)
+            # Heredoc autocorrection is not yet implemented.
+            return if heredoc?
+
+            corrector.replace(
+              block,
+              "#{block.send_node.source}.and_return(#{body.source})"
+            )
+          end
+
+          private
+
+          attr_reader :node, :block, :body
+
+          def heredoc?
+            body.loc.is_a?(Parser::Source::Map::Heredoc)
+          end
+
+          NULL_BLOCK_BODY = Struct.new(:loc, :source).new(nil, 'nil')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for let scattered across the example group.
+      #
+      # Group lets together
+      #
+      # @example
+      #   # bad
+      #   describe Foo do
+      #     let(:foo) { 1 }
+      #     subject { Foo }
+      #     let(:bar) { 2 }
+      #     before { prepare }
+      #     let!(:baz) { 3 }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     subject { Foo }
+      #     before { prepare }
+      #     let(:foo) { 1 }
+      #     let(:bar) { 2 }
+      #     let!(:baz) { 3 }
+      #   end
+      #
+      class ScatteredLet < Base
+        extend AutoCorrector
+
+        MSG = 'Group all let/let! blocks in the example group together.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group_with_body?(node)
+
+          check_let_declarations(node.body)
+        end
+
+        private
+
+        def check_let_declarations(body)
+          lets = body.each_child_node.select { |node| let?(node) }
+
+          first_let = lets.first
+          lets.each_with_index do |node, idx|
+            next if node.sibling_index == first_let.sibling_index + idx
+
+            add_offense(node) do |corrector|
+              RuboCop::RSpec::Corrector::MoveNode.new(
+                node, corrector, processed_source
+              ).move_after(first_let)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for setup scattered across multiple hooks in an example group.
+      #
+      # Unify `before`, `after`, and `around` hooks when possible.
+      #
+      # @example
+      #   # bad
+      #   describe Foo do
+      #     before { setup1 }
+      #     before { setup2 }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     before do
+      #       setup1
+      #       setup2
+      #     end
+      #   end
+      #
+      class ScatteredSetup < Base
+        include FinalEndLocation
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not define multiple `%<hook_name>s` hooks in the same ' \
+              'example group (also defined on %<lines>s).'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group?(node)
+
+          repeated_hooks(node).each do |occurrences|
+            occurrences.each do |occurrence|
+              message = message(occurrences, occurrence)
+              add_offense(occurrence, message: message) do |corrector|
+                autocorrect(corrector, occurrences.first, occurrence)
+              end
+            end
+          end
+        end
+
+        private
+
+        def repeated_hooks(node)
+          hooks = RuboCop::RSpec::ExampleGroup.new(node)
+            .hooks
+            .select(&:knowable_scope?)
+            .group_by { |hook| [hook.name, hook.scope, hook.metadata] }
+            .values
+            .reject(&:one?)
+
+          hooks.map do |hook|
+            hook.map(&:to_node)
+          end
+        end
+
+        def lines_msg(numbers)
+          if numbers.size == 1
+            "line #{numbers.first}"
+          else
+            "lines #{numbers.join(', ')}"
+          end
+        end
+
+        def message(occurrences, occurrence)
+          lines = occurrences.map(&:first_line)
+          lines_except_current = lines - [occurrence.first_line]
+          format(MSG, hook_name: occurrences.first.method_name,
+                      lines: lines_msg(lines_except_current))
+        end
+
+        def autocorrect(corrector, first_occurrence, occurrence)
+          return if first_occurrence == occurrence || !first_occurrence.body
+
+          # Take heredocs into account
+          body = occurrence.body&.source_range&.with(
+            end_pos: final_end_location(occurrence).begin_pos
+          )
+
+          corrector.insert_after(first_occurrence.body,
+                                 "\n#{body&.source}")
+          corrector.remove(range_by_whole_lines(occurrence.source_range,
+                                                include_final_newline: true))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for proper shared_context and shared_examples usage.
+      #
+      # If there are no examples defined, use shared_context.
+      # If there is no setup defined, use shared_examples.
+      #
+      # @example
+      #   # bad
+      #   RSpec.shared_context 'only examples here' do
+      #     it 'does x' do
+      #     end
+      #
+      #     it 'does y' do
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.shared_examples 'only examples here' do
+      #     it 'does x' do
+      #     end
+      #
+      #     it 'does y' do
+      #     end
+      #   end
+      #
+      # @example
+      #   # bad
+      #   RSpec.shared_examples 'only setup here' do
+      #     subject(:foo) { :bar }
+      #
+      #     let(:baz) { :bazz }
+      #
+      #     before do
+      #       something
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.shared_context 'only setup here' do
+      #     subject(:foo) { :bar }
+      #
+      #     let(:baz) { :bazz }
+      #
+      #     before do
+      #       something
+      #     end
+      #   end
+      #
+      class SharedContext < Base
+        extend AutoCorrector
+
+        MSG_EXAMPLES = "Use `shared_examples` when you don't define context."
+        MSG_CONTEXT  = "Use `shared_context` when you don't define examples."
+
+        # @!method examples?(node)
+        def_node_search :examples?, <<~PATTERN
+          (send nil? {#Includes.examples #Examples.all} ...)
+        PATTERN
+
+        # @!method context?(node)
+        def_node_search :context?, <<~PATTERN
+          (send nil?
+            {#Subjects.all #Helpers.all #Includes.context #Hooks.all} ...
+          )
+        PATTERN
+
+        # @!method shared_context(node)
+        def_node_matcher :shared_context, <<~PATTERN
+          (block (send #rspec? #SharedGroups.context ...) ...)
+        PATTERN
+
+        # @!method shared_example(node)
+        def_node_matcher :shared_example, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          context_with_only_examples(node) do
+            add_offense(node.send_node, message: MSG_EXAMPLES) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_examples')
+            end
+          end
+
+          examples_with_only_context(node) do
+            add_offense(node.send_node, message: MSG_CONTEXT) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_context')
+            end
+          end
+        end
+
+        private
+
+        def context_with_only_examples(node)
+          shared_context(node) { yield if examples?(node) && !context?(node) }
+        end
+
+        def examples_with_only_context(node)
+          shared_example(node) { yield if context?(node) && !examples?(node) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for consistent style for shared example names.
+      #
+      # Enforces either `string` or `symbol` for shared example names.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: string` (default)
+      #   # bad
+      #   it_behaves_like :foo_bar_baz
+      #   it_should_behave_like :foo_bar_baz
+      #   shared_examples :foo_bar_baz
+      #   shared_examples_for :foo_bar_baz
+      #   include_examples :foo_bar_baz
+      #
+      #   # good
+      #   it_behaves_like 'foo bar baz'
+      #   it_should_behave_like 'foo bar baz'
+      #   shared_examples 'foo bar baz'
+      #   shared_examples_for 'foo bar baz'
+      #   include_examples 'foo bar baz'
+      #
+      # @example `EnforcedStyle: symbol`
+      #   # bad
+      #   it_behaves_like 'foo bar baz'
+      #   it_should_behave_like 'foo bar baz'
+      #   shared_examples 'foo bar baz'
+      #   shared_examples_for 'foo bar baz'
+      #   include_examples 'foo bar baz'
+      #
+      #   # good
+      #   it_behaves_like :foo_bar_baz
+      #   it_should_behave_like :foo_bar_baz
+      #   shared_examples :foo_bar_baz
+      #   shared_examples_for :foo_bar_baz
+      #   include_examples :foo_bar_baz
+      #
+      class SharedExamples < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        # @!method shared_examples(node)
+        def_node_matcher :shared_examples, <<~PATTERN
+          {
+            (send #rspec? #SharedGroups.all $_ ...)
+            (send nil? #Includes.all $_ ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          shared_examples(node) do |ast_node|
+            next unless offense?(ast_node)
+
+            checker = new_checker(ast_node)
+            add_offense(ast_node, message: checker.message) do |corrector|
+              corrector.replace(ast_node, checker.preferred_style)
+            end
+          end
+        end
+
+        private
+
+        def offense?(ast_node)
+          if style == :symbol
+            ast_node.str_type?
+          else # string
+            ast_node.sym_type?
+          end
+        end
+
+        def new_checker(ast_node)
+          if style == :symbol
+            SymbolChecker.new(ast_node)
+          else # string
+            StringChecker.new(ast_node)
+          end
+        end
+
+        # :nodoc:
+        class SymbolChecker
+          MSG = 'Prefer %<prefer>s over `%<current>s` ' \
+                'to symbolize shared examples.'
+
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def message
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
+          end
+
+          def preferred_style
+            ":#{node.value.to_s.downcase.tr(' ', '_')}"
+          end
+        end
+
+        # :nodoc:
+        class StringChecker
+          MSG = 'Prefer %<prefer>s over `%<current>s` ' \
+                'to titleize shared examples.'
+
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def message
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
+          end
+
+          def preferred_style
+            "'#{node.value.to_s.tr('_', ' ')}'"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that chains of messages contain more than one element.
+      #
+      # @example
+      #   # bad
+      #   allow(foo).to receive_message_chain(:bar).and_return(42)
+      #
+      #   # good
+      #   allow(foo).to receive(:bar).and_return(42)
+      #
+      #   # also good
+      #   allow(foo).to receive(:bar, :baz)
+      #   allow(foo).to receive("bar.baz")
+      #
+      class SingleArgumentMessageChain < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<recommended>s` instead of calling ' \
+              '`%<called>s` with a single argument.'
+        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
+
+        # @!method message_chain(node)
+        def_node_matcher :message_chain, <<~PATTERN
+          (send _ {:receive_message_chain :stub_chain} $_)
+        PATTERN
+
+        # @!method single_key_hash?(node)
+        def_node_matcher :single_key_hash?, '(hash pair)'
+
+        def on_send(node)
+          message_chain(node) do |arg|
+            return if valid_usage?(arg)
+
+            method = node.method_name
+            msg = format(MSG, recommended: replacement(method), called: method)
+
+            add_offense(node.loc.selector, message: msg) do |corrector|
+              autocorrect(corrector, node, method, arg)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, method, arg)
+          corrector.replace(node.loc.selector, replacement(method))
+          autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
+          autocorrect_array_arg(corrector, arg) if arg.array_type?
+        end
+
+        def valid_usage?(node)
+          return true unless node.literal? || node.array_type?
+
+          case node.type
+          when :hash then !single_key_hash?(node)
+          when :array then !single_element_array?(node)
+          else node.to_s.include?('.')
+          end
+        end
+
+        def single_element_array?(node)
+          node.child_nodes.one?
+        end
+
+        def autocorrect_hash_arg(corrector, arg)
+          key, value = *arg.children.first
+
+          corrector.replace(arg, key_to_arg(key))
+          corrector.insert_after(arg.parent.loc.end,
+                                 ".and_return(#{value.source})")
+        end
+
+        def autocorrect_array_arg(corrector, arg)
+          value = arg.children.first
+
+          corrector.replace(arg, value.source)
+        end
+
+        def key_to_arg(node)
+          node.sym_type? ? ":#{node.value}" : node.source
+        end
+
+        def replacement(method)
+          method.equal?(:receive_message_chain) ? 'receive' : 'stub'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for passing a block to `skip` within examples.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     skip 'not yet implemented' do
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     skip 'not yet implemented'
+      #     do_something
+      #   end
+      #
+      #   # good - when outside example
+      #   skip 'not yet implemented' do
+      #   end
+      #
+      class SkipBlockInsideExample < Base
+        MSG = "Don't pass a block to `skip` inside examples."
+
+        def on_block(node)
+          return unless node.method?(:skip)
+          return unless inside_example?(node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def inside_example?(node)
+          node.each_ancestor(:block).any? { |ancestor| example?(ancestor) }
+        end
+      end
+    end
+  end
+end