rubocop-rspec 2.25.0 → 2.27.1

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

@@ -22,6 +22,9 @@ module RuboCop
       #   it 'should find nothing' do
       #   end
       #
+      #   it 'will find nothing' do
+      #   end
+      #
       #   # good
       #   it 'finds nothing' do
       #   end
@@ -47,25 +50,30 @@ module RuboCop
         extend AutoCorrector
 
         MSG_SHOULD = 'Do not use should when describing your tests.'
+        MSG_WILL   = 'Do not use the future tense when describing your tests.'
         MSG_IT     = "Do not repeat 'it' when describing your tests."
         MSG_INSUFFICIENT_DESCRIPTION = 'Your example description is ' \
                                        'insufficient.'
 
         SHOULD_PREFIX = /\Ashould(?:n't)?\b/i.freeze
+        WILL_PREFIX   = /\A(?:will|won't)\b/i.freeze
         IT_PREFIX     = /\Ait /i.freeze
 
         # @!method it_description(node)
-        def_node_matcher :it_description, <<-PATTERN
+        def_node_matcher :it_description, <<~PATTERN
           (block (send _ :it ${
             (str $_)
             (dstr (str $_ ) ...)
           } ...) ...)
         PATTERN
 
+        # rubocop:disable Metrics/MethodLength
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           it_description(node) do |description_node, message|
             if message.match?(SHOULD_PREFIX)
               add_wording_offense(description_node, MSG_SHOULD)
+            elsif message.match?(WILL_PREFIX)
+              add_wording_offense(description_node, MSG_WILL)
             elsif message.match?(IT_PREFIX)
               add_wording_offense(description_node, MSG_IT)
             elsif insufficient_docstring?(description_node)
@@ -74,6 +82,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         private
 
@@ -100,7 +109,7 @@ module RuboCop
         def replacement_text(node)
           text = text(node)
 
-          if text.match?(SHOULD_PREFIX)
+          if text.match?(SHOULD_PREFIX) || text.match?(WILL_PREFIX)
             RuboCop::RSpec::Wording.new(
               text,
               ignore:  ignored_words,

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

@@ -29,7 +29,7 @@ module RuboCop
         MSG = 'Excessive whitespace.'
 
         # @!method example_description(node)
-        def_node_matcher :example_description, <<-PATTERN
+        def_node_matcher :example_description, <<~PATTERN
           (send _ {#Examples.all #ExampleGroups.all} ${
             $str
             $(dstr ({str dstr `sym} ...) ...)

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

@@ -50,7 +50,8 @@ module RuboCop
           regexp
         ].freeze
 
-        SUPPORTED_MATCHERS = %i[eq eql equal be].freeze
+        SKIPPED_MATCHERS = %i[route_to be_routable].freeze
+        CORRECTABLE_MATCHERS = %i[eq eql equal be].freeze
 
         # @!method expect_literal(node)
         def_node_matcher :expect_literal, <<~PATTERN
@@ -66,8 +67,10 @@ module RuboCop
 
         def on_send(node)
           expect_literal(node) do |actual, matcher, expected|
+            next if SKIPPED_MATCHERS.include?(matcher)
+
             add_offense(actual.source_range) do |corrector|
-              next unless SUPPORTED_MATCHERS.include?(matcher)
+              next unless CORRECTABLE_MATCHERS.include?(matcher)
               next if literal?(expected)
 
               swap(corrector, actual, expected)

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

@@ -38,12 +38,12 @@ module RuboCop
         RESTRICT_ON_SEND = %i[change].freeze
 
         # @!method expect_change_with_arguments(node)
-        def_node_matcher :expect_change_with_arguments, <<-PATTERN
+        def_node_matcher :expect_change_with_arguments, <<~PATTERN
           (send nil? :change $_ ({sym str} $_))
         PATTERN
 
         # @!method expect_change_with_block(node)
-        def_node_matcher :expect_change_with_block, <<-PATTERN
+        def_node_matcher :expect_change_with_block, <<~PATTERN
           (block
             (send nil? :change)
             (args)

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

@@ -22,10 +22,7 @@ module RuboCop
         def on_gvasgn(node)
           return unless inside_example_scope?(node)
 
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          variable_name, _rhs = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
-          name = variable_name[1..]
+          name = node.name[1..]
           return unless name.eql?('stdout') || name.eql?('stderr')
 
           add_offense(node.loc.name, message: format(MSG, name: name))

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

@@ -56,7 +56,7 @@ module RuboCop
         MSG = 'Focused spec found.'
 
         # @!method focusable_selector?(node)
-        def_node_matcher :focusable_selector?, <<-PATTERN
+        def_node_matcher :focusable_selector?, <<~PATTERN
           {
             #ExampleGroups.regular
             #ExampleGroups.skipped
@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         # @!method metadata(node)
-        def_node_matcher :metadata, <<-PATTERN
+        def_node_matcher :metadata, <<~PATTERN
           {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
            (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN

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

@@ -66,12 +66,12 @@ module RuboCop
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
         # @!method scoped_hook(node)
-        def_node_matcher :scoped_hook, <<-PATTERN
+        def_node_matcher :scoped_hook, <<~PATTERN
           ({block numblock} $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
         # @!method unscoped_hook(node)
-        def_node_matcher :unscoped_hook, <<-PATTERN
+        def_node_matcher :unscoped_hook, <<~PATTERN
           ({block numblock} $(send _ #Hooks.all) ...)
         PATTERN
 

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
         # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
             ({block numblock} {
               (send #rspec? #ExampleGroups.all ...)

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

@@ -22,7 +22,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
 
         # @!method lambda?(node)
-        def_node_matcher :lambda?, <<-PATTERN
+        def_node_matcher :lambda?, <<~PATTERN
           {
             (send (const nil? :Proc) :new)
             (send nil? {:proc :lambda})
@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :lambda_subject?, '(block #lambda? ...)'
 
         # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
+        def_node_matcher :implicit_expect, <<~PATTERN
           $(send nil? {:is_expected :should :should_not} ...)
         PATTERN
 

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

@@ -31,7 +31,7 @@ module RuboCop
         RESTRICT_ON_SEND = Runners.all + %i[should should_not]
 
         # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
+        def_node_matcher :implicit_expect, <<~PATTERN
           {
             (send nil? ${:should :should_not} ...)
             (send (send nil? $:is_expected) #Runners.all ...)

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

@@ -78,12 +78,12 @@ module RuboCop
         ].freeze
 
         # @!method explicit_unnamed_subject?(node)
-        def_node_matcher :explicit_unnamed_subject?, <<-PATTERN
+        def_node_matcher :explicit_unnamed_subject?, <<~PATTERN
           (send nil? :expect (send nil? :subject))
         PATTERN
 
         # @!method implicit_subject?(node)
-        def_node_matcher :implicit_subject?, <<-PATTERN
+        def_node_matcher :implicit_subject?, <<~PATTERN
           (send nil? {:should :should_not :is_expected} ...)
         PATTERN
 

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

@@ -25,7 +25,7 @@ module RuboCop
               'with `have_received`.'
 
         # @!method null_double(node)
-        def_node_search :null_double, <<-PATTERN
+        def_node_search :null_double, <<~PATTERN
           (lvasgn $_
             (send
               $(send nil? :instance_double
@@ -33,7 +33,7 @@ module RuboCop
         PATTERN
 
         # @!method have_received_usage(node)
-        def_node_search :have_received_usage, <<-PATTERN
+        def_node_search :have_received_usage, <<~PATTERN
           (send
             (send nil? :expect
             (lvar $_)) :to

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

@@ -52,12 +52,12 @@ module RuboCop
               'a method call, or a local variable (if possible).'
 
         # @!method dynamic_class?(node)
-        def_node_matcher :dynamic_class?, <<-PATTERN
+        def_node_matcher :dynamic_class?, <<~PATTERN
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
 
         # @!method custom_matcher?(node)
-        def_node_matcher :custom_matcher?, <<-PATTERN
+        def_node_matcher :custom_matcher?, <<~PATTERN
           (block {
             (send nil? :matcher sym)
             (send (const (const nil? :RSpec) :Matchers) :define sym)

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `specify` with `is_expected` and one-liner expectations.
+      #
+      # @example
+      #   # bad
+      #   specify { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   specify do
+      #     # ...
+      #   end
+      #   specify { expect(sqrt(4)).to eq(2) }
+      #
+      class IsExpectedSpecify < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[specify].freeze
+        IS_EXPECTED_METHODS = ::Set[:is_expected, :are_expected].freeze
+        MSG = 'Use `it` instead of `specify`.'
+
+        # @!method offense?(node)
+        def_node_matcher :offense?, <<~PATTERN
+          (block (send _ :specify) _ (send (send _ IS_EXPECTED_METHODS) ...))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.single_line? && offense?(block_node)
+
+          selector = node.loc.selector
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
               'of iterating over an array.'
 
         # @!method each?(node)
-        def_node_matcher :each?, <<-PATTERN
+        def_node_matcher :each?, <<~PATTERN
           (block
             (send ... :each)
             (args (arg $_))
@@ -30,14 +30,14 @@ module RuboCop
         PATTERN
 
         # @!method each_numblock?(node)
-        def_node_matcher :each_numblock?, <<-PATTERN
+        def_node_matcher :each_numblock?, <<~PATTERN
           (numblock
             (send ... :each) _ $(...)
           )
         PATTERN
 
         # @!method expectation?(node)
-        def_node_matcher :expectation?, <<-PATTERN
+        def_node_matcher :expectation?, <<~PATTERN
           (send (send nil? :expect (lvar %)) :to ...)
         PATTERN
 

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

@@ -36,7 +36,7 @@ module RuboCop
         MSG = 'Move `let` before the examples in the group.'
 
         # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
             (block (send nil? {#ExampleGroups.all #Examples.all} ...) ...)
             (send nil? #Includes.examples ...)

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

@@ -37,7 +37,7 @@ module RuboCop
         PATTERN
 
         # @!method let_bang(node)
-        def_node_matcher :let_bang, <<-PATTERN
+        def_node_matcher :let_bang, <<~PATTERN
           {
             (block $(send nil? :let! {(sym $_) (str $_)}) ...)
             $(send nil? :let! {(sym $_) (str $_)} block_pass)

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

@@ -29,11 +29,10 @@ module RuboCop
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'
 
-        SUPPORTED_STYLES = %w[allow expect].freeze
         RESTRICT_ON_SEND = %i[to].freeze
 
         # @!method message_expectation(node)
-        def_node_matcher :message_expectation, <<-PATTERN
+        def_node_matcher :message_expectation, <<~PATTERN
           (send $(send nil? {:expect :allow} ...) :to #receive_message?)
         PATTERN
 

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

@@ -39,8 +39,6 @@ module RuboCop
                             'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
-        SUPPORTED_STYLES = %w[have_received receive].freeze
-
         RESTRICT_ON_SEND = Runners.all
 
         # @!method message_expectation(node)

data/lib/rubocop/cop/rspec/mixin/skip_or_pending.rb

@@ -8,7 +8,7 @@ module RuboCop
         extend RuboCop::NodePattern::Macros
 
         # @!method skipped_in_metadata?(node)
-        def_node_matcher :skipped_in_metadata?, <<-PATTERN
+        def_node_matcher :skipped_in_metadata?, <<~PATTERN
           {
             (send _ _ <(sym {:skip :pending}) ...>)
             (send _ _ ... (hash <(pair (sym {:skip :pending}) { true str dstr }) ...>))
@@ -30,7 +30,7 @@ module RuboCop
         #
         #   @param node [RuboCop::AST::Node]
         #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :skip_or_pending_inside_block?, <<-PATTERN
+        def_node_matcher :skip_or_pending_inside_block?, <<~PATTERN
           (block <(send nil? {:skip :pending} ...) ...>)
         PATTERN
       end

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

@@ -48,12 +48,17 @@ module RuboCop
       #     end
       #   end
       #
-      # @example configuration
-      #   # .rubocop.yml
-      #   # RSpec/MultipleExpectations:
-      #   #   Max: 2
+      # @example `Max: 1` (default)
+      #   # bad
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # not flagged by rubocop
+      # @example `Max: 2`
+      #   # good
       #   describe UserCreator do
       #     it 'builds a user' do
       #       expect(user.name).to eq("John")
@@ -70,7 +75,7 @@ module RuboCop
         TRUE = ->(node) { node.true_type? }
 
         # @!method aggregate_failures?(node)
-        def_node_matcher :aggregate_failures?, <<-PATTERN
+        def_node_matcher :aggregate_failures?, <<~PATTERN
           (block {
               (send _ _ <(sym :aggregate_failures) ...>)
               (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
@@ -81,7 +86,7 @@ module RuboCop
         def_node_matcher :expect?, '(send nil? #Expectations.all ...)'
 
         # @!method aggregate_failures_block?(node)
-        def_node_matcher :aggregate_failures_block?, <<-PATTERN
+        def_node_matcher :aggregate_failures_block?, <<~PATTERN
           (block (send nil? :aggregate_failures ...) ...)
         PATTERN
 

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

@@ -67,7 +67,7 @@ module RuboCop
         private
 
         def skipped?(node)
-          skippable?(node) && skipped_in_metadata?(node) ||
+          (skippable?(node) && skipped_in_metadata?(node)) ||
             skipped_regular_example_without_body?(node)
         end
 

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

@@ -103,7 +103,7 @@ module RuboCop
           on_pending_by_metadata(node)
           return unless (parent = parent_node(node))
 
-          if example_group?(parent) || block_node_example_group?(node)
+          if spec_group?(parent) || block_node_example_group?(node)
             on_skipped_by_example_method(node)
             on_skipped_by_example_group_method(node)
           elsif example?(parent)

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

@@ -26,7 +26,7 @@ module RuboCop
         end
 
         # @!method predicate_in_actual?(node)
-        def_node_matcher :predicate_in_actual?, <<-PATTERN
+        def_node_matcher :predicate_in_actual?, <<~PATTERN
           (send
             (send nil? :expect {
               (block $(send !nil? #predicate? ...) ...)
@@ -36,12 +36,12 @@ module RuboCop
         PATTERN
 
         # @!method be_bool?(node)
-        def_node_matcher :be_bool?, <<-PATTERN
+        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
+        def_node_matcher :be_boolthy?, <<~PATTERN
           (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
         PATTERN
 
@@ -179,7 +179,7 @@ module RuboCop
         end
 
         # @!method predicate_matcher?(node)
-        def_node_matcher :predicate_matcher?, <<-PATTERN
+        def_node_matcher :predicate_matcher?, <<~PATTERN
           (send
             (send nil? :expect $!nil?)
             #Runners.all
@@ -188,7 +188,7 @@ module RuboCop
         PATTERN
 
         # @!method predicate_matcher_block?(node)
-        def_node_matcher :predicate_matcher_block?, <<-PATTERN
+        def_node_matcher :predicate_matcher_block?, <<~PATTERN
           (block
             (send
               (send nil? :expect $!nil?)
@@ -202,7 +202,7 @@ module RuboCop
 
           return false if allowed_explicit_matchers.include?(name)
 
-          name.start_with?('be_', 'have_') && !name.end_with?('?') ||
+          (name.start_with?('be_', 'have_') && !name.end_with?('?')) ||
             %w[include respond_to].include?(name)
         end
 

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

@@ -23,7 +23,7 @@ module RuboCop
           MSG = 'Use `before` instead of `setup`.'
 
           # @!method setup_call(node)
-          def_node_matcher :setup_call, <<-PATTERN
+          def_node_matcher :setup_call, <<~PATTERN
             (block
               $(send nil? :setup)
               (args) _)

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

@@ -6,48 +6,72 @@ module RuboCop
       module Rails
         # Checks that tests use `have_http_status` instead of equality matchers.
         #
-        # @example
+        # @example ResponseMethods: ['response', 'last_response'] (default)
         #   # bad
         #   expect(response.status).to be(200)
-        #   expect(response.code).to eq("200")
+        #   expect(last_response.code).to eq("200")
         #
         #   # good
         #   expect(response).to have_http_status(200)
+        #   expect(last_response).to have_http_status(200)
+        #
+        # @example ResponseMethods: ['foo_response']
+        #   # bad
+        #   expect(foo_response.status).to be(200)
+        #
+        #   # good
+        #   expect(foo_response).to have_http_status(200)
+        #
+        #   # also good
+        #   expect(response).to have_http_status(200)
+        #   expect(last_response).to have_http_status(200)
         #
         class HaveHttpStatus < ::RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG =
-            'Prefer `expect(response).%<to>s have_http_status(%<status>s)` ' \
-            'over `%<bad_code>s`.'
+            'Prefer `expect(%<response>s).%<to>s ' \
+            'have_http_status(%<status>s)` over `%<bad_code>s`.'
 
           RUNNERS = %i[to to_not not_to].to_set
           RESTRICT_ON_SEND = RUNNERS
 
           # @!method match_status(node)
-          def_node_matcher :match_status, <<-PATTERN
+          def_node_matcher :match_status, <<~PATTERN
             (send
               (send nil? :expect
-                $(send (send nil? :response) {:status :code})
+                $(send $(send nil? #response_methods?) {:status :code})
               )
               $RUNNERS
               $(send nil? {:be :eq :eql :equal} ({int str} $_))
             )
           PATTERN
 
-          def on_send(node)
-            match_status(node) do |response_status, to, match, status|
+          def on_send(node) # rubocop:disable Metrics/MethodLength
+            match_status(node) do
+              |response_status, response_method, to, match, status|
               return unless status.to_s.match?(/\A\d+\z/)
 
-              message = format(MSG, to: to, status: status,
+              message = format(MSG, response: response_method.method_name,
+                                    to: to, status: status,
                                     bad_code: node.source)
               add_offense(node, message: message) do |corrector|
-                corrector.replace(response_status, 'response')
+                corrector.replace(response_status, response_method.method_name)
                 corrector.replace(match.loc.selector, 'have_http_status')
                 corrector.replace(match.first_argument, status.to_s)
               end
             end
           end
+
+          private
+
+          def response_methods?(name)
+            response_methods.include?(name.to_s)
+          end
+
+          def response_methods
+            cop_config.fetch('ResponseMethods', [])
+          end
         end
       end
     end

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

@@ -60,7 +60,7 @@ module RuboCop
           RESTRICT_ON_SEND = %i[have_http_status].freeze
 
           # @!method http_status(node)
-          def_node_matcher :http_status, <<-PATTERN
+          def_node_matcher :http_status, <<~PATTERN
             (send nil? :have_http_status ${int sym str})
           PATTERN