rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer negated matchers over `to change.by(0)`.
+      #
+      # In the case of composite expectations, cop suggest using the
+      # negation matchers of `RSpec::Matchers#change`.
+      #
+      # By default the cop does not support autocorrect of
+      # compound expectations, but if you set the
+      # negated matcher for `change`, e.g. `not_change` with
+      # the `NegatedMatcher` option, the cop will perform the autocorrection.
+      #
+      # @example NegatedMatcher: ~ (default)
+      #   # bad
+      #   expect { run }.to change(Foo, :bar).by(0)
+      #   expect { run }.to change { Foo.bar }.by(0)
+      #
+      #   # bad - compound expectations (does not support autocorrection)
+      #   expect { run }
+      #     .to change(Foo, :bar).by(0)
+      #     .and change(Foo, :baz).by(0)
+      #   expect { run }
+      #     .to change { Foo.bar }.by(0)
+      #     .and change { Foo.baz }.by(0)
+      #
+      #   # good
+      #   expect { run }.not_to change(Foo, :bar)
+      #   expect { run }.not_to change { Foo.bar }
+      #
+      #   # good - compound expectations
+      #   define_negated_matcher :not_change, :change
+      #   expect { run }
+      #     .to not_change(Foo, :bar)
+      #     .and not_change(Foo, :baz)
+      #   expect { run }
+      #     .to not_change { Foo.bar }
+      #     .and not_change { Foo.baz }
+      #
+      # @example NegatedMatcher: not_change
+      #   # bad (support autocorrection to good case)
+      #   expect { run }
+      #     .to change(Foo, :bar).by(0)
+      #     .and change(Foo, :baz).by(0)
+      #   expect { run }
+      #     .to change { Foo.bar }.by(0)
+      #     .and change { Foo.baz }.by(0)
+      #
+      #   # good
+      #   define_negated_matcher :not_change, :change
+      #   expect { run }
+      #     .to not_change(Foo, :bar)
+      #     .and not_change(Foo, :baz)
+      #   expect { run }
+      #     .to not_change { Foo.bar }
+      #     .and not_change { Foo.baz }
+      #
+      class ChangeByZero < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `not_to change` over `to %<method>s.by(0)`.'
+        MSG_COMPOUND = 'Prefer %<preferred>s with compound expectations ' \
+                       'over `%<method>s.by(0)`.'
+        CHANGE_METHODS = Set[:change, :a_block_changing, :changing].freeze
+        RESTRICT_ON_SEND = CHANGE_METHODS.freeze
+
+        # @!method expect_change_with_arguments(node)
+        def_node_matcher :expect_change_with_arguments, <<~PATTERN
+          (send
+            $(send nil? CHANGE_METHODS ...) :by
+            (int 0))
+        PATTERN
+
+        # @!method expect_change_with_block(node)
+        def_node_matcher :expect_change_with_block, <<~PATTERN
+          (send
+            (block
+              $(send nil? CHANGE_METHODS)
+              (args)
+              (send (...) _)) :by
+            (int 0))
+        PATTERN
+
+        # @!method change_nodes(node)
+        def_node_search :change_nodes, <<~PATTERN
+          $(send nil? CHANGE_METHODS ...)
+        PATTERN
+
+        def on_send(node)
+          expect_change_with_arguments(node.parent) do |change|
+            register_offense(node.parent, change)
+          end
+
+          expect_change_with_block(node.parent.parent) do |change|
+            register_offense(node.parent.parent, change)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def register_offense(node, change_node)
+          if compound_expectations?(node)
+            add_offense(node.source_range,
+                        message: message_compound(change_node)) do |corrector|
+              autocorrect_compound(corrector, node)
+            end
+          else
+            add_offense(node.source_range,
+                        message: message(change_node)) do |corrector|
+              autocorrect(corrector, node, change_node)
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def compound_expectations?(node)
+          %i[and or & |].include?(node.parent.method_name)
+        end
+
+        def message(change_node)
+          format(MSG, method: change_node.method_name)
+        end
+
+        def message_compound(change_node)
+          format(MSG_COMPOUND, preferred: preferred_method,
+                               method: change_node.method_name)
+        end
+
+        def autocorrect(corrector, node, change_node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          corrector.replace(change_node.loc.selector, 'change')
+          range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+          corrector.remove(range)
+        end
+
+        def autocorrect_compound(corrector, node)
+          return unless negated_matcher
+
+          change_nodes(node) do |change_node|
+            corrector.replace(change_node.loc.selector, negated_matcher)
+            insert_operator(corrector, node, change_node)
+            remove_by_zero(corrector, node, change_node)
+          end
+        end
+
+        def insert_operator(corrector, node, change_node)
+          operator = node.right_siblings.first
+          return unless %i[& |].include?(operator)
+
+          corrector.insert_after(
+            replace_node(node, change_node), " #{operator}"
+          )
+        end
+
+        def replace_node(node, change_node)
+          expect_change_with_arguments(node) ? change_node : change_node.parent
+        end
+
+        def remove_by_zero(corrector, node, change_node)
+          range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+          if change_node.loc.line == range.line
+            corrector.remove(range)
+          else
+            corrector.remove(
+              range_by_whole_lines(range, include_final_newline: true)
+            )
+          end
+        end
+
+        def negated_matcher
+          cop_config['NegatedMatcher']
+        end
+
+        def preferred_method
+          negated_matcher ? "`#{negated_matcher}`" : 'negated matchers'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Enforces consistent use of `be_a` or `be_kind_of`.
+      #
+      # @example EnforcedStyle: be_a (default)
+      #   # bad
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      #   # good
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      # @example EnforcedStyle: be_kind_of
+      #   # bad
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      #   # good
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      class ClassCheck < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<preferred>s` over `%<current>s`.'
+
+        METHOD_NAMES_FOR_BE_A = ::Set[
+          :be_a,
+          :be_an
+        ].freeze
+
+        METHOD_NAMES_FOR_KIND_OF = ::Set[
+          :be_a_kind_of,
+          :be_kind_of
+        ].freeze
+
+        PREFERRED_METHOD_NAME_BY_STYLE = {
+          be_a: :be_a,
+          be_kind_of: :be_kind_of
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[
+          be_a
+          be_a_kind_of
+          be_an
+          be_kind_of
+        ].freeze
+
+        def on_send(node)
+          return unless offending?(node)
+
+          add_offense(
+            node.loc.selector,
+            message: format_message(node)
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.loc.selector, preferred_method_name)
+        end
+
+        def format_message(node)
+          format(
+            MSG,
+            current: node.method_name,
+            preferred: preferred_method_name
+          )
+        end
+
+        def offending?(node)
+          !node.receiver && !preferred_method_name?(node.method_name)
+        end
+
+        def preferred_method_name?(method_name)
+          preferred_method_names.include?(method_name)
+        end
+
+        def preferred_method_name
+          PREFERRED_METHOD_NAME_BY_STYLE[style]
+        end
+
+        def preferred_method_names
+          if style == :be_a
+            METHOD_NAMES_FOR_BE_A
+          else
+            METHOD_NAMES_FOR_KIND_OF
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks where `contain_exactly` is used.
+      #
+      # This cop checks for the following:
+      # - Prefer `match_array` when matching array values.
+      # - Prefer `be_empty` when using `contain_exactly` with no arguments.
+      #
+      # @example
+      #   # bad
+      #   it { is_expected.to contain_exactly(*array1, *array2) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(array1 + array2) }
+      #
+      #   # good
+      #   it { is_expected.to contain_exactly(content, *array) }
+      #
+      class ContainExactly < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `match_array` when matching array values.'
+        RESTRICT_ON_SEND = %i[contain_exactly].freeze
+
+        def on_send(node)
+          return if node.arguments.empty?
+
+          check_populated_collection(node)
+        end
+
+        private
+
+        def check_populated_collection(node)
+          return unless node.each_child_node.all?(&:splat_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect_for_populated_array(node, corrector)
+          end
+        end
+
+        def autocorrect_for_populated_array(node, corrector)
+          arrays = node.arguments.map do |splat_node|
+            splat_node.children.first
+          end
+          corrector.replace(
+            node,
+            "match_array(#{arrays.map(&:source).join(' + ')})"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # `context` should not be used for specifying methods.
+      #
+      # @example
+      #   # bad
+      #   context '#foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   context '.foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe '#foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   describe '.foo_bar' do
+      #     # ...
+      #   end
+      #
+      class ContextMethod < Base
+        extend AutoCorrector
+
+        MSG = 'Use `describe` for testing methods.'
+
+        # @!method context_method(node)
+        def_node_matcher :context_method, <<~PATTERN
+          (block
+            (send #rspec? :context
+              ${(str #method_name?) (dstr (str #method_name?) ...)}
+            ...)
+          ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          context_method(node) do |context|
+            add_offense(context) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'describe')
+            end
+          end
+        end
+
+        private
+
+        def method_name?(description)
+          description.start_with?('.', '#')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that `context` docstring starts with an allowed prefix.
+      #
+      # The default list of prefixes is minimal. Users are encouraged to tailor
+      # the configuration to meet project needs. Other acceptable prefixes may
+      # include `if`, `unless`, `for`, `before`, `after`, or `during`.
+      # They may consist of multiple words if desired.
+      #
+      # @see http://www.betterspecs.org/#contexts
+      #
+      # @example `Prefixes` configuration
+      #   # .rubocop.yml
+      #   # RSpec/ContextWording:
+      #   #   Prefixes:
+      #   #     - when
+      #   #     - with
+      #   #     - without
+      #   #     - if
+      #   #     - unless
+      #   #     - for
+      #
+      # @example
+      #   # bad
+      #   context 'the display name not present' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context 'when the display name is not present' do
+      #     # ...
+      #   end
+      #
+      # This cop can be customized allowed context description pattern
+      # with `AllowedPatterns`. By default, there are no checking by pattern.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/ContextWording:
+      #   #   AllowedPatterns:
+      #   #     - とき$
+      #
+      # @example
+      #   # bad
+      #   context '条件を満たす' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context '条件を満たすとき' do
+      #     # ...
+      #   end
+      #
+      class ContextWording < Base
+        include AllowedPattern
+
+        MSG = 'Context description should match %<patterns>s.'
+
+        # @!method context_wording(node)
+        def_node_matcher :context_wording, <<~PATTERN
+          (block (send #rspec? { :context :shared_context } $({str dstr xstr} ...) ...) ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          context_wording(node) do |context|
+            if bad_pattern?(context)
+              message = format(MSG, patterns: expect_patterns)
+              add_offense(context, message: message)
+            end
+          end
+        end
+
+        private
+
+        def allowed_patterns
+          super + prefix_regexes
+        end
+
+        def prefix_regexes
+          @prefix_regexes ||= prefixes.map { |pre| /^#{Regexp.escape(pre)}\b/ }
+        end
+
+        def bad_pattern?(node)
+          return false if allowed_patterns.empty?
+
+          !matches_allowed_pattern?(description(node))
+        end
+
+        def description(context)
+          if context.xstr_type?
+            context.value.value
+          else
+            context.value
+          end
+        end
+
+        def expect_patterns
+          inspected = allowed_patterns.map do |pattern|
+            pattern.inspect.gsub(/\A"|"\z/, '/')
+          end
+          return inspected.first if inspected.size == 1
+
+          inspected << "or #{inspected.pop}"
+          inspected.join(', ')
+        end
+
+        def prefixes
+          Array(cop_config.fetch('Prefixes', []))
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,19 @@
 module RuboCop
   module Cop
     module RSpec
-      # Check that the first argument to the top level describe is a constant.
+      # Check that the first argument to the top-level describe is a constant.
+      #
+      # It can be configured to ignore strings when certain metadata is passed.
+      #
+      # Ignores Rails and Aruba `type` metadata by default.
+      #
+      # @example `IgnoredMetadata` configuration
+      #   # .rubocop.yml
+      #   # RSpec/DescribeClass:
+      #   #   IgnoredMetadata:
+      #   #     type:
+      #   #       - request
+      #   #       - controller
       #
       # @example
       #   # bad
@@ -12,41 +24,60 @@ module RuboCop
       #
       #   # good
       #   describe TestedClass do
+      #     subject { described_class }
+      #   end
+      #
+      #   describe 'TestedClass::VERSION' do
+      #     subject { Object.const_get(self.class.description) }
       #   end
       #
       #   describe "A feature example", type: :feature do
       #   end
-      class DescribeClass < Cop
-        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::TopLevelDescribe
+      #
+      class DescribeClass < Base
+        include TopLevelGroup
 
-        MSG = 'The first argument to describe should be '\
-              'the class or module being tested.'.freeze
+        MSG = 'The first argument to describe should be ' \
+              'the class or module being tested.'
 
-        def_node_matcher :valid_describe?, <<-PATTERN
-        {(send {(const nil :RSpec) nil} :describe const ...) (send nil :describe)}
+        # @!method example_group_with_ignored_metadata?(node)
+        def_node_matcher :example_group_with_ignored_metadata?, <<~PATTERN
+          (send #rspec? :describe ... (hash <#ignored_metadata? ...>))
         PATTERN
 
-        def_node_matcher :describe_with_metadata, <<-PATTERN
-        (send {(const nil :RSpec) nil} :describe
-          !const
-          ...
-          (hash $...))
+        # @!method not_a_const_described(node)
+        def_node_matcher :not_a_const_described, <<~PATTERN
+          (send #rspec? :describe $[!const !#string_constant?] ...)
         PATTERN
 
-        def_node_matcher :rails_metadata?, <<-PATTERN
-        (pair
-          (sym :type)
-          (sym {:request :feature :routing :view}))
+        # @!method sym_pair(node)
+        def_node_matcher :sym_pair, <<~PATTERN
+          (pair $sym $sym)
         PATTERN
 
-        def on_top_level_describe(node, args)
-          return if valid_describe?(node)
+        def on_top_level_group(node)
+          return if example_group_with_ignored_metadata?(node.send_node)
 
-          describe_with_metadata(node) do |pairs|
-            return if pairs.any?(&method(:rails_metadata?))
+          not_a_const_described(node.send_node) do |described|
+            add_offense(described)
           end
+        end
+
+        private
+
+        def ignored_metadata?(node)
+          sym_pair(node) do |key, value|
+            ignored_metadata[key.value.to_s].to_a.include?(value.value.to_s)
+          end
+        end
+
+        def string_constant?(described)
+          described.str_type? &&
+            described.value.match?(/^(?:(?:::)?[A-Z]\w*)+$/)
+        end
 
-          add_offense(args.first, :expression)
+        def ignored_metadata
+          cop_config['IgnoredMetadata'] || {}
         end
       end
     end

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

@@ -16,20 +16,35 @@ module RuboCop
       #
       #   describe MyClass, '.my_class_method' do
       #   end
-      class DescribeMethod < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Util
+      #
+      class DescribeMethod < Base
+        include TopLevelGroup
+
+        MSG = 'The second argument to describe should be the method ' \
+              "being tested. '#instance' or '.class'."
+
+        # @!method second_string_literal_argument(node)
+        def_node_matcher :second_string_literal_argument, <<~PATTERN
+          (block
+            (send #rspec? :describe _first_argument ${str dstr} ...)
+          ...)
+        PATTERN
 
-        MESSAGE = 'The second argument to describe should be the method ' \
-                  "being tested. '#instance' or '.class'".freeze
-        METHOD_STRING_MATCHER = /^[\#\.].+/
+        # @!method method_name?(node)
+        def_node_matcher :method_name?, <<~PATTERN
+          {(str #method_name_prefix?) (dstr (str #method_name_prefix?) ...)}
+        PATTERN
+
+        def on_top_level_group(node)
+          second_string_literal_argument(node) do |argument|
+            add_offense(argument) unless method_name?(argument)
+          end
+        end
 
-        def on_top_level_describe(_node, (_, second_arg))
-          return unless second_arg && second_arg.type.equal?(:str)
-          return if METHOD_STRING_MATCHER =~ one(second_arg.children)
+        private
 
-          add_offense(second_arg, :expression, MESSAGE)
+        def method_name_prefix?(description)
+          description.start_with?('.', '#')
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid describing symbols.
+      #
+      # @example
+      #   # bad
+      #   describe :my_method do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe '#my_method' do
+      #     # ...
+      #   end
+      #
+      # @see https://github.com/rspec/rspec-core/issues/1610
+      class DescribeSymbol < Base
+        MSG = 'Avoid describing symbols.'
+        RESTRICT_ON_SEND = %i[describe].freeze
+
+        # @!method describe_symbol?(node)
+        def_node_matcher :describe_symbol?, <<~PATTERN
+          (send #rspec? :describe $sym ...)
+        PATTERN
+
+        def on_send(node)
+          describe_symbol?(node) do |match|
+            add_offense(match)
+          end
+        end
+      end
+    end
+  end
+end