rubocop-rspec 1.7.0 → 3.0.2

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for redundant predicate matcher.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be_exist(bar)
+      #   expect(foo).not_to be_include(bar)
+      #   expect(foo).to be_all(bar)
+      #
+      #   # good
+      #   expect(foo).to exist(bar)
+      #   expect(foo).not_to include(bar)
+      #   expect(foo).to all be(bar)
+      #
+      class RedundantPredicateMatcher < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND =
+          %i[be_all be_cover be_end_with be_eql be_equal
+             be_exist be_exists be_include be_match
+             be_respond_to be_start_with].freeze
+
+        def on_send(node)
+          return if node.parent.block_type? || node.arguments.empty?
+          return unless replaceable_arguments?(node)
+
+          method_name = node.method_name.to_s
+          replaced = replaced_method_name(method_name)
+          add_offense(node, message: message(method_name,
+                                             replaced)) do |corrector|
+            unless node.method?(:be_all)
+              corrector.replace(node.loc.selector, replaced)
+            end
+          end
+        end
+
+        private
+
+        def message(bad_method, good_method)
+          format(MSG, bad: bad_method, good: good_method)
+        end
+
+        def replaceable_arguments?(node)
+          if node.method?(:be_all)
+            node.first_argument.send_type?
+          else
+            true
+          end
+        end
+
+        def replaced_method_name(method_name)
+          name = method_name.to_s.delete_prefix('be_')
+          if name == 'exists'
+            'exist'
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that `remove_const` is not used in specs.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     Object.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      #   before do
+      #     SomeClass.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      class RemoveConst < Base
+        include RuboCop::RSpec::Language
+
+        MSG = 'Do not use remove_const in specs. ' \
+              'Consider using e.g. `stub_const`.'
+        RESTRICT_ON_SEND = %i[send __send__].freeze
+
+        # @!method remove_const(node)
+        def_node_matcher :remove_const, <<~PATTERN
+          (send _ {:send | :__send__} (sym :remove_const) _)
+        PATTERN
+
+        # Check for offenses
+        def on_send(node)
+          remove_const(node) do
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated description strings in example groups.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe User do
+      #     it 'is valid' do
+      #       # ...
+      #     end
+      #
+      #     it 'is valid' do
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe User do
+      #     it 'is valid when first and last name are present' do
+      #       # ...
+      #     end
+      #
+      #     it 'is valid when last name only is present' do
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe User do
+      #     it 'is valid' do
+      #       # ...
+      #     end
+      #
+      #     it 'is valid', :flag do
+      #       # ...
+      #     end
+      #   end
+      #
+      class RepeatedDescription < Base
+        MSG = "Don't repeat descriptions within an example group."
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group?(node)
+
+          repeated_descriptions(node).each do |description|
+            add_offense(description)
+          end
+
+          repeated_its(node).each do |its|
+            add_offense(its)
+          end
+        end
+
+        private
+
+        # Select examples in the current scope with repeated description strings
+        def repeated_descriptions(node)
+          grouped_examples =
+            RuboCop::RSpec::ExampleGroup.new(node)
+              .examples
+              .reject { |n| n.definition.method?(:its) }
+              .group_by { |example| example_signature(example) }
+
+          grouped_examples
+            .select { |signatures, group| signatures.any? && group.size > 1 }
+            .values
+            .flatten
+            .map(&:definition)
+        end
+
+        def repeated_its(node)
+          grouped_its =
+            RuboCop::RSpec::ExampleGroup.new(node)
+              .examples
+              .select { |n| n.definition.method?(:its) }
+              .group_by { |example| its_signature(example) }
+
+          grouped_its
+            .select { |signatures, group| signatures.any? && group.size > 1 }
+            .values
+            .flatten
+            .map(&:to_node)
+        end
+
+        def example_signature(example)
+          [example.metadata, example.doc_string]
+        end
+
+        def its_signature(example)
+          [example.doc_string, example]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated examples within example groups.
+      #
+      # @example
+      #
+      #   it 'is valid' do
+      #     expect(user).to be_valid
+      #   end
+      #
+      #   it 'validates the user' do
+      #     expect(user).to be_valid
+      #   end
+      #
+      class RepeatedExample < Base
+        MSG = "Don't repeat examples within an example group."
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group?(node)
+
+          repeated_examples(node).each do |repeated_example|
+            add_offense(repeated_example)
+          end
+        end
+
+        private
+
+        def repeated_examples(node)
+          RuboCop::RSpec::ExampleGroup.new(node)
+            .examples
+            .group_by { |example| example_signature(example) }
+            .values
+            .reject(&:one?)
+            .flatten
+            .map(&:to_node)
+        end
+
+        def example_signature(example)
+          key_parts = [example.metadata, example.implementation]
+
+          if example.definition.method?(:its)
+            key_parts << example.definition.arguments
+          end
+
+          key_parts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# 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 < Base
+        include SkipOrPending
+
+        MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
+
+        # @!method several_example_groups?(node)
+        def_node_matcher :several_example_groups?, <<~PATTERN
+          (begin <#example_group_with_body? #example_group_with_body? ...>)
+        PATTERN
+
+        # @!method metadata(node)
+        def_node_matcher :metadata, '(block (send _ _ _ $...) ...)'
+
+        # @!method body(node)
+        def_node_matcher :body, '(block _ args $...)'
+
+        # @!method const_arg(node)
+        def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
+
+        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_inside_block?(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 < Base
+        include SkipOrPending
+
+        MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
+
+        # @!method several_example_groups?(node)
+        def_node_matcher :several_example_groups?, <<~PATTERN
+          (begin <#example_group? #example_group? ...>)
+        PATTERN
+
+        # @!method doc_string_and_metadata(node)
+        def_node_matcher :doc_string_and_metadata, <<~PATTERN
+          (block (send _ _ $_ $...) ...)
+        PATTERN
+
+        # @!method empty_description?(node)
+        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_inside_block?(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/repeated_include_example.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated include of shared examples.
+      #
+      # @example
+      #   # bad
+      #   describe 'foo' do
+      #     include_examples 'cool stuff'
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   # bad
+      #   describe 'foo' do
+      #     it_behaves_like 'a cool', 'thing'
+      #     it_behaves_like 'a cool', 'thing'
+      #   end
+      #
+      #   # bad
+      #   context 'foo' do
+      #     it_should_behave_like 'a duck'
+      #     it_should_behave_like 'a duck'
+      #   end
+      #
+      #   # good
+      #   describe 'foo' do
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   describe 'bar' do
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   # good
+      #   describe 'foo' do
+      #     it_behaves_like 'a cool', 'thing'
+      #     it_behaves_like 'a cool', 'person'
+      #   end
+      #
+      #   # good
+      #   context 'foo' do
+      #     it_should_behave_like 'a duck'
+      #     it_should_behave_like 'a goose'
+      #   end
+      #
+      class RepeatedIncludeExample < Base
+        MSG = 'Repeated include of shared_examples %<name>s ' \
+              'on line(s) %<repeat>s'
+
+        # @!method several_include_examples?(node)
+        def_node_matcher :several_include_examples?, <<~PATTERN
+          (begin <#include_examples? #include_examples? ...>)
+        PATTERN
+
+        # @!method include_examples?(node)
+        def_node_matcher :include_examples?,
+                         '(send nil? #Includes.examples ...)'
+
+        # @!method shared_examples_name(node)
+        def_node_matcher :shared_examples_name,
+                         '(send nil? #Includes.examples $_name ...)'
+
+        def on_begin(node)
+          return unless several_include_examples?(node)
+
+          repeated_include_examples(node).each do |item, repeats|
+            add_offense(item, message: message(item, repeats))
+          end
+        end
+
+        private
+
+        def repeated_include_examples(node)
+          node
+            .children
+            .select { |child| literal_include_examples?(child) }
+            .group_by { |child| signature_keys(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines(items) }
+        end
+
+        def literal_include_examples?(node)
+          include_examples?(node) &&
+            node.arguments.all?(&:recursive_literal_or_const?)
+        end
+
+        def add_repeated_lines(items)
+          repeated_lines = items.map(&:first_line)
+          items.map { |item| [item, repeated_lines - [item.first_line]] }
+        end
+
+        def signature_keys(item)
+          item.arguments
+        end
+
+        def message(item, repeats)
+          format(MSG, name: shared_examples_name(item).source, repeat: repeats)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for repeated calls to subject missing that it is memoized.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     subject
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   it do
+      #     expect { subject }.to change { A.count }
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect { my_method }.to change { A.count }
+      #     expect { my_method }.to not_change { A.count }
+      #   end
+      #
+      #   # also good
+      #   it do
+      #     expect { subject.a }.to change { A.count }
+      #     expect { subject.b }.to not_change { A.count }
+      #   end
+      #
+      class RepeatedSubjectCall < Base
+        include TopLevelGroup
+
+        MSG = 'Calls to subject are memoized, this block is misleading'
+
+        # @!method subject?(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject?(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method subject_calls(node, method_name)
+        def_node_search :subject_calls, <<~PATTERN
+          (send nil? %)
+        PATTERN
+
+        def on_top_level_group(node)
+          @subjects_by_node = detect_subjects_in_scope(node)
+
+          detect_offenses_in_block(node)
+        end
+
+        private
+
+        def detect_offense(subject_node)
+          return if subject_node.chained?
+          return if subject_node.parent.send_type?
+          return unless (block_node = expect_block(subject_node))
+
+          add_offense(block_node)
+        end
+
+        def expect_block(node)
+          node.each_ancestor(:block).find { |block| block.method?(:expect) }
+        end
+
+        def detect_offenses_in_block(node, subject_names = [])
+          subject_names = [*subject_names, *@subjects_by_node[node]]
+
+          if example?(node)
+            return detect_offenses_in_example(node, subject_names)
+          end
+
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            detect_offenses_in_block(child, subject_names)
+          end
+        end
+
+        def detect_offenses_in_example(node, subject_names)
+          return unless node.body
+
+          subjects_used = Hash.new(false)
+
+          subject_calls(node.body, Set[*subject_names, :subject]).each do |call|
+            if subjects_used[call.method_name]
+              detect_offense(call)
+            else
+              subjects_used[call.method_name] = true
+            end
+          end
+        end
+
+        def detect_subjects_in_scope(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            subject?(child) do |name|
+              outer_example_group = child.each_ancestor(:block).find do |a|
+                example_group?(a)
+              end
+
+              (h[outer_example_group] ||= []) << name
+            end
+          end
+        end
+      end
+    end
+  end
+end