rubocop-rspec 1.12.0 → 1.13.0

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

@@ -17,7 +17,7 @@ module RuboCop
       #   expect(name).to eq("John")
       #
       class ExpectActual < Cop
-        MSG = 'Provide the actual you are testing to `expect(...)`'.freeze
+        MSG = 'Provide the actual you are testing to `expect(...)`.'.freeze
 
         SIMPLE_LITERALS = %i(
           true
@@ -41,7 +41,7 @@ module RuboCop
           regexp
         ).freeze
 
-        def_node_matcher :expect, '(send _ :expect $_)'
+        def_node_matcher :expect_literal, '(send _ :expect $#literal?)'
 
         def on_send(node)
           expect_literal(node) do |argument|
@@ -53,14 +53,8 @@ module RuboCop
 
         # This is not implement using a NodePattern because it seems
         # to not be able to match against an explicit (nil) sexp
-        def expect_literal(node)
-          return unless (argument = expect(node))
-
-          yield(argument) if literal?(argument)
-        end
-
         def literal?(node)
-          simple_literal?(node) || complex_literal?(node)
+          node && (simple_literal?(node) || complex_literal?(node))
         end
 
         def simple_literal?(node)

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

@@ -15,8 +15,8 @@ module RuboCop
       #   # good
       #   expect { my_app.print_report }.to output('Hello World').to_stdout
       class ExpectOutput < Cop
-        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` ' \
-              'instead of mutating $%<name>s'.freeze
+        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` '\
+              'instead of mutating $%<name>s.'.freeze
 
         def_node_matcher :hook?, Hooks::ALL.block_pattern
 

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

@@ -44,66 +44,67 @@ module RuboCop
       class FilePath < Cop
         include RuboCop::RSpec::TopLevelDescribe
 
-        MESSAGE = 'Spec path should end with `%s`'.freeze
-        ROUTING_PAIR = s(:pair, s(:sym, :type), s(:sym, :routing))
+        MSG = 'Spec path should end with `%s`.'.freeze
+
+        def_node_search :const_described?,  '(send _ :describe (const ...) ...)'
+        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
 
         def on_top_level_describe(node, args)
+          return unless const_described?(node) && single_top_level_describe?
           return if routing_spec?(args)
 
-          return unless single_top_level_describe?
-          object = args.first.const_name
-          return unless object
+          glob = glob_for(args)
 
-          path_matcher = matcher(object, args.at(1))
-          return if source_filename =~ regexp_from_glob(path_matcher)
+          return if filename_ends_with?(glob)
 
-          add_offense(node, :expression, format(MESSAGE, path_matcher))
+          add_offense(node, :expression, format(MSG, glob))
         end
 
         private
 
         def routing_spec?(args)
-          args.any? do |arg|
-            arg.children.include?(ROUTING_PAIR)
-          end
+          args.any?(&method(:routing_metadata?))
         end
 
-        def matcher(object, method)
-          path = File.join(parts(object))
-          if method && method.type.equal?(:str) && !ignore_methods?
-            path += '*' + method.str_content.gsub(/\W+/, '')
-          end
-
-          "#{path}*_spec.rb"
+        def glob_for((described_class, method_name))
+          "#{expected_path(described_class)}#{name_glob(method_name)}*_spec.rb"
         end
 
-        def parts(object)
-          object.split('::').map do |p|
-            custom_transform[p] || camel_to_underscore(p)
-          end
+        def name_glob(name)
+          return unless name && name.str_type?
+
+          "*#{name.str_content.gsub(/\W/, '')}" unless ignore_methods?
         end
 
-        def source_filename
-          processed_source.buffer.name
+        def expected_path(constant)
+          File.join(
+            constant.const_name.split('::').map do |name|
+              custom_transform.fetch(name) { camel_to_snake_case(name) }
+            end
+          )
         end
 
-        def camel_to_underscore(string)
+        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 regexp_from_glob(glob)
-          Regexp.new(glob.sub('.', '\\.').gsub('*', '.*') + '$')
+        def custom_transform
+          cop_config.fetch('CustomTransform', {})
         end
 
         def ignore_methods?
           cop_config['IgnoreMethods']
         end
 
-        def custom_transform
-          cop_config['CustomTransform'] || {}
+        def filename_ends_with?(glob)
+          File.fnmatch?("*#{glob}", processed_source.buffer.name)
+        end
+
+        def relevant_rubocop_rspec_file?(_)
+          true
         end
       end
     end

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

@@ -66,7 +66,7 @@ module RuboCop
         HOOKS = Hooks::ALL.node_pattern_union.freeze
 
         def_node_matcher :scoped_hook, <<-PATTERN
-        (block $(send nil #{HOOKS} (sym ${:each :example})) ...)
+          (block $(send nil #{HOOKS} (sym ${:each :example})) ...)
         PATTERN
 
         def_node_matcher :unscoped_hook, "(block $(send nil #{HOOKS}) ...)"

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

@@ -19,27 +19,27 @@ module RuboCop
       #   end
       #
       class InstanceSpy < Cop
-        MSG = 'Use `instance_spy` when you check your double ' \
-              'with `have_received`'.freeze
+        MSG = 'Use `instance_spy` when you check your double '\
+              'with `have_received`.'.freeze
 
         EXAMPLES = Examples::ALL.node_pattern_union.freeze
 
         def_node_matcher :example?, "(block $(send nil #{EXAMPLES}) ...)"
 
         def_node_search :null_double, <<-PATTERN
-        (lvasgn $_
-          (send
-            $(send nil :instance_double
-              ...) :as_null_object))
+          (lvasgn $_
+            (send
+              $(send nil :instance_double
+                ...) :as_null_object))
         PATTERN
 
         def_node_search :have_received_usage, <<-PATTERN
-        (send
-          (send nil :expect
-          (lvar $_)) :to
-          (send nil :have_received
+          (send
+            (send nil :expect
+            (lvar $_)) :to
+            (send nil :have_received
+            ...)
           ...)
-        ...)
         PATTERN
 
         def on_block(node)
@@ -47,7 +47,7 @@ module RuboCop
 
           null_double(node) do |var, receiver|
             have_received_usage(node) do |expected|
-              add_offense(receiver, :expression, MSG) if expected == var
+              add_offense(receiver, :expression) if expected == var
             end
           end
         end

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

@@ -47,7 +47,7 @@ module RuboCop
       #   end
       #
       class InstanceVariable < Cop
-        MESSAGE = 'Use `let` instead of an instance variable'.freeze
+        MSG = 'Use `let` instead of an instance variable.'.freeze
 
         EXAMPLE_GROUP_METHODS = ExampleGroups::ALL + SharedGroups::ALL
 
@@ -63,7 +63,7 @@ module RuboCop
           ivar_usage(node) do |ivar, name|
             return if assignment_only? && !ivar_assigned?(node, name)
 
-            add_offense(ivar, :expression, MESSAGE)
+            add_offense(ivar, :expression)
           end
         end
 

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that only one `it_behaves_like` style is used.
+      #
+      # @example when configuration is `EnforcedStyle: it_behaves_like`
+      #   # bad
+      #   it_should_behave_like 'a foo'
+      #
+      #   # good
+      #   it_behaves_like 'a foo'
+      #
+      # @example when configuration is `EnforcedStyle: it_should_behave_like`
+      #   # bad
+      #   it_behaves_like 'a foo'
+      #
+      #   # good
+      #   it_should_behave_like 'a foo'
+      class ItBehavesLike < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%s` over `%s` when including examples in '\
+              'a nested context.'.freeze
+
+        def_node_matcher :example_inclusion_offense, '(send _ % ...)'
+
+        def on_send(node)
+          example_inclusion_offense(node, alternative_style) do
+            add_offense(node, :expression)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, style, alternative_style)
+        end
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module RuboCop
       #     end
       #   end
       class LeadingSubject < Cop
-        MSG = 'Declare `subject` above any other `let` declarations'.freeze
+        MSG = 'Declare `subject` above any other `let` declarations.'.freeze
 
         def_node_matcher :subject?, '(block $(send nil :subject ...) args ...)'
 

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

@@ -12,13 +12,16 @@ module RuboCop
       #   allow(foo).to receive(bar: thing)
       #
       class MessageChain < Cop
-        MESSAGE = 'Avoid stubbing using `%<method>s`'.freeze
+        MSG = 'Avoid stubbing using `%<method>s`.'.freeze
+
+        def_node_matcher :message_chain, Matchers::MESSAGE_CHAIN.send_pattern
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless Matchers::MESSAGE_CHAIN.include?(method_name)
+          message_chain(node) { add_offense(node, :selector) }
+        end
 
-          add_offense(node, :selector, format(MESSAGE, method: method_name))
+        def message(node)
+          format(MSG, method: node.method_name)
         end
       end
     end

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

@@ -27,11 +27,12 @@ module RuboCop
       class MessageSpies < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_RECEIVE = 'Prefer `receive` for setting message ' \
-          'expectations.'.freeze
-        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
-          'expectations. Setup `%s` as a spy using `allow` or `instance_spy`.'
-          .freeze
+        MSG_RECEIVE = 'Prefer `receive` for setting message '\
+                      'expectations.'.freeze
+
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message '\
+                            'expectations. Setup `%s` as a spy using `allow`'\
+                            ' or `instance_spy`.'.freeze
 
         SUPPORTED_STYLES = %w(have_received receive).freeze
 

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

@@ -25,7 +25,7 @@ module RuboCop
       class MultipleDescribes < Cop
         include RuboCop::RSpec::TopLevelDescribe
 
-        MSG = 'Do not use multiple top level describes - ' \
+        MSG = 'Do not use multiple top level describes - '\
               'try to nest them.'.freeze
 
         def on_top_level_describe(node, _args)

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

@@ -48,22 +48,54 @@ module RuboCop
       class MultipleExpectations < Cop
         include ConfigurableMax
 
-        MSG = 'Example has too many expectations [%{total}/%{max}]'.freeze
+        MSG = 'Example has too many expectations [%{total}/%{max}].'.freeze
 
-        def_node_search :expect, '(send _ :expect ...)'
+        def_node_search :with_aggregated_failures?, '(sym :aggregate_failures)'
+        def_node_search :disabled_aggregated_failures?, <<-PATTERN
+          (pair (sym :aggregate_failures) (false))
+        PATTERN
+
+        def_node_matcher :expect?, '(send _ :expect ...)'
+        def_node_matcher :aggregate_failures?, <<-PATTERN
+          (block (send _ :aggregate_failures ...) ...)
+        PATTERN
 
         def on_block(node)
-          return unless example?(node) && (expectations = expect(node))
+          return unless example?(node)
+
+          return if example_with_aggregated_failures?(node)
+
+          expectations_count = to_enum(:find_expectation, node).count
 
-          return if expectations.count <= max_expectations
+          return if expectations_count <= max_expectations
 
-          self.max = expectations.count
+          self.max = expectations_count
 
-          flag_example(node, expectation_count: expectations.count)
+          flag_example(node, expectation_count: expectations_count)
         end
 
         private
 
+        def example_with_aggregated_failures?(node)
+          example = node.children.first
+
+          with_aggregated_failures?(example) &&
+            !disabled_aggregated_failures?(example)
+        end
+
+        def find_expectation(node, &block)
+          return unless node.is_a?(Parser::AST::Node)
+
+          yield if expect?(node) || aggregate_failures?(node)
+
+          # do not search inside of aggregate_failures block
+          return if aggregate_failures?(node)
+
+          node.children.each do |child|
+            find_expectation(child, &block)
+          end
+        end
+
         def flag_example(node, expectation_count:)
           method, = *node
 

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

@@ -38,8 +38,8 @@ module RuboCop
       #     it { should be_valid }
       #   end
       class NamedSubject < Cop
-        MSG = 'Name your test subject if '\
-              'you need to reference it explicitly.'.freeze
+        MSG = 'Name your test subject if you need '\
+              'to reference it explicitly.'.freeze
 
         def_node_matcher :rspec_block?, <<-PATTERN
           (block

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

@@ -5,7 +5,7 @@ module RuboCop
     module RSpec
       # Checks for nested example groups.
       #
-      # This cop is configurable using the `MaxNesting` option
+      # This cop is configurable using the `Max` option
       #
       # @example
       #   # bad
@@ -56,7 +56,7 @@ module RuboCop
       #
       #   # .rubocop.yml
       #   RSpec/NestedGroups:
-      #     MaxNesting: 2
+      #     Max: 2
       #
       #   context 'when using some feature' do
       #     let(:some)    { :various }
@@ -87,7 +87,7 @@ module RuboCop
       class NestedGroups < Cop
         include RuboCop::RSpec::TopLevelDescribe
 
-        MSG = 'Maximum example group nesting exceeded'.freeze
+        MSG = 'Maximum example group nesting exceeded [%d/%d].'.freeze
 
         DEPRECATED_MAX_KEY = 'MaxNesting'.freeze
 
@@ -98,8 +98,8 @@ module RuboCop
         def_node_search :find_contexts, ExampleGroups::ALL.block_pattern
 
         def on_top_level_describe(node, _)
-          find_nested_contexts(node.parent) do |context|
-            add_offense(context.children.first, :expression)
+          find_nested_contexts(node.parent) do |context, nesting|
+            add_offense(context.children.first, :expression, message(nesting))
           end
         end
 
@@ -107,7 +107,7 @@ module RuboCop
 
         def find_nested_contexts(node, nesting: 1, &block)
           find_contexts(node) do |nested_context|
-            yield(nested_context) if nesting > max_nesting
+            yield(nested_context, nesting) if nesting > max_nesting
 
             nested_context.each_child_node do |child|
               find_nested_contexts(child, nesting: nesting + 1, &block)
@@ -115,6 +115,10 @@ module RuboCop
           end
         end
 
+        def message(nesting)
+          format(MSG, nesting, max_nesting)
+        end
+
         def max_nesting
           @max_nesting ||= Integer(max_nesting_config)
         end