rubocop-minitest 0.22.2 → 0.32.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a90bf7594f331c351450d9cd2012ab3c7378e72c24fad69c79a052983d2ea8
-  data.tar.gz: 9cbdab3ceafeddbe54fba39ea451c5347489dae3066f36208635b7aea2abcd7e
+  metadata.gz: ce290f7a13faed25c00a17d9daf8bcaf17e187599a075323fc99f8494c29c2bb
+  data.tar.gz: 9def860d52f65aed4e8923bcf2fd851a5188485986c7ad5bce44a9dc0d79b2d3
 SHA512:
-  metadata.gz: 8b0d79ca4c4de8521c71b8752bc759f346efd898e7538acf1e424b7f3920ca291a9e85b7017eeae7a251313643c5bd0a4abcfaa042e14ac1c592ca8c9e3dde47
-  data.tar.gz: 838aa30294ec6f330a90dd500bbdce42febf70fa40e0e9b32490a9ffd7d663634e343a8cc321a7aa1e46a417373e26cb89f85d1d551a1b8ec2c4b1ffb1375542
+  metadata.gz: 8db20fcf7d8e58b564da63b85f6692c4a2be189ffeacdc654f4b18ea689416688442df945606c84f55e63b9007c8df51b4f173004a7ae145603733f6bac62c61
+  data.tar.gz: 41232dfbabd012e4edbe1e78b49f1846004246950773a6f06c50fff358cb71a79fbdcd95ed0657690387801331093606c2dabb376788368cf51438ff84846be4

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-2022 Bozhidar Batsov, Jonas Arvidsson, Koichi ITO
+Copyright (c) 2019-2023 Bozhidar Batsov, Jonas Arvidsson, Koichi ITO
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -3,15 +3,15 @@
 [![Gem Version](https://badge.fury.io/rb/rubocop-minitest.svg)](https://badge.fury.io/rb/rubocop-minitest)
 [![CircleCI](https://circleci.com/gh/rubocop/rubocop-minitest.svg?style=svg)](https://circleci.com/gh/rubocop/rubocop-minitest)
 
-A [RuboCop](https://github.com/rubocop/rubocop) extension focused on enforcing Minitest best practices and coding conventions.
+A [RuboCop](https://github.com/rubocop/rubocop) extension focused on enforcing [Minitest](https://github.com/minitest/minitest) best practices and coding conventions.
 The library is based on the guidelines outlined in the community [Minitest Style Guide](https://minitest.rubystyle.guide).
 
 ## Installation
 
 Just install the `rubocop-minitest` gem
 
-```bash
-gem install rubocop-minitest
+```sh
+$ gem install rubocop-minitest
 ```
 
 or if you use bundler put this in your `Gemfile`
@@ -46,8 +46,8 @@ cops together with the standard cops.
 
 ### Command line
 
-```bash
-rubocop --require rubocop-minitest
+```sh
+$ rubocop --require rubocop-minitest
 ```
 
 ### Rake task

data/config/default.yml

@@ -59,6 +59,12 @@ Minitest/AssertNil:
   Enabled: true
   VersionAdded: '0.1'
 
+Minitest/AssertOperator:
+  Description: 'This cop enforces the use of `assert_operator(expected, :<, actual)` over `assert(expected < actual)`.'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-operator'
+  Enabled: pending
+  VersionAdded: '0.32'
+
 Minitest/AssertOutput:
   Description: 'This cop checks for opportunities to use `assert_output`.'
   StyleGuide: 'https://minitest.rubystyle.guide/#assert-output'
@@ -85,7 +91,9 @@ Minitest/AssertRaisesCompoundBody:
 Minitest/AssertRaisesWithRegexpArgument:
   Description: 'This cop enforces checks for regular expression literals passed to `assert_raises`.'
   Enabled: pending
+  Severity: warning
   VersionAdded: '0.22'
+  VersionChanged: '0.26'
 
 Minitest/AssertRespondTo:
   Description: 'This cop enforces the test to use `assert_respond_to(object, :do_something)` over `assert(object.respond_to?(:do_something))`.'
@@ -93,6 +101,12 @@ Minitest/AssertRespondTo:
   Enabled: true
   VersionAdded: '0.3'
 
+Minitest/AssertSame:
+  Description: 'Enforces the use of `assert_same(expected, actual)` over `assert(expected.equal?(actual))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide#assert-same'
+  Enabled: pending
+  VersionAdded: '0.26'
+
 Minitest/AssertSilent:
   Description: "This cop enforces the test to use `assert_silent { ... }` instead of using `assert_output('', '') { ... }`."
   StyleGuide: 'https://github.com/rubocop/minitest-style-guide#assert-silent'
@@ -103,13 +117,17 @@ Minitest/AssertTruthy:
   Description: 'This cop enforces the test to use `assert(actual)` instead of using `assert_equal(true, actual)`.'
   StyleGuide: 'https://minitest.rubystyle.guide#assert-truthy'
   Enabled: true
+  Safe: false
   VersionAdded: '0.2'
+  VersionChanged: '0.27'
 
 Minitest/AssertWithExpectedArgument:
   Description: 'This cop tries to detect when a user accidentally used `assert` when they meant to use `assert_equal`.'
   Enabled: pending
+  Severity: warning
   Safe: false
   VersionAdded: '0.11'
+  VersionChanged: '0.26'
 
 Minitest/AssertionInLifecycleHook:
   Description: 'This cop checks for usage of assertions in lifecycle hooks.'
@@ -122,10 +140,16 @@ Minitest/DuplicateTestRun:
   Enabled: pending
   VersionAdded: '0.19'
 
+Minitest/EmptyLineBeforeAssertionMethods:
+  Description: 'Add empty line before assertion methods.'
+  Enabled: pending
+  VersionAdded: '0.23'
+
 Minitest/GlobalExpectations:
   Description: 'This cop checks for deprecated global expectations.'
   StyleGuide: 'https://minitest.rubystyle.guide#global-expectations'
   Enabled: true
+  Severity: warning
   EnforcedStyle: any
   Include:
     - '**/test/**/*'
@@ -138,7 +162,13 @@ Minitest/GlobalExpectations:
     - expect
     - value
   VersionAdded: '0.7'
-  VersionChanged: '0.16'
+  VersionChanged: '0.26'
+
+Minitest/LifecycleHooksOrder:
+  Description: 'Checks that lifecycle hooks are declared in the order in which they will be executed.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#hooks-ordering'
+  Enabled: pending
+  VersionAdded: '0.28'
 
 Minitest/LiteralAsActualArgument:
   Description: 'This cop enforces correct order of `expected` and `actual` arguments for `assert_equal`.'
@@ -157,6 +187,17 @@ Minitest/NoAssertions:
   Enabled: false
   VersionAdded: '0.12'
 
+Minitest/NoTestCases:
+  Description: 'Checks if test class contains any test cases.'
+  Enabled: false
+  VersionAdded: '0.30'
+
+Minitest/NonPublicTestMethod:
+  Description: 'Detects non `public` (marked as `private` or `protected`) test methods.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '0.27'
+
 Minitest/RefuteEmpty:
   Description: 'This cop enforces to use `refute_empty` instead of using `refute(object.empty?)`.'
   StyleGuide: 'https://minitest.rubystyle.guide#refute-empty'
@@ -173,7 +214,9 @@ Minitest/RefuteFalse:
   Description: 'Check if your test uses `refute(actual)` instead of `assert_equal(false, actual)`.'
   StyleGuide: 'https://minitest.rubystyle.guide#refute-false'
   Enabled: true
+  Safe: false
   VersionAdded: '0.3'
+  VersionChanged: '0.27'
 
 Minitest/RefuteInDelta:
   Description: 'This cop enforces the test to use `refute_in_delta` instead of using `refute_equal` to compare floats.'
@@ -211,6 +254,12 @@ Minitest/RefuteNil:
   Enabled: true
   VersionAdded: '0.2'
 
+Minitest/RefuteOperator:
+  Description: 'This cop enforces the use of `refute_operator(expected, :<, actual)` over `refute(expected < actual)`.'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-operator'
+  Enabled: pending
+  VersionAdded: '0.32'
+
 Minitest/RefutePathExists:
   Description: 'This cop enforces the test to use `refute_path_exists` instead of using `refute(File.exist?(path))`.'
   StyleGuide: 'https://minitest.rubystyle.guide/#refute-path-exists'
@@ -229,10 +278,35 @@ Minitest/RefuteRespondTo:
   Enabled: true
   VersionAdded: '0.4'
 
+Minitest/RefuteSame:
+  Description: 'Enforces the use of `refute_same(expected, actual)` over `refute(expected.equal?(actual))`.'
+  StyleGuide: 'https://minitest.rubystyle.guide#refute-same'
+  Enabled: pending
+  VersionAdded: '0.26'
+
+Minitest/ReturnInTestMethod:
+  Description: 'Enforces the use of `skip` instead of `return` in test methods.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#skipping-runnable-methods'
+  Enabled: pending
+  VersionAdded: '0.31'
+
 Minitest/SkipEnsure:
   Description: 'Checks that `ensure` call even if `skip`.'
   Enabled: pending
+  Severity: warning
   VersionAdded: '0.20'
+  VersionChanged: '0.26'
+
+Minitest/SkipWithoutReason:
+  Description: 'Checks for skipped tests missing the skipping reason.'
+  Enabled: pending
+  VersionAdded: '0.24'
+
+Minitest/TestFileName:
+  Description: 'Checks if test file names start with `test_` or end with `_test.rb`.'
+  StyleGuide: 'https://minitest.rubystyle.guide/#file-naming'
+  Enabled: pending
+  VersionAdded: '0.26'
 
 Minitest/TestMethodName:
   Description: 'This cop enforces that test method names start with `test_` prefix.'
@@ -242,10 +316,17 @@ Minitest/TestMethodName:
 Minitest/UnreachableAssertion:
   Description: 'This cop checks for an `assert_raises` block containing any unreachable assertions.'
   Enabled: pending
+  Severity: warning
   VersionAdded: '0.14'
+  VersionChanged: '0.26'
 
 Minitest/UnspecifiedException:
   Description: 'This cop checks for a specified error in `assert_raises`.'
   StyleGuide: 'https://minitest.rubystyle.guide#unspecified-exception'
   Enabled: 'pending'
   VersionAdded: '0.10'
+
+Minitest/UselessAssertion:
+  Description: 'Detects useless assertions (assertions that either always pass or always fail).'
+  Enabled: pending
+  VersionAdded: '0.26'

data/lib/rubocop/cop/generator.rb

@@ -10,7 +10,7 @@ module RuboCop
       TEST_TEMPLATE = <<~TEST
         # frozen_string_literal: true
 
-        require 'test_helper'
+        require_relative '../../../test_helper'
 
         class %<cop_name>sTest < Minitest::Test
           def test_registers_offense_when_using_bad_method

data/lib/rubocop/cop/minitest/assert_instance_of.rb

@@ -11,14 +11,30 @@ module RuboCop
       #   assert(object.instance_of?(Class))
       #   assert(object.instance_of?(Class), 'message')
       #
+      #   # bad
+      #   assert_equal(Class, object.class)
+      #   assert_equal(Class, object.class, 'message')
+      #
       #   # good
       #   assert_instance_of(Class, object)
       #   assert_instance_of(Class, object, 'message')
       #
       class AssertInstanceOf < Base
-        extend MinitestCopRule
+        include InstanceOfAssertionHandleable
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[assert assert_equal].freeze
+
+        def_node_matcher :instance_of_assertion?, <<~PATTERN
+          {
+            (send nil? :assert (send $_ :instance_of? $const) $_?)
+            (send nil? :assert_equal $const (send $_ :class) $_?)
+          }
+        PATTERN
 
-        define_rule :assert, target_method: :instance_of?, inverse: true
+        def on_send(node)
+          investigate(node, :assert)
+        end
       end
     end
   end

data/lib/rubocop/cop/minitest/assert_match.rb

@@ -9,6 +9,8 @@ module RuboCop
       # @example
       #   # bad
       #   assert(matcher.match(string))
+      #   assert(matcher.match?(string))
+      #   assert(matcher =~ string)
       #   assert(matcher.match(string), 'message')
       #
       #   # good
@@ -18,7 +20,8 @@ module RuboCop
       class AssertMatch < Base
         extend MinitestCopRule
 
-        define_rule :assert, target_method: :match, inverse: 'regexp_type?'
+        define_rule :assert, target_method: %i[match match? =~],
+                             preferred_method: :assert_match, inverse: 'regexp_type?'
       end
     end
   end

data/lib/rubocop/cop/minitest/assert_operator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces the use of `assert_operator(expected, :<, actual)` over `assert(expected < actual)`.
+      #
+      # @example
+      #
+      #   # bad
+      #   assert(expected < actual)
+      #
+      #   # good
+      #   assert_operator(expected, :<, actual)
+      #
+      class AssertOperator < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer using `assert_operator(%<new_arguments>s)`.'
+        RESTRICT_ON_SEND = %i[assert].freeze
+        ALLOWED_OPERATORS = [:[]].freeze
+
+        def on_send(node)
+          first_argument = node.first_argument
+          return unless first_argument.respond_to?(:binary_operation?) && first_argument.binary_operation?
+
+          operator = first_argument.to_a[1]
+          return if ALLOWED_OPERATORS.include?(operator)
+
+          new_arguments = build_new_arguments(node)
+
+          add_offense(node, message: format(MSG, new_arguments: new_arguments)) do |corrector|
+            corrector.replace(node.loc.selector, 'assert_operator')
+
+            corrector.replace(range_of_arguments(node), new_arguments)
+          end
+        end
+
+        private
+
+        def build_new_arguments(node)
+          lhs, op, rhs = *node.first_argument
+          new_arguments = "#{lhs.source}, :#{op}, #{rhs.source}"
+
+          if node.arguments.count == 2
+            new_arguments << ", #{node.last_argument.source}"
+          else
+            new_arguments
+          end
+        end
+
+        def range_of_arguments(node)
+          node.first_argument.source_range.begin.join(node.last_argument.source_range.end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest/assert_output.rb

@@ -36,8 +36,7 @@ module RuboCop
         private
 
         def find_test_case(node)
-          def_ancestor = node.each_ancestor(:def).first
-          def_ancestor if test_case?(def_ancestor)
+          node.each_ancestor.find { |ancestor| test_case?(ancestor) }
         end
 
         def references_gvar?(assertion, gvar_name)

data/lib/rubocop/cop/minitest/assert_path_exists.rb

@@ -30,20 +30,25 @@ module RuboCop
         def on_send(node)
           assert_file_exists(node) do |path, failure_message|
             failure_message = failure_message.first
-            good_method = build_good_method(path, failure_message)
+            good_method = build_good_method(node, path, failure_message)
             message = format(MSG, good_method: good_method)
 
             add_offense(node, message: message) do |corrector|
-              corrector.replace(node, good_method)
+              corrector.replace(node.loc.selector, 'assert_path_exists')
+              corrector.replace(node.first_argument, path.source)
             end
           end
         end
 
         private
 
-        def build_good_method(path, message)
+        def build_good_method(node, path, message)
           args = [path.source, message&.source].compact.join(', ')
-          "assert_path_exists(#{args})"
+          if node.parenthesized?
+            "assert_path_exists(#{args})"
+          else
+            "assert_path_exists #{args}"
+          end
         end
       end
     end

data/lib/rubocop/cop/minitest/assert_same.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces the use of `assert_same(expected, actual)`
+      # over `assert(expected.equal?(actual))`.
+      #
+      # NOTE: Use `assert_same` only when there is a need to compare by identity.
+      #       Otherwise, use `assert_equal`.
+      #
+      # @example
+      #   # bad
+      #   assert(expected.equal?(actual))
+      #
+      #   # good
+      #   assert_same(expected, actual)
+      #
+      class AssertSame < Base
+        extend MinitestCopRule
+
+        define_rule :assert, target_method: :equal?, preferred_method: :assert_same
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest/assert_truthy.rb

@@ -5,6 +5,16 @@ module RuboCop
     module Minitest
       # Enforces the test to use `assert(actual)` instead of using `assert_equal(true, actual)`.
       #
+      # @safety
+      #   This cop is unsafe because true might be expected instead of truthy.
+      #   False positives cannot be prevented when this is a variable or method return value.
+      #
+      #   [source,ruby]
+      #   ----
+      #   assert_equal(true, 'truthy') # failure
+      #   assert('truthy')             # success
+      #   ----
+      #
       # @example
       #   # bad
       #   assert_equal(true, actual)

data/lib/rubocop/cop/minitest/assert_with_expected_argument.rb

@@ -6,6 +6,9 @@ module RuboCop
       # Tries to detect when a user accidentally used
       # `assert` when they meant to use `assert_equal`.
       #
+      # NOTE: The second argument to the `assert` method named `message` and `msg` is allowed.
+      #       Because their names are inferred as message arguments.
+      #
       # @safety
       #   This cop is unsafe because it is not possible to determine
       #   whether the second argument of `assert` is a message or not.
@@ -19,10 +22,13 @@ module RuboCop
       #   assert_equal(3, my_list.length)
       #   assert_equal(expected, actual)
       #   assert(foo, 'message')
+      #   assert(foo, message)
+      #   assert(foo, msg)
       #
       class AssertWithExpectedArgument < Base
         MSG = 'Did you mean to use `assert_equal(%<arguments>s)`?'
         RESTRICT_ON_SEND = %i[assert].freeze
+        MESSAGE_VARIABLES = %w[message msg].freeze
 
         def_node_matcher :assert_with_two_arguments?, <<~PATTERN
           (send nil? :assert $_ $_)
@@ -30,7 +36,7 @@ module RuboCop
 
         def on_send(node)
           assert_with_two_arguments?(node) do |_expected, message|
-            return if message.str_type? || message.dstr_type?
+            return if message.str_type? || message.dstr_type? || MESSAGE_VARIABLES.include?(message.source)
 
             arguments = node.arguments.map(&:source).join(', ')
             add_offense(node, message: format(MSG, arguments: arguments))

data/lib/rubocop/cop/minitest/empty_line_before_assertion_methods.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Enforces empty line before assertion methods because it separates assertion phase.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something
+      #   assert_equal(expected, actual)
+      #
+      #   # good
+      #   do_something
+      #
+      #   assert_equal(expected, actual)
+      #
+      class EmptyLineBeforeAssertionMethods < Base
+        include MinitestExplorationHelpers
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Add empty line before assertion.'
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_send(node)
+          return unless (assertion_method = assertion_method(node))
+          return unless (previous_line_node = assertion_method.left_sibling)
+          return if node.parent.resbody_type?
+          return if accept_previous_line?(previous_line_node, assertion_method)
+
+          previous_line_node = previous_line_node.arguments.last if use_heredoc_argument?(previous_line_node)
+          return if use_assertion_method_at_last_of_block?(previous_line_node)
+          return unless no_empty_line?(previous_line_node, assertion_method)
+
+          register_offense(assertion_method, previous_line_node)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        private
+
+        def assertion_method(node)
+          return node if assertion_method?(node)
+          return unless (parent = node.parent)
+          return unless parent.block_type?
+          return if parent.method?(:test)
+
+          node.parent if parent.body && assertion_method?(parent.body)
+        end
+
+        def accept_previous_line?(previous_line_node, node)
+          return true if !previous_line_node.is_a?(RuboCop::AST::Node) ||
+                         previous_line_node.args_type? || node.parent.basic_conditional?
+
+          assertion_method?(previous_line_node)
+        end
+
+        def use_heredoc_argument?(node)
+          node.respond_to?(:arguments) && heredoc?(node.arguments.last)
+        end
+
+        def use_assertion_method_at_last_of_block?(node)
+          return false if !node.block_type? || !node.body
+
+          if node.body.begin_type?
+            assertion_method?(node.body.children.last)
+          else
+            assertion_method?(node.body)
+          end
+        end
+
+        def heredoc?(last_argument)
+          last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+        end
+
+        def no_empty_line?(previous_line_node, node)
+          previous_line = if heredoc?(previous_line_node)
+                            previous_line_node.loc.heredoc_end.line
+                          else
+                            previous_line_node.loc.last_line
+                          end
+
+          previous_line + 1 == node.loc.line
+        end
+
+        def register_offense(node, previous_line_node)
+          add_offense(node) do |corrector|
+            range = if heredoc?(previous_line_node)
+                      previous_line_node.loc.heredoc_end
+                    else
+                      range_by_whole_lines(previous_line_node.source_range, include_final_newline: true)
+                    end
+
+            corrector.insert_after(range, "\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest/global_expectations.rb

@@ -96,7 +96,9 @@ module RuboCop
           wont_be_kind_of wont_match wont_be_nil wont_be wont_respond_to wont_be_same_as
         ].freeze
 
-        BLOCK_MATCHERS = %i[must_output must_raise must_be_silent must_throw].freeze
+        BLOCK_MATCHERS = %i[
+          must_output must_pattern_match must_raise must_be_silent must_throw wont_pattern_match
+        ].freeze
 
         RESTRICT_ON_SEND = VALUE_MATCHERS + BLOCK_MATCHERS
 

data/lib/rubocop/cop/minitest/lifecycle_hooks_order.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # Checks that lifecycle hooks are declared in the order in which they will be executed.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def teardown; end
+      #     def setup; end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def setup; end
+      #     def teardown; end
+      #   end
+      #
+      #   # bad (after test cases)
+      #   class FooTest < Minitest::Test
+      #     def test_something
+      #       assert foo
+      #     end
+      #     def setup; end
+      #     def teardown; end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def setup; end
+      #     def teardown; end
+      #     def test_something
+      #       assert foo
+      #     end
+      #   end
+      #
+      #   # good (after non test case methods)
+      #   class FooTest < Minitest::Test
+      #     def do_something; end
+      #     def setup; end
+      #     def teardown; end
+      #   end
+      #
+      class LifecycleHooksOrder < Base
+        include MinitestExplorationHelpers
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`%<current>s` is supposed to appear before `%<previous>s`.'
+
+        # Regular method's position should be last.
+        REGULAR_METHOD_POSITION = LIFECYCLE_HOOK_METHODS_IN_ORDER.size + 1
+        HOOKS_ORDER_MAP = Hash.new do |hash, hook|
+          hash[hook] = LIFECYCLE_HOOK_METHODS_IN_ORDER.index(hook) || REGULAR_METHOD_POSITION
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          previous_index = -1
+          previous_hook_node = nil
+
+          hooks_and_test_cases(class_node).each do |node|
+            hook = node.method_name
+            index = HOOKS_ORDER_MAP[hook]
+
+            if index < previous_index
+              message = format(MSG, current: hook, previous: previous_hook_node.method_name)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, previous_hook_node, node)
+              end
+            end
+            previous_index = index
+            previous_hook_node = node
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def hooks_and_test_cases(class_node)
+          class_def_nodes(class_node).select do |node|
+            lifecycle_hook_method?(node) || test_case?(node)
+          end
+        end
+
+        def autocorrect(corrector, previous_node, node)
+          previous_node_range = range_with_comments_and_lines(previous_node)
+          node_range = range_with_comments_and_lines(node)
+
+          corrector.insert_before(previous_node_range, node_range.source)
+          corrector.remove(node_range)
+        end
+      end
+    end
+  end
+end