rubocop-rspec 1.37.0 → 1.40.0

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

@@ -58,6 +58,13 @@ module RuboCop
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
 
+        def_node_matcher :custom_matcher?, <<-PATTERN
+          (block {
+            (send nil? :matcher sym)
+            (send (const (const nil? :RSpec) :Matchers) :define sym)
+          } ...)
+        PATTERN
+
         def_node_search :ivar_usage, '$(ivar $_)'
 
         def_node_search :ivar_assigned?, '(ivasgn % ...)'
@@ -66,8 +73,8 @@ module RuboCop
           return unless spec_group?(node)
 
           ivar_usage(node) do |ivar, name|
-            return if inside_dynamic_class?(ivar)
-            return if assignment_only? && !ivar_assigned?(node, name)
+            next if valid_usage?(ivar)
+            next if assignment_only? && !ivar_assigned?(node, name)
 
             add_offense(ivar)
           end
@@ -75,8 +82,10 @@ module RuboCop
 
         private
 
-        def inside_dynamic_class?(node)
-          node.each_ancestor(:block).any? { |block| dynamic_class?(block) }
+        def valid_usage?(node)
+          node.each_ancestor(:block).any? do |block|
+            dynamic_class?(block) || custom_matcher?(block)
+          end
         end
 
         def assignment_only?

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

@@ -32,8 +32,6 @@ module RuboCop
       #     it { expect_something_else }
       #
       class LeadingSubject < Cop
-        include RangeHelp
-
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
         def on_block(node)
@@ -58,10 +56,9 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             first_node = find_first_offending_node(node)
-            first_node_position = first_node.loc.expression
-            indent = "\n" + ' ' * first_node.loc.column
-            corrector.insert_before(first_node_position, node.source + indent)
-            corrector.remove(node_range(node))
+            RuboCop::RSpec::Corrector::MoveNode.new(
+              node, corrector, processed_source
+            ).move_before(first_node)
           end
         end
 
@@ -75,10 +72,6 @@ module RuboCop
           node.parent.children.find { |sibling| offending?(sibling) }
         end
 
-        def node_range(node)
-          range_by_whole_lines(node.source_range, include_final_newline: true)
-        end
-
         def in_spec_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
             example?(ancestor)

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

@@ -31,9 +31,6 @@ module RuboCop
       #     expect(some).to be
       #   end
       class LetBeforeExamples < Cop
-        include RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
-
         MSG = 'Move `let` before the examples in the group.'
 
         def_node_matcher :example_or_group?, <<-PATTERN
@@ -52,11 +49,9 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             first_example = find_first_example(node.parent)
-            first_example_pos = first_example.loc.expression
-            indent = "\n" + ' ' * first_example.loc.column
-
-            corrector.insert_before(first_example_pos, source(node) + indent)
-            corrector.remove(node_range_with_surrounding_space(node))
+            RuboCop::RSpec::Corrector::MoveNode.new(
+              node, corrector, processed_source
+            ).move_before(first_example)
           end
         end
 
@@ -80,19 +75,6 @@ module RuboCop
         def find_first_example(node)
           node.children.find { |sibling| example_or_group?(sibling) }
         end
-
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          node.loc.expression.with(end_pos: final_end_location(node).end_pos)
-        end
       end
     end
   end

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   # better
       #   thing = Thing.new(baz: 42)
-      #   allow(foo).to receive(bar: thing)
+      #   allow(foo).to receive(:bar).and_return(thing)
       #
       class MessageChain < Cop
         MSG = 'Avoid stubbing using `%<method>s`.'

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

@@ -6,11 +6,11 @@ module RuboCop
       # Checks for explicitly referenced test subjects.
       #
       # RSpec lets you declare an "implicit subject" using `subject { ... }`
-      # which allows for tests like `it { should be_valid }`. If you need to
-      # reference your test subject you should explicitly name it using
-      # `subject(:your_subject_name) { ... }`. Your test subjects should be
-      # the most important object in your tests so they deserve a descriptive
-      # name.
+      # which allows for tests like `it { is_expected.to be_valid }`.
+      # If you need to reference your test subject you should explicitly
+      # name it using `subject(:your_subject_name) { ... }`. Your test subjects
+      # should be the most important object in your tests so they deserve
+      # a descriptive name.
       #
       # This cop can be configured in your configuration using the
       # `IgnoreSharedExamples` which will not report offenses for implicit
@@ -39,7 +39,7 @@ module RuboCop
       #   RSpec.describe Foo do
       #     subject(:user) { described_class.new }
       #
-      #     it { should be_valid }
+      #     it { is_expected.to be_valid }
       #   end
       class NamedSubject < Cop
         MSG = 'Name your test subject if you need '\

data/lib/rubocop/cop/rspec/rails/http_status.rb

@@ -70,6 +70,7 @@ module RuboCop
                   'to describe HTTP status code.'
 
             attr_reader :node
+
             def initialize(node)
               @node = node
             end
@@ -110,6 +111,7 @@ module RuboCop
             ALLOWED_STATUSES = %i[error success missing redirect].freeze
 
             attr_reader :node
+
             def initialize(node)
               @node = node
             end

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

@@ -29,6 +29,17 @@ module RuboCop
       #       end
       #     end
       #
+      #     # good
+      #     RSpec.describe User do
+      #       it 'is valid' do
+      #         # ...
+      #       end
+      #
+      #       it 'is valid', :flag do
+      #         # ...
+      #       end
+      #     end
+      #
       class RepeatedDescription < Cop
         MSG = "Don't repeat descriptions within an example group."
 
@@ -47,14 +58,18 @@ module RuboCop
           grouped_examples =
             RuboCop::RSpec::ExampleGroup.new(node)
               .examples
-              .group_by(&:doc_string)
+              .group_by { |example| example_signature(example) }
 
           grouped_examples
-            .select { |description, group| description && group.size > 1 }
+            .select { |signatures, group| signatures.any? && group.size > 1 }
             .values
             .flatten
             .map(&:definition)
         end
+
+        def example_signature(example)
+          [example.metadata, example.doc_string]
+        end
       end
     end
   end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated describe and context block body.
+      #
+      # @example
+      #
+      #    # bad
+      #    describe 'cool feature x' do
+      #      it { cool_predicate }
+      #    end
+      #
+      #    describe 'cool feature y' do
+      #      it { cool_predicate }
+      #    end
+      #
+      #    # good
+      #    describe 'cool feature' do
+      #      it { cool_predicate }
+      #    end
+      #
+      #    describe 'another cool feature' do
+      #      it { another_predicate }
+      #    end
+      #
+      #    # good
+      #    context 'when case x', :tag do
+      #      it { cool_predicate }
+      #    end
+      #
+      #    context 'when case y' do
+      #      it { cool_predicate }
+      #    end
+      #
+      #    # good
+      #    context Array do
+      #      it { is_expected.to respond_to :each }
+      #    end
+      #
+      #    context Hash do
+      #      it { is_expected.to respond_to :each }
+      #    end
+      #
+      class RepeatedExampleGroupBody < Cop
+        MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
+
+        def_node_matcher :several_example_groups?, <<-PATTERN
+          (begin <#example_group_with_body? #example_group_with_body? ...>)
+        PATTERN
+
+        def_node_matcher :metadata, '(block (send _ _ _ $...) ...)'
+        def_node_matcher :body, '(block _ args $...)'
+        def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
+
+        def_node_matcher :skip_or_pending?, <<-PATTERN
+          (block <(send nil? {:skip :pending}) ...>)
+        PATTERN
+
+        def on_begin(node)
+          return unless several_example_groups?(node)
+
+          repeated_group_bodies(node).each do |group, repeats|
+            add_offense(group, message: message(group, repeats))
+          end
+        end
+
+        private
+
+        def repeated_group_bodies(node)
+          node
+            .children
+            .select { |child| example_group_with_body?(child) }
+            .reject { |child| skip_or_pending?(child) }
+            .group_by { |group| signature_keys(group) }
+            .values
+            .reject(&:one?)
+            .flat_map { |groups| add_repeated_lines(groups) }
+        end
+
+        def add_repeated_lines(groups)
+          repeated_lines = groups.map(&:first_line)
+          groups.map { |group| [group, repeated_lines - [group.first_line]] }
+        end
+
+        def signature_keys(group)
+          [metadata(group), body(group), const_arg(group)]
+        end
+
+        def message(group, repeats)
+          format(MSG, group: group.method_name, loc: repeats)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated example group descriptions.
+      #
+      # @example
+      #
+      #    # bad
+      #    describe 'cool feature' do
+      #      # example group
+      #    end
+      #
+      #    describe 'cool feature' do
+      #      # example group
+      #    end
+      #
+      #    # bad
+      #    context 'when case x' do
+      #      # example group
+      #    end
+      #
+      #    describe 'when case x' do
+      #      # example group
+      #    end
+      #
+      #    # good
+      #    describe 'cool feature' do
+      #      # example group
+      #    end
+      #
+      #    describe 'another cool feature' do
+      #      # example group
+      #    end
+      #
+      #    # good
+      #    context 'when case x' do
+      #      # example group
+      #    end
+      #
+      #    context 'when another case' do
+      #      # example group
+      #    end
+      #
+      class RepeatedExampleGroupDescription < Cop
+        MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
+
+        def_node_matcher :several_example_groups?, <<-PATTERN
+          (begin <#example_group? #example_group? ...>)
+        PATTERN
+
+        def_node_matcher :doc_string_and_metadata, <<-PATTERN
+          (block (send _ _ $_ $...) ...)
+        PATTERN
+
+        def_node_matcher :skip_or_pending?, <<-PATTERN
+          (block <(send nil? {:skip :pending}) ...>)
+        PATTERN
+
+        def_node_matcher :empty_description?, '(block (send _ _) ...)'
+
+        def on_begin(node)
+          return unless several_example_groups?(node)
+
+          repeated_group_descriptions(node).each do |group, repeats|
+            add_offense(group, message: message(group, repeats))
+          end
+        end
+
+        private
+
+        def repeated_group_descriptions(node)
+          node
+            .children
+            .select { |child| example_group?(child) }
+            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| empty_description?(child) }
+            .group_by { |group| doc_string_and_metadata(group) }
+            .values
+            .reject(&:one?)
+            .flat_map { |groups| add_repeated_lines(groups) }
+        end
+
+        def add_repeated_lines(groups)
+          repeated_lines = groups.map(&:first_line)
+          groups.map { |group| [group, repeated_lines - [group.first_line]] }
+        end
+
+        def message(group, repeats)
+          format(MSG, group: group.method_name, loc: repeats)
+        end
+      end
+    end
+  end
+end

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

@@ -35,6 +35,15 @@ module RuboCop
           check_let_declarations(node.body)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            first_let = find_first_let(node.parent)
+            RuboCop::RSpec::Corrector::MoveNode.new(
+              node, corrector, processed_source
+            ).move_after(first_let)
+          end
+        end
+
         private
 
         def check_let_declarations(body)
@@ -47,6 +56,10 @@ module RuboCop
             add_offense(node)
           end
         end
+
+        def find_first_let(node)
+          node.children.find { |child| let?(child) }
+        end
       end
     end
   end

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

@@ -23,25 +23,43 @@ module RuboCop
       #   end
       #
       class ScatteredSetup < Cop
-        MSG = 'Do not define multiple hooks in the same example group.'
+        MSG = 'Do not define multiple `%<hook_name>s` hooks in the same '\
+              'example group (also defined on %<lines>s).'
 
         def on_block(node)
           return unless example_group?(node)
 
-          analyzable_hooks(node).each do |repeated_hook|
-            add_offense(repeated_hook)
+          repeated_hooks(node).each do |occurrences|
+            lines = occurrences.map(&:first_line)
+
+            occurrences.each do |occurrence|
+              lines_except_current = lines - [occurrence.first_line]
+              message = format(MSG, hook_name: occurrences.first.method_name,
+                               lines: lines_msg(lines_except_current))
+              add_offense(occurrence, message: message)
+            end
           end
         end
 
-        def analyzable_hooks(node)
-          RuboCop::RSpec::ExampleGroup.new(node)
+        def repeated_hooks(node)
+          hooks = RuboCop::RSpec::ExampleGroup.new(node)
             .hooks
-            .select { |hook| hook.knowable_scope? && hook.valid_scope? }
-            .group_by { |hook| [hook.name, hook.scope] }
+            .select(&:knowable_scope?)
+            .group_by { |hook| [hook.name, hook.scope, hook.metadata] }
             .values
             .reject(&:one?)
-            .flatten
-            .map(&:to_node)
+
+          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
       end
     end