Add new RSpec/ChangeWithoutExpect cop

Follow up: #2071

Author: ydah

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Fix issue when `Style/ContextWording` is configured with a Prefix being interpreted as a boolean, like `on`. ([@sakuro])
 - Add new `RSpec/IncludeExamples` cop to enforce using `it_behaves_like` over `include_examples`. ([@dvandersluis])
 - Change `RSpec/ScatteredSetup` to allow `around` hooks to be scattered. ([@ydah])
+- Add new `RSpec/ChangeWithoutExpect` cop. ([@ydah])
 
 ## 3.5.0 (2025-02-16)
 

config/default.yml

@@ -199,6 +199,12 @@ RSpec/ChangeByZero:
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeByZero
   NegatedMatcher: ~
 
+RSpec/ChangeWithoutExpect:
+  Description: Checks for `change` matcher usage without an `expect` block.
+  Enabled: pending
+  VersionAdded: "<<next>>"
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeWithoutExpect
+
 RSpec/ClassCheck:
   Description: Enforces consistent use of `be_a` or `be_kind_of`.
   StyleGuide: "#is-a-vs-kind-of"

lib/rubocop/cop/rspec/change_without_expect.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `change` matcher usage without an `expect` block.
+      #
+      # This cop only considered a matcher if it is chained with
+      # `from`, `by`, `by_at_least`, or `by_at_most`.
+      #
+      # @example
+      #   # bad
+      #   it 'changes the count' do
+      #     change(Counter, :count).by(1)
+      #   end
+      #
+      #   # bad
+      #   it 'changes the count' do
+      #     change(Counter, :count).by_at_least(1)
+      #   end
+      #
+      #   # bad
+      #   it 'changes the count' do
+      #     change(Counter, :count).by_at_most(1)
+      #   end
+      #
+      #   # bad
+      #   it 'changes the count' do
+      #     change(Counter, :count).from(0)
+      #   end
+      #
+      #   # bad
+      #   it 'changes the count' do
+      #     change(Counter, :count).from(0).to(1)
+      #   end
+      #
+      #   # good - no chained matchers
+      #   it 'changes the count' do
+      #     change(Counter, :count)
+      #   end
+      #
+      #   # good - ignore not change matcher
+      #   it 'changes the count' do
+      #     change(Counter, :count).from(0).by(1)
+      #   end
+      #
+      #   # good - within expect block
+      #   it 'changes the count' do
+      #     expect { subject }.to change(Counter, :count).by(1)
+      #   end
+      #
+      class ChangeWithoutExpect < RuboCop::Cop::Base
+        include RangeHelp
+
+        MSG = 'Use `change` matcher within an `expect` block.'
+        RESTRICT_ON_SEND = [:change].freeze
+        SINGLE_RESTRICTED_METHODS = %i[by by_at_least by_at_most from].freeze
+
+        # @!method expectation?(node)
+        def_node_search :expectation?, <<~PATTERN
+          (send
+            {
+              (block (send nil? :expect ...) ...)
+              (send nil? :expect ...)
+            }
+            {:to :not_to}
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return if within_expectation?(node)
+          return unless offensive_chain?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def offensive_chain?(node)
+          chain_methods = chain_methods(node)
+          return false if chain_methods.empty?
+
+          # Case 1: single restricted method (by, by_at_least, by_at_most, from)
+          if chain_methods.size == 1 &&
+              SINGLE_RESTRICTED_METHODS.include?(chain_methods.first)
+            return true
+          end
+
+          # Case 2: exactly from().to() pattern
+          if chain_methods.size == 2 &&
+              chain_methods.first == :from &&
+              chain_methods.last == :to
+            return true
+          end
+
+          false
+        end
+
+        def chain_methods(node)
+          methods = []
+          chain = node
+
+          while chain.send_type? && chain.parent&.send_type?
+            chain = chain.parent
+            methods << chain.method_name
+          end
+
+          methods
+        end
+
+        def within_expectation?(node)
+          node.each_ancestor(:send).any? do |ancestor|
+            expectation?(ancestor)
+          end
+        end
+      end
+    end
+  end
+end

lib/rubocop/cop/rspec_cops.rb

@@ -11,6 +11,7 @@
 require_relative 'rspec/be_nil'
 require_relative 'rspec/before_after_all'
 require_relative 'rspec/change_by_zero'
+require_relative 'rspec/change_without_expect'
 require_relative 'rspec/class_check'
 require_relative 'rspec/contain_exactly'
 require_relative 'rspec/context_method'

spec/rubocop/cop/rspec/change_without_expect_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ChangeWithoutExpect, :config do
+  it 'registers an offense for a `change` call with only `by` ' \
+     'without an `expect` block' do
+    expect_offense(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).by(1)
+        ^^^^^^^^^^^^^^^^^^^^^^^ Use `change` matcher within an `expect` block.
+      end
+    RUBY
+  end
+
+  it 'registers an offense for a `change` call with only `by_at_least` ' \
+     'without an `expect` block' do
+    expect_offense(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).by_at_least(1)
+        ^^^^^^^^^^^^^^^^^^^^^^^ Use `change` matcher within an `expect` block.
+      end
+    RUBY
+  end
+
+  it 'registers an offense for a `change` call with only `by_at_most` ' \
+     'without an `expect` block' do
+    expect_offense(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).by_at_most(1)
+        ^^^^^^^^^^^^^^^^^^^^^^^ Use `change` matcher within an `expect` block.
+      end
+    RUBY
+  end
+
+  it 'registers an offense for a `change` call with only `from` ' \
+     'without an `expect` block' do
+    expect_offense(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).from(0)
+        ^^^^^^^^^^^^^^^^^^^^^^^ Use `change` matcher within an `expect` block.
+      end
+    RUBY
+  end
+
+  it 'registers an offense for a `change` call with exactly `from().to()` ' \
+     'without an `expect` block' do
+    expect_offense(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).from(0).to(1)
+        ^^^^^^^^^^^^^^^^^^^^^^^ Use `change` matcher within an `expect` block.
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a `change` call with `from().by()` ' \
+     'without an `expect` block' do
+    expect_no_offenses(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).from(0).by(1)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a simple `change` call ' \
+     'without chains' do
+    expect_no_offenses(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a `change` call with unsupported ' \
+     'chain method' do
+    expect_no_offenses(<<~RUBY)
+      it 'changes the count' do
+        change(Counter, :count).some_other_method(123)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for `change` with chains within an ' \
+     '`expect` block' do
+    expect_no_offenses(<<~RUBY)
+      it 'changes the count' do
+        expect { subject }.to change(Counter, :count).by(1)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for `change` with from-to chain ' \
+     'within an `expect` block' do
+    expect_no_offenses(<<~RUBY)
+      it 'changes the count' do
+        expect { subject }.to change(Counter, :count).from(0).to(1)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for `change` with chains ' \
+     'within an `expect` with not_to' do
+    expect_no_offenses(<<~RUBY)
+      it 'does not change the count' do
+        expect { subject }.not_to change(Counter, :count).by(1)
+      end
+    RUBY
+  end
+end