rubocop-dev_doc 0.7.0 → 0.9.0

data/lib/rubocop/cop/dev_doc/style/literal_or_in_when_clause.rb

@@ -0,0 +1,134 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag `||` / `&&` between literals inside a `when` clause. The operator
+        # evaluates immediately (`:a || :b` is just `:a`), so the other literal
+        # silently never matches — `when` alternatives must be comma-separated.
+        #
+        # ## Rationale
+        # `when :issuing_country || :nationality` reads like "either of these"
+        # but compiles to `when :issuing_country`; the `:nationality` branch is
+        # dead from day one and nothing at runtime ever hints at it. No core or
+        # rubocop-rails cop catches this shape. Restricted to literal operands
+        # the pattern is provably wrong, so the false-positive surface is
+        # effectively zero (`when SOME_CONST || fallback` and variable operands
+        # are left alone — unusual, but potentially intentional).
+        #
+        #   ❌ :nationality can never match
+        #   when :issuing_country || :nationality
+        #
+        #   ✔️ comma-separated alternatives
+        #   when :issuing_country, :nationality
+        #
+        # Autocorrect rewrites `||` chains to a comma list. It is marked unsafe
+        # because it deliberately changes behavior: the dead alternative starts
+        # matching, which is the fix — but any code relying on the buggy
+        # behavior must be re-verified. Chains containing `nil`/`false` and all
+        # `&&` forms are flagged without autocorrect (the intent is ambiguous).
+        #
+        # @example
+        #   # bad
+        #   case topic
+        #   when :billing || :payments
+        #     route_to_finance
+        #   end
+        #
+        #   # good
+        #   case topic
+        #   when :billing, :payments
+        #     route_to_finance
+        #   end
+        class LiteralOrInWhenClause < Base
+          extend AutoCorrector
+
+          MSG = '`%<source>s` evaluates immediately to `%<result>s`, so the other ' \
+                'literal(s) in it can never match this `when` clause. List ' \
+                'alternatives with commas instead: `when %<list>s`.'.freeze
+
+          LITERAL_TYPES = %i[sym str int float true false nil].freeze
+          FALSY_TYPES = %i[false nil].freeze
+
+          def on_case(node)
+            node.when_branches.each do |branch|
+              branch.conditions.each { |condition| check(condition) }
+            end
+          end
+
+          private
+
+          def check(condition)
+            inner = unwrap_begin(condition)
+            return unless inner.or_type? || inner.and_type?
+
+            leaves = flatten_chain(inner, inner.type)
+            return unless leaves.all? { |leaf| LITERAL_TYPES.include?(leaf.type) }
+
+            add_offense(inner, message: offense_message(inner, leaves)) do |corrector|
+              next unless autocorrectable_chain?(inner, leaves)
+
+              corrector.replace(rewrite_range(condition), comma_list(leaves))
+            end
+          end
+
+          # Parentheses wrap a condition in a `begin` node; unwrap it for
+          # inspection while keeping the outer node for the autocorrect range.
+          def unwrap_begin(node)
+            node = node.children.first while node.begin_type?
+            node
+          end
+
+          # Replace the full condition including wrapping parentheses, so
+          # `when (:a || :b)` becomes `when :a, :b` rather than `when (:a, :b)`.
+          def rewrite_range(condition)
+            return condition unless condition.begin_type? && condition.loc.begin
+
+            condition.loc.begin.join(condition.loc.end)
+          end
+
+          def offense_message(condition, leaves)
+            format(
+              MSG,
+              source: condition.source,
+              result: fold(leaves, condition.type).source,
+              list: comma_list(leaves)
+            )
+          end
+
+          def comma_list(leaves)
+            leaves.map(&:source).join(', ')
+          end
+
+          # Flatten a homogeneous `||` (or `&&`) chain into its operand nodes.
+          # A mixed-operator chain yields operand nodes of differing types,
+          # which the caller's literal-type check then filters out. An operand
+          # wrapped in parentheses arrives as a `begin` node
+          # (`(:a || :b) || :c`), so unwrap before recursing; otherwise the
+          # inner chain reads as a single non-literal leaf and evades the check.
+          def flatten_chain(node, operator)
+            node = unwrap_begin(node)
+            return [node] unless node.type == operator
+
+            flatten_chain(node.lhs, operator) + flatten_chain(node.rhs, operator)
+          end
+
+          # The single literal the operator chain folds to.
+          def fold(leaves, operator)
+            if operator == :or
+              leaves.find { |leaf| !FALSY_TYPES.include?(leaf.type) } || leaves.last
+            else
+              leaves.find { |leaf| FALSY_TYPES.include?(leaf.type) } || leaves.last
+            end
+          end
+
+          # Only rewrite `||` chains of truthy literals: there the comma list is
+          # unambiguously what was meant. `nil`/`false` operands and `&&` forms
+          # have no clear when-clause intent, so they are flagged only.
+          def autocorrectable_chain?(condition, leaves)
+            condition.or_type? && leaves.none? { |leaf| FALSY_TYPES.include?(leaf.type) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/style/no_unscoped_method_definitions.rb

@@ -74,7 +74,9 @@ module RuboCop
                 'or inside a DSL block (e.g. Rake `namespace`). ' \
                 'Methods defined here land on `Object` and can silently collide across files.'.freeze
 
-          DEFAULT_SAFE_DSL_RECEIVERS = %w[Struct Class Module].freeze
+          # Data (Ruby 3.2 value objects) scopes block-defined methods to the
+          # new class exactly like Struct.
+          DEFAULT_SAFE_DSL_RECEIVERS = %w[Struct Data Class Module].freeze
 
           def on_def(node)
             add_offense(node.loc.keyword) unless enclosed_in_class_or_module?(node)

data/lib/rubocop/cop/dev_doc/style/prefer_public_send.rb

@@ -21,16 +21,16 @@ module RuboCop
         #   meant a public-API call. `send` leaves it ambiguous whether
         #   private access was wanted.
         #
-        # ## Relationship to AvoidSend
-        # `DevDoc/Style/AvoidSend` flags *dynamic* dispatch (both `send` and
+        # ## Relationship to AvoidInsecureSend
+        # `DevDoc/Style/AvoidInsecureSend` flags *dynamic* dispatch (both `send` and
         # `public_send`) as risky. This cop is orthogonal: it flags `send`
-        # specifically, including the cases AvoidSend exempts (literal-symbol
+        # specifically, including the cases AvoidInsecureSend exempts (literal-symbol
         # args, prefix-string args). The friction asymmetry is intentional —
         # `send` is the deeper exception, so it costs an extra disable:
         #
-        #   obj.public_send(method_name)        # AvoidSend: 1 disable
+        #   obj.public_send(method_name)        # AvoidInsecureSend: 1 disable
         #   obj.public_send(:foo)               # clean
-        #   obj.send(method_name)               # AvoidSend + this cop: 2 disables
+        #   obj.send(method_name)               # AvoidInsecureSend + this cop: 2 disables
         #   obj.send(:foo)                      # this cop only: 1 disable
         #
         # ## When `send` IS the right choice
@@ -67,17 +67,19 @@ module RuboCop
         #   # good — receiver-less send (calling self's own method)
         #   send(:internal_helper)
         class PreferPublicSend < Base
-          MSG = 'Prefer `public_send` over `send` — it respects method ' \
+          MSG = 'Prefer `public_send` over `%<method>s` — it respects method ' \
                 'visibility, surfacing typos/misconfig that would otherwise ' \
                 'silently invoke a private method. Disable with a reason ' \
                 'when bypassing visibility is intentional.'.freeze
 
-          RESTRICT_ON_SEND = %i[send].freeze
+          # `__send__` is the canonical alias — omitting it would leave a
+          # zero-cost visibility bypass that dodges this cop entirely.
+          RESTRICT_ON_SEND = %i[send __send__].freeze
 
           def on_send(node)
             return if node.receiver.nil?
 
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/style/redundant_guard_after_bang.rb

@@ -0,0 +1,155 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Style
+        # Flag a nil/presence guard on a variable that was just assigned from a
+        # bang method. Bang methods raise on failure instead of returning
+        # nil/false, so the guard can never fire — it is dead code that hides
+        # the real contract and invites style churn (e.g. `Rails/Presence`
+        # "fixing" the guard's shape instead of questioning its existence).
+        #
+        # ## Rationale
+        # By convention a `!` method signals failure by raising (`create!`,
+        # `save!`, `find_by!`, custom `do_thing!`). Guarding its result reads
+        # as if nil were possible, which misleads reviewers about the failure
+        # mode and preserves defensive noise through refactors. The fix is to
+        # delete the guard, not to restyle it.
+        #
+        # Ruby-core mutator bangs (`gsub!`, `uniq!`, `compact!`, ...) are the
+        # exception — they return nil when nothing changed, so guarding them is
+        # legitimate. Those are excluded via the default `AllowedMethods`; add
+        # any app-specific nil-returning bang there too (or better, rename it,
+        # since a nil-returning `!` method is itself misleading).
+        #
+        # Caveat on `present?`/`blank?`: for a bang that returns a possibly-empty
+        # collection or string, a `present?` check is emptiness logic rather than
+        # a nil-guard, and is NOT dead — the cop cannot distinguish this
+        # statically, so such methods also belong in `AllowedMethods`. Plain
+        # truthiness (`if x`), `nil?`, and `&.` guards carry no such ambiguity:
+        # `[]` and `""` are truthy, so those forms only ever test for nil.
+        #
+        #   ❌ dead guard — create! raises rather than return nil
+        #   snapshot = create_snapshot!(**attrs)
+        #   if snapshot.present?
+        #     snapshot.update_columns(version: version)
+        #   end
+        #
+        #   ✔️ no guard — the bang contract is the guard
+        #   snapshot = create_snapshot!(**attrs)
+        #   snapshot.update_columns(version: version)
+        #
+        #   ✔️ core mutator bang — nil means "no change", guard is real logic
+        #   cleaned = name.strip!
+        #   apply(cleaned) if cleaned
+        #
+        # @example
+        #   # bad
+        #   record = Order.create!(params)
+        #   record&.notify_owner
+        #
+        #   # good
+        #   record = Order.create!(params)
+        #   record.notify_owner
+        class RedundantGuardAfterBang < Base
+          MSG = '`%<method>s` raises on failure instead of returning nil, ' \
+                'so this guard on `%<var>s` is dead; remove it.'.freeze
+
+          # Value assigned from a plain (non-safe-navigation) send, with or
+          # without a block (named or numbered params). `obj&.create!` is
+          # deliberately not matched: a nil receiver nils the whole expression,
+          # making a guard legitimate.
+          def_node_matcher :bang_call, <<~PATTERN
+            {
+              (send _ $_ ...)
+              (block (send _ $_ ...) ...)
+              (numblock (send _ $_ ...) ...)
+            }
+          PATTERN
+
+          def_node_matcher :truthiness_condition?, <<~PATTERN
+            {
+              ({lvar ivar} %1)
+              (send ({lvar ivar} %1) {:present? :nil? :blank?})
+              (send (send ({lvar ivar} %1) :nil?) :!)
+            }
+          PATTERN
+
+          def_node_matcher :safe_navigation_on_var?, <<~PATTERN
+            {
+              (csend ({lvar ivar} %1) ...)
+              (csend (send ({lvar ivar} %1) :presence) ...)
+            }
+          PATTERN
+
+          def on_lvasgn(node)
+            # `a ||= x` wraps a value-less lvasgn in an or_asgn; nothing to check.
+            return unless node.expression
+
+            method_name = bang_call(node.expression)
+            return unless bang_method?(method_name)
+            return if allowed_method?(method_name)
+
+            following = next_sibling(node)
+            return unless following
+
+            guard = guard_node(following, node.name)
+            return unless guard
+
+            add_offense(guard, message: format(MSG, method: method_name, var: node.name))
+          end
+          alias on_ivasgn on_lvasgn
+
+          private
+
+          # Only the statement immediately after the assignment is considered:
+          # once other code intervenes, the variable may have been reassigned
+          # and the deadness is no longer provable.
+          def next_sibling(node)
+            parent = node.parent
+            return nil unless parent&.begin_type?
+
+            parent.children[node.sibling_index + 1]
+          end
+
+          def guard_node(stmt, var)
+            return stmt.condition if stmt.if_type? && guard_condition?(stmt.condition, var)
+            return stmt if safe_navigation_on_var?(stmt, var)
+
+            embedded_safe_navigation(stmt, var)
+          end
+
+          # A dead guard can sit in the condition itself, not only as the
+          # whole statement: `if record&.persisted?` is the same dead `&.` as
+          # a standalone `record&.foo` (the bang never returned nil).
+          def guard_condition?(condition, var)
+            truthiness_condition?(condition, var) || safe_navigation_on_var?(condition, var)
+          end
+
+          # y = x&.foo — the guard is embedded in another assignment's value.
+          def embedded_safe_navigation(stmt, var)
+            return nil unless stmt.respond_to?(:expression)
+
+            value = stmt.expression
+            return nil unless value.is_a?(RuboCop::AST::Node)
+
+            value if safe_navigation_on_var?(value, var)
+          end
+
+          def allowed_method?(method_name)
+            cop_config.fetch('AllowedMethods', []).include?(method_name.to_s)
+          end
+
+          # A trailing `!` signals raise-on-failure by convention. The unary
+          # negation operator parses as method `:!`, which also ends in `!` but
+          # is not a bang method, so it is excluded.
+          def bang_method?(method_name)
+            return false unless method_name
+
+            name = method_name.to_s
+            name.end_with?('!') && name != '!'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/test/avoid_glib_travel_freeze.rb

@@ -36,15 +36,18 @@ module RuboCop
         #     expect(order.expired?).to be true
         #   end
         class AvoidGlibTravelFreeze < Base
-          MSG = 'Avoid `glib_travel_freeze` — use `glib_travel` instead. ' \
+          MSG = 'Avoid `%<method>s` — use `glib_travel` instead. ' \
                 'Frozen time masks timing bugs that surface in production. ' \
                 'Use `# rubocop:disable DevDoc/Test/AvoidGlibTravelFreeze` ' \
-                'with a comment explaining why `glib_travel` cannot work for this test.'
+                'with a comment explaining why `glib_travel` cannot work for this test.'.freeze
 
-          RESTRICT_ON_SEND = %i[glib_travel_freeze].freeze
+          # The native ActiveSupport helpers freeze the clock exactly the same
+          # way — policing only the glib spelling would ban one name for
+          # frozen time while leaving the ones agents know from training data.
+          RESTRICT_ON_SEND = %i[glib_travel_freeze freeze_time travel_to travel].freeze
 
           def on_send(node)
-            add_offense(node.loc.selector)
+            add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
           end
         end
       end

data/lib/rubocop/cop/dev_doc/test/avoid_unit_test.rb

@@ -44,15 +44,25 @@ module RuboCop
         #     model's own": you usually don't need to — assert the *observable*
         #     guarantee through the real path; that is what matters in production.
         #
-        # When a unit test is genuinely necessary, suppress with a reason that
-        # explains why a controller test can't cover the path. That reason IS the
-        # required justification — keep it specific and reviewable:
+        # When a unit test is genuinely necessary, do NOT disable this cop —
+        # use the sanctioned form instead: subclass `Glib::LastResortUnitTest`
+        # (the name is the policy), place the file in a unit-test directory
+        # (test/models|services|helpers/), and open it with a justification
+        # header containing the marker phrase "deliberate exception" that
+        # explains why no controller path can reach the behaviour. That form is
+        # machine-enforced by DevDoc/Test/RequireUnitTestJustification and
+        # never trips this cop, so a properly justified unit test carries zero
+        # disable directives:
         #
-        #   # rubocop:disable DevDoc/Test/AvoidUnitTest -- search ranking isn't visible through the controller
-        #   class Ai::Retrieval::PgSearchStrategyTest < ActiveSupport::TestCase
+        #   # Per best practice, we focus on controller tests. This model test
+        #   # is a deliberate exception: <why no controller path exists>.
+        #   class MemberTest < Glib::LastResortUnitTest
         #     # ...
         #   end
-        #   # rubocop:enable DevDoc/Test/AvoidUnitTest
+        #
+        # Legacy `< ActiveSupport::TestCase` tests that predate the sanctioned
+        # form survive via project-config Excludes until migrated; new code has
+        # no reason to add one.
         #
         # NOTE: The cop matches the *direct* superclass only. A project base
         # (`class ApplicationServiceTest < ActiveSupport::TestCase`) is flagged
@@ -64,17 +74,20 @@ module RuboCop
         #   end
         #
         #   # good — exercised through the controller
-        #   class NotesControllerTest < ActionDispatch::IntegrationTest
+        #   class NotesControllerTest < Glib::IntegrationTest
         #   end
         #
-        #   # good — genuinely unit-only, justified with a reason
-        #   # rubocop:disable DevDoc/Test/AvoidUnitTest -- <why a controller test can't cover this>
-        #   class SomeServiceTest < ActiveSupport::TestCase
+        #   # good — genuinely unit-only: sanctioned base + unit directory +
+        #   # justification header (enforced by RequireUnitTestJustification)
+        #   # Per best practice, we focus on controller tests. This test is a
+        #   # deliberate exception: <why a controller test can't cover this>.
+        #   class SomeServiceTest < Glib::LastResortUnitTest
         #   end
-        #   # rubocop:enable DevDoc/Test/AvoidUnitTest
         class AvoidUnitTest < Base
           MSG = 'Prefer a controller test — unit tests are a rare exception. If a controller test ' \
-                'genuinely cannot cover this path, disable this cop on the class with a reason.'.freeze
+                'genuinely cannot cover this path, use `Glib::LastResortUnitTest` in a unit-test ' \
+                'directory with a justification header (see ' \
+                'DevDoc/Test/RequireUnitTestJustification); do not disable this cop.'.freeze
 
           def on_class(node)
             superclass = node.parent_class

data/lib/rubocop/cop/dev_doc/test/require_glib_integration_base.rb

@@ -0,0 +1,57 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # In HTTP-driven test directories, integration tests must subclass the
+        # project base (`RequiredBase`, default `Glib::IntegrationTest`) rather
+        # than a raw framework base (`LegacyBases`, default
+        # `ActionDispatch::IntegrationTest`).
+        #
+        # ## Rationale
+        # The project base is where behavioural enforcement and plumbing are
+        # attached: DevDoc::Test::Lints::HttpDrivenControllerTests (which fails
+        # any test under test/controllers/ that completes without making an
+        # HTTP request), plus the glib helpers (submit_form, glib_travel,
+        # parallel coverage). A test that inherits the framework base directly
+        # sidesteps all of it — and that is an observed evasion shape: when the
+        # runtime lint fails a disguised unit test, switching the superclass to
+        # the raw framework base would silence the lint without fixing the
+        # test. This cop closes that hop statically, completing the loop with
+        # DevDoc/Test/RequireUnitTestJustification (which forbids unit bases in
+        # these directories and integration bases in unit directories).
+        #
+        # Framework-specific bases for other test types
+        # (`ActionMailer::TestCase`, `ActionCable::Connection::TestCase`, ...)
+        # are not flagged — only the configured legacy integration bases.
+        #
+        # @example
+        #   # bad
+        #   class NotesControllerTest < ActionDispatch::IntegrationTest
+        #   end
+        #
+        #   # good
+        #   class NotesControllerTest < Glib::IntegrationTest
+        #   end
+        class RequireGlibIntegrationBase < Base
+          MSG = '`%<base>s` is the raw framework base — subclass `%<required>s` instead. The project ' \
+                'base carries the runtime HTTP-driven enforcement and the glib test plumbing; ' \
+                'inheriting the framework base directly sidesteps both.'.freeze
+
+          def on_class(node)
+            superclass = node.parent_class
+            return unless superclass&.const_type?
+            return unless legacy_bases.include?(superclass.const_name)
+
+            add_offense(superclass, message: format(MSG, base: superclass.const_name, required: required_base))
+          end
+
+          private
+
+          def legacy_bases = cop_config.fetch('LegacyBases', %w[ActionDispatch::IntegrationTest])
+
+          def required_base = cop_config.fetch('RequiredBase', 'Glib::IntegrationTest')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dev_doc/test/require_glib_travel.rb

@@ -0,0 +1,119 @@
+module RuboCop
+  module Cop
+    module DevDoc
+      module Test
+        # Controller tests must run inside a `glib_travel` block.
+        #
+        # ## Rationale
+        # Per the testing best practice ("Time Travel"), tests should always run
+        # inside a `glib_travel` block — even when they do not appear
+        # time-sensitive. Controller tests integrate HTTP, the database, and the
+        # clock (timestamps, expiry windows, token validity, rate limits), so they
+        # are the highest-leverage place to enforce it. A controller test that
+        # does not freeze time passes today and flakes or regresses the moment an
+        # ordering, expiry, or TTL boundary shifts under it.
+        #
+        # The block form auto-returns to real time at the end of the test, so no
+        # teardown is needed:
+        #
+        #   test 'shows the row' do
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #       assert_response :success
+        #     end
+        #   end
+        #
+        # This cop is a *presence* check — it only asks "did you freeze time?".
+        # Whether you used the block form (vs. the leak-prone bare anchor) is
+        # enforced separately by `DevDoc/Test/RequireGlibTravelBlock`, and
+        # `glib_travel_freeze` vs. `glib_travel` by `AvoidGlibTravelFreeze`.
+        #
+        # ## What is NOT flagged
+        # - Tests that already call `glib_travel` or `glib_travel_freeze`.
+        # - Non-controller test files — the cop is scoped to
+        #   `test/controllers/**` via `Include`, where the time-sensitivity risk
+        #   is highest. (The best practice recommends the block form for every
+        #   test; this cop enforces the subset with the strongest evidence.)
+        #
+        # ## Inline disable
+        # For the rare controller test that is genuinely time-independent and the
+        # block adds noise, add a `rubocop:disable DevDoc/Test/RequireGlibTravel`
+        # comment to the test's opening line (`test '...' do` or `def test_*`)
+        # with a written reason.
+        #
+        # @example
+        #   # bad
+        #   test 'shows the row' do
+        #     get items_url(format: :json)
+        #     assert_response :success
+        #   end
+        #
+        #   # good
+        #   test 'shows the row' do
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #       assert_response :success
+        #     end
+        #   end
+        #
+        #   # good (method-style test — also covered)
+        #   def test_shows_the_row
+        #     glib_travel(FROZEN_TIME) do
+        #       get items_url(format: :json)
+        #     end
+        #   end
+        class RequireGlibTravel < Base
+          MSG = 'Wrap this test in a `glib_travel` block — controller tests integrate ' \
+                'HTTP, DB, and time, so the frozen time must be deterministic. See the ' \
+                'testing best practice ("Time Travel"). Disable with a written reason ' \
+                'only if the test is genuinely time-independent.'.freeze
+
+          # @!method test_block?(node)
+          def_node_matcher :test_block?, <<~PATTERN
+            (block (send nil? :test ...) _args _body)
+          PATTERN
+
+          # Any glib time helper satisfies the presence check. `glib_travel_freeze`
+          # counts as "froze time" here — its form is policed by
+          # AvoidGlibTravelFreeze, not by this cop.
+          # @!method calls_glib_time_helper?(node)
+          def_node_search :calls_glib_time_helper?, <<~PATTERN
+            (send nil? {:glib_travel :glib_travel_freeze} ...)
+          PATTERN
+
+          def on_block(node)
+            return unless test_block?(node)
+
+            check_test(node, node.send_node.loc.selector)
+          end
+
+          # Minitest also allows method-style tests (`def test_shows_the_row`);
+          # those are the same kind of controller test and must freeze time too.
+          def on_def(node)
+            return unless test_method?(node)
+
+            check_test(node, node.loc.name)
+          end
+
+          private
+
+          # Shared by the block form (`test '...' do`) and the method form
+          # (`def test_*`): a test with a body that never freezes time.
+          def check_test(node, location)
+            return unless node.body
+            return if calls_glib_time_helper?(node)
+
+            add_offense(location)
+          end
+
+          # Minitest treats any `def test_*` method as a test. Node patterns
+          # match exact method names rather than a prefix, so this is a plain
+          # Ruby string check. (`def test` — no underscore — is not a test.)
+          def test_method?(node)
+            node.method_name.to_s.start_with?('test_')
+          end
+        end
+      end
+    end
+  end
+end