rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # A helper for `inflected` style
+      module InflectedHelper
+        include RuboCop::RSpec::Language
+        extend NodePattern::Macros
+
+        MSG_INFLECTED = 'Prefer using `%<matcher_name>s` matcher over ' \
+                        '`%<predicate_name>s`.'
+
+        private
+
+        def check_inflected(node)
+          predicate_in_actual?(node) do |predicate, to, matcher|
+            msg = message_inflected(predicate)
+            add_offense(node, message: msg) do |corrector|
+              remove_predicate(corrector, predicate)
+              corrector.replace(node.loc.selector,
+                                true?(to, matcher) ? 'to' : 'not_to')
+              rewrite_matcher(corrector, predicate, matcher)
+            end
+          end
+        end
+
+        # @!method predicate_in_actual?(node)
+        def_node_matcher :predicate_in_actual?, <<~PATTERN
+          (send
+            (send nil? :expect {
+              (block $(send !nil? #predicate? ...) ...)
+              $(send !nil? #predicate? ...)})
+            $#Runners.all
+            $#boolean_matcher? ...)
+        PATTERN
+
+        # @!method be_bool?(node)
+        def_node_matcher :be_bool?, <<~PATTERN
+          (send nil? {:be :eq :eql :equal} {true false})
+        PATTERN
+
+        # @!method be_boolthy?(node)
+        def_node_matcher :be_boolthy?, <<~PATTERN
+          (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
+        PATTERN
+
+        def boolean_matcher?(node)
+          if cop_config['Strict']
+            be_boolthy?(node)
+          else
+            be_bool?(node) || be_boolthy?(node)
+          end
+        end
+
+        def predicate?(sym)
+          sym.to_s.end_with?('?')
+        end
+
+        def message_inflected(predicate)
+          format(MSG_INFLECTED,
+                 predicate_name: predicate.method_name,
+                 matcher_name: to_predicate_matcher(predicate.method_name))
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def to_predicate_matcher(name)
+          case name = name.to_s
+          when 'is_a?'
+            'be_a'
+          when 'instance_of?'
+            'be_an_instance_of'
+          when 'include?', 'respond_to?'
+            name[0..-2]
+          when 'exist?', 'exists?'
+            'exist'
+          when /\Ahas_/
+            name.sub('has_', 'have_')[0..-2]
+          else
+            "be_#{name[0..-2]}"
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def remove_predicate(corrector, predicate)
+          range = predicate.loc.dot.with(
+            end_pos: predicate.source_range.end_pos
+          )
+
+          corrector.remove(range)
+
+          block_range = LocationHelp.block_with_whitespace(predicate)
+          corrector.remove(block_range) if block_range
+        end
+
+        def rewrite_matcher(corrector, predicate, matcher)
+          args = LocationHelp.arguments_with_whitespace(predicate).source
+          block_loc = LocationHelp.block_with_whitespace(predicate)
+          block = block_loc ? block_loc.source : ''
+
+          corrector.replace(
+            matcher,
+            to_predicate_matcher(predicate.method_name) + args + block
+          )
+        end
+
+        def true?(to_symbol, matcher)
+          result = case matcher.method_name
+                   when :be, :eq
+                     matcher.first_argument.true_type?
+                   when :be_truthy, :a_truthy_value
+                     true
+                   when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
+                     false
+                   end
+          to_symbol == :to ? result : !result
+        end
+      end
+
+      # A helper for `explicit` style
+      module ExplicitHelper # rubocop:disable Metrics/ModuleLength
+        include RuboCop::RSpec::Language
+        extend NodePattern::Macros
+
+        MSG_EXPLICIT = 'Prefer using `%<predicate_name>s` over ' \
+                       '`%<matcher_name>s` matcher.'
+        BUILT_IN_MATCHERS = %w[
+          be_truthy be_falsey be_falsy
+          have_attributes have_received
+          be_between be_within
+        ].freeze
+
+        private
+
+        def allowed_explicit_matchers
+          cop_config.fetch('AllowedExplicitMatchers', []) + BUILT_IN_MATCHERS
+        end
+
+        def check_explicit(node) # rubocop:disable Metrics/MethodLength
+          predicate_matcher_block?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              to_node = node.send_node
+              corrector_explicit(corrector, to_node, actual, matcher, to_node)
+            end
+            ignore_node(node.children.first)
+            return
+          end
+
+          return if part_of_ignored_node?(node)
+
+          predicate_matcher?(node) do |actual, matcher|
+            next unless replaceable_matcher?(matcher)
+
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              next if uncorrectable_matcher?(node, matcher)
+
+              corrector_explicit(corrector, node, actual, matcher, matcher)
+            end
+          end
+        end
+
+        def replaceable_matcher?(matcher)
+          case matcher.method_name.to_s
+          when 'include'
+            matcher.arguments.one?
+          else
+            true
+          end
+        end
+
+        def uncorrectable_matcher?(node, matcher)
+          heredoc_argument?(matcher) && !same_line?(node, matcher)
+        end
+
+        def heredoc_argument?(matcher)
+          matcher.arguments.select do |arg|
+            arg.str_type? || arg.dstr_type? || arg.xstr_type?
+          end.any?(&:heredoc?)
+        end
+
+        # @!method predicate_matcher?(node)
+        def_node_matcher :predicate_matcher?, <<~PATTERN
+          (send
+            (send nil? :expect $!nil?)
+            #Runners.all
+            {
+              $(send nil? #predicate_matcher_name? ...)
+              (block $(send nil? #predicate_matcher_name? ...) ...)
+            }
+            ...
+          )
+        PATTERN
+
+        # @!method predicate_matcher_block?(node)
+        def_node_matcher :predicate_matcher_block?, <<~PATTERN
+          (block
+            (send
+              (send nil? :expect $!nil?)
+              #Runners.all
+              $(send nil? #predicate_matcher_name?))
+            ...)
+        PATTERN
+
+        def predicate_matcher_name?(name)
+          name = name.to_s
+
+          return false if allowed_explicit_matchers.include?(name)
+
+          (name.start_with?('be_', 'have_') && !name.end_with?('?')) ||
+            %w[include respond_to].include?(name)
+        end
+
+        def message_explicit(matcher)
+          format(MSG_EXPLICIT,
+                 predicate_name: to_predicate_method(matcher.method_name),
+                 matcher_name: matcher.method_name)
+        end
+
+        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
+          replacement_matcher = replacement_matcher(to_node)
+          corrector.replace(matcher, replacement_matcher)
+          move_predicate(corrector, actual, matcher, block_child)
+          corrector.replace(to_node.loc.selector, 'to')
+        end
+
+        def move_predicate(corrector, actual, matcher, block_child)
+          predicate = to_predicate_method(matcher.method_name)
+          args = LocationHelp.arguments_with_whitespace(matcher).source
+          block_loc = LocationHelp.block_with_whitespace(block_child)
+          block = block_loc ? block_loc.source : ''
+
+          corrector.remove(block_loc) if block_loc
+          corrector.insert_after(actual, ".#{predicate}" + args + block)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def to_predicate_method(matcher)
+          case matcher = matcher.to_s
+          when 'be_a', 'be_an', 'be_a_kind_of', 'a_kind_of', 'be_kind_of'
+            'is_a?'
+          when 'be_an_instance_of', 'be_instance_of', 'an_instance_of'
+            'instance_of?'
+          when 'include'
+            'include?'
+          when 'respond_to'
+            'respond_to?'
+          when /\Ahave_(.+)/
+            "has_#{Regexp.last_match(1)}?"
+          else
+            "#{matcher[/\Abe_(.+)/, 1]}?"
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def replacement_matcher(node)
+          case [cop_config['Strict'], node.method?(:to)]
+          when [true, true]
+            'be(true)'
+          when [true, false]
+            'be(false)'
+          when [false, true]
+            'be_truthy'
+          when [false, false]
+            'be_falsey'
+          end
+        end
+      end
+
+      # Prefer using predicate matcher over using predicate method directly.
+      #
+      # RSpec defines magic matchers for predicate methods.
+      # This cop recommends to use the predicate matcher instead of using
+      # predicate method directly.
+      #
+      # @example Strict: true, EnforcedStyle: inflected (default)
+      #   # bad
+      #   expect(foo.something?).to be_truthy
+      #
+      #   # good
+      #   expect(foo).to be_something
+      #
+      #   # also good - It checks "true" strictly.
+      #   expect(foo.something?).to be(true)
+      #
+      # @example Strict: false, EnforcedStyle: inflected
+      #   # bad
+      #   expect(foo.something?).to be_truthy
+      #   expect(foo.something?).to be(true)
+      #
+      #   # good
+      #   expect(foo).to be_something
+      #
+      # @example Strict: true, EnforcedStyle: explicit
+      #   # bad
+      #   expect(foo).to be_something
+      #
+      #   # good - the above code is rewritten to it by this cop
+      #   expect(foo.something?).to be(true)
+      #
+      #   # bad - no autocorrect
+      #   expect(foo)
+      #     .to be_something(<<~TEXT)
+      #       bar
+      #     TEXT
+      #
+      #   # good
+      #   expect(foo.something?(<<~TEXT)).to be(true)
+      #     bar
+      #   TEXT
+      #
+      # @example Strict: false, EnforcedStyle: explicit
+      #   # bad
+      #   expect(foo).to be_something
+      #
+      #   # good - the above code is rewritten to it by this cop
+      #   expect(foo.something?).to be_truthy
+      #
+      class PredicateMatcher < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include InflectedHelper
+        include ExplicitHelper
+
+        RESTRICT_ON_SEND = Runners.all
+
+        def on_send(node)
+          case style
+          when :inflected
+            check_inflected(node)
+          when :explicit
+            check_explicit(node)
+          end
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          check_explicit(node) if style == :explicit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `once` and `twice` receive counts matchers usage.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).exactly(1).times
+      #   expect(foo).to receive(:bar).exactly(2).times
+      #   expect(foo).to receive(:bar).at_least(1).times
+      #   expect(foo).to receive(:bar).at_least(2).times
+      #   expect(foo).to receive(:bar).at_most(1).times
+      #   expect(foo).to receive(:bar).at_most(2).times
+      #
+      #   # good
+      #   expect(foo).to receive(:bar).once
+      #   expect(foo).to receive(:bar).twice
+      #   expect(foo).to receive(:bar).at_least(:once)
+      #   expect(foo).to receive(:bar).at_least(:twice)
+      #   expect(foo).to receive(:bar).at_most(:once)
+      #   expect(foo).to receive(:bar).at_most(:twice).times
+      #
+      class ReceiveCounts < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<alternative>s` instead of `%<original>s`.'
+
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        # @!method receive_counts(node)
+        def_node_matcher :receive_counts, <<~PATTERN
+          (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
+        PATTERN
+
+        # @!method stub?(node)
+        def_node_search :stub?, '(send nil? :receive ...)'
+
+        def on_send(node)
+          receive_counts(node) do |offending_node|
+            return unless stub?(offending_node.receiver)
+
+            offending_range = range(node, offending_node)
+
+            msg = message_for(offending_node, offending_range.source)
+            add_offense(offending_range, message: msg) do |corrector|
+              autocorrect(corrector, offending_node, offending_range)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node, range)
+          replacement = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
+
+          corrector.replace(range, replacement)
+        end
+
+        def message_for(node, source)
+          alternative = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
+          format(MSG, alternative: alternative, original: source)
+        end
+
+        def matcher_for(method, count)
+          matcher = count == 1 ? 'once' : 'twice'
+          if method == :exactly
+            ".#{matcher}"
+          else
+            ".#{method}(:#{matcher})"
+          end
+        end
+
+        def range(node, offending_node)
+          offending_node.loc.dot.with(
+            end_pos: node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for multiple messages stubbed on the same object.
+      #
+      # @safety
+      #   The autocorrection is marked as unsafe, because it may change the
+      #   order of stubs. This in turn may cause e.g. variables to be called
+      #   before they are defined.
+      #
+      # @example
+      #   # bad
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:baz).and_return(qux)
+      #   end
+      #
+      #   # good
+      #   before do
+      #     allow(Service).to receive_messages(foo: bar, baz: qux)
+      #   end
+      #
+      #   # good - ignore same message
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:foo).and_return(qux)
+      #   end
+      #
+      class ReceiveMessages < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `receive_messages` instead of multiple stubs on lines ' \
+              '%<loc>s.'
+
+        # @!method allow_receive_message?(node)
+        def_node_matcher :allow_receive_message?, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym _)) :and_return !#heredoc_or_splat?))
+        PATTERN
+
+        # @!method allow_argument(node)
+        def_node_matcher :allow_argument, <<~PATTERN
+          (send (send nil? :allow $_ ...) ...)
+        PATTERN
+
+        # @!method receive_node(node)
+        def_node_search :receive_node, <<~PATTERN
+          $(send (send nil? :receive ...) ...)
+        PATTERN
+
+        # @!method receive_arg(node)
+        def_node_search :receive_arg, <<~PATTERN
+          (send (send nil? :receive $_) ...)
+        PATTERN
+
+        # @!method receive_and_return_argument(node)
+        def_node_matcher :receive_and_return_argument, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym $_)) :and_return $_))
+        PATTERN
+
+        def on_begin(node)
+          repeated_receive_message(node).each do |item, repeated_lines, args|
+            next if repeated_lines.empty?
+
+            register_offense(item, repeated_lines, args)
+          end
+        end
+
+        private
+
+        def repeated_receive_message(node)
+          node
+            .children
+            .select { |child| allow_receive_message?(child) }
+            .group_by { |child| allow_argument(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines_and_arguments(items) }
+        end
+
+        def add_repeated_lines_and_arguments(items)
+          uniq_items = uniq_items(items)
+          repeated_lines = uniq_items.map(&:first_line)
+          uniq_items.map do |item|
+            [item, repeated_lines - [item.first_line], arguments(uniq_items)]
+          end
+        end
+
+        def uniq_items(items)
+          items.select do |item|
+            items.none? do |i|
+              receive_arg(item).first == receive_arg(i).first &&
+                !same_line?(item, i)
+            end
+          end
+        end
+
+        def arguments(items)
+          items.map do |item|
+            receive_and_return_argument(item) do |receive_arg, return_arg|
+              "#{normalize_receive_arg(receive_arg)}: " \
+                "#{normalize_return_arg(return_arg)}"
+            end
+          end
+        end
+
+        def normalize_receive_arg(receive_arg)
+          if requires_quotes?(receive_arg)
+            "'#{receive_arg}'"
+          else
+            receive_arg
+          end
+        end
+
+        def normalize_return_arg(return_arg)
+          if return_arg.hash_type? && !return_arg.braces?
+            "{ #{return_arg.source} }"
+          else
+            return_arg.source
+          end
+        end
+
+        def register_offense(item, repeated_lines, args)
+          add_offense(item, message: message(repeated_lines)) do |corrector|
+            if item.loc.line > repeated_lines.max
+              replace_to_receive_messages(corrector, item, args)
+            else
+              corrector.remove(item_range_by_whole_lines(item))
+            end
+          end
+        end
+
+        def message(repeated_lines)
+          format(MSG, loc: repeated_lines)
+        end
+
+        def replace_to_receive_messages(corrector, item, args)
+          receive_node(item) do |node|
+            corrector.replace(node,
+                              "receive_messages(#{args.join(', ')})")
+          end
+        end
+
+        def item_range_by_whole_lines(item)
+          range_by_whole_lines(item.source_range, include_final_newline: true)
+        end
+
+        def heredoc_or_splat?(node)
+          ((node.str_type? || node.dstr_type?) && node.heredoc?) ||
+            node.splat_type?
+        end
+
+        def requires_quotes?(value)
+          value.match?(/^:".*?"|=$|^\W+$/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer `not_to receive(...)` over `receive(...).never`.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).never
+      #
+      #   # good
+      #   expect(foo).not_to receive(:bar)
+      #
+      class ReceiveNever < Base
+        extend AutoCorrector
+        MSG = 'Use `not_to receive` instead of `never`.'
+        RESTRICT_ON_SEND = %i[never].freeze
+
+        # @!method method_on_stub?(node)
+        def_node_search :method_on_stub?, '(send nil? :receive ...)'
+
+        def on_send(node)
+          return unless node.method?(:never) && method_on_stub?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Remove redundant `around` hook.
+      #
+      # @example
+      #   # bad
+      #   around do |example|
+      #     example.run
+      #   end
+      #
+      #   # good
+      #
+      class RedundantAround < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `around` hook.'
+
+        RESTRICT_ON_SEND = %i[around].freeze
+
+        def on_block(node)
+          return unless match_redundant_around_hook_block?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless match_redundant_around_hook_send?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method match_redundant_around_hook_block?(node)
+        def_node_matcher :match_redundant_around_hook_block?, <<~PATTERN
+          ({block numblock} (send _ :around ...) ... (send _ :run))
+        PATTERN
+
+        # @!method match_redundant_around_hook_send?(node)
+        def_node_matcher :match_redundant_around_hook_send?, <<~PATTERN
+          (send
+            _
+            :around
+            ...
+            (block-pass
+              (sym :run)
+            )
+          )
+        PATTERN
+
+        def autocorrect(corrector, node)
+          corrector.remove(node)
+        end
+      end
+    end
+  end
+end