rubocop-minitest 0.39.1 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 105c20646b59d61d5b7782e8acd5eb2af261c82e2e570a45476c18aac021a582
-  data.tar.gz: 899dff52feb335ffe772a5271de2d809034aaf851f26ae6da5e467e6040a4125
+  metadata.gz: eda17cda5caf90c2cf74b9f760a0ba38d1cf1c9e5d73c16c450dc4b905bb0105
+  data.tar.gz: a623715c3491d9eaa408842b98f790cc95c761d75fe5c42e0a9bb8b32c0730bf
 SHA512:
-  metadata.gz: dd0e8fdbb2be6cc4b6987a4e4c093f68325cafcf813bdf92b4b7ab5cbbea6dce9c33549806240e7bac9c8c259767ac7024e19bc32eaa5aca1e89f99a96c56dac
-  data.tar.gz: e0a3dd6040a6b7385d4057a62b2be39ada32de00e5e42014df2294b9a4bfb2d1633738abce251943e6948cc6391e24c3fab2fb69b9652a12c51744aa35dfa220
+  metadata.gz: ea451f9315708de691d4fec8a1190f7c3ad20c1f601ea784f05d20289d43cbec4f6471ef257ed0ef63341c20c8abac9f990db749a7faa1b12af6c5fe6725904d
+  data.tar.gz: e8404442a84c387f85c38d270a8312d2f0e0b37105cabf9bd0b5a25d3ac9bf3d48267659b25c4432f7ef335315f1fc3df585c1223ec9acc16c35e541fdc858fb

data/README.md

@@ -78,6 +78,96 @@ Minitest/AssertNil:
     - test/my_file_to_ignore_test.rb
 ```
 
+## Testing your own cops
+
+This gem provides `RuboCop::TestCase`, a base test case class for testing custom cops with Minitest.
+Require `rubocop/minitest/support` in your test helper, then inherit from `RuboCop::TestCase` to get
+the `assert_offense`, `assert_correction`, `assert_no_corrections`, and `assert_no_offenses` assertions:
+
+```ruby
+require 'rubocop/minitest/support'
+
+module CustomCops
+  class MyCopTest < RuboCop::TestCase
+    def test_registers_offense
+      assert_offense(<<~RUBY)
+        bad_method
+        ^^^^^^^^^^ Use `good_method` instead of `bad_method`.
+      RUBY
+
+      assert_correction(<<~RUBY)
+        good_method
+      RUBY
+    end
+
+    def test_does_not_register_offense
+      assert_no_offenses(<<~RUBY)
+        good_method
+      RUBY
+    end
+  end
+end
+```
+
+The cop under test is derived from the test class name: `CustomCops::MyCopTest` resolves
+`CustomCops::MyCop`, then `RuboCop::Cop::Minitest::MyCop`. Define a `cop_class` method in
+the test class to specify the cop explicitly:
+
+```ruby
+class MyCopTest < RuboCop::TestCase
+  private
+
+  def cop_class
+    CustomCops::MyCop
+  end
+end
+```
+
+The configuration for the cop under test and the target Ruby version can be specified
+by overriding `cop_config`, `other_cops`, or `target_ruby_version` in the test class:
+
+```ruby
+class MyCopTest < RuboCop::TestCase
+  private
+
+  def cop_config
+    { 'Max' => 1 }
+  end
+
+  def target_ruby_version
+    3.0
+  end
+end
+```
+
+To change them for a single test, assign them in the test method. This makes it
+possible for tests targeting different Ruby versions to live in the same test class:
+
+```ruby
+class MyCopTest < RuboCop::TestCase
+  def test_registers_offense_on_ruby31
+    self.target_ruby_version = 3.1
+
+    assert_offense(<<~RUBY)
+      bad_method
+      ^^^^^^^^^^ Use `good_method` instead of `bad_method`.
+    RUBY
+  end
+
+  def test_does_not_register_offense_on_ruby30
+    self.target_ruby_version = 3.0
+
+    assert_no_offenses(<<~RUBY)
+      bad_method
+    RUBY
+  end
+end
+```
+
+The default configuration of extensions registered as [lint_roller](https://github.com/standardrb/lint_roller) plugins
+is applied automatically. For other extensions, call `RuboCop::ConfigLoader.inject_defaults!('path/to/default.yml')`
+in your test helper.
+
 ## Documentation
 
 You can read a lot more about RuboCop Minitest in its [official docs](https://docs.rubocop.org/rubocop-minitest/).

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

@@ -31,7 +31,8 @@ module RuboCop
 
         def on_def(node)
           return if !test_method?(node) || !use_test_class?
-          return if node.left_siblings.none? { |sibling| possible_test_class?(sibling) }
+          return if inside_test_class?(node)
+          return if (node.left_siblings + node.right_siblings).none? { |sibling| possible_test_class?(sibling) }
 
           add_offense(node)
         end
@@ -44,6 +45,10 @@ module RuboCop
           root_node.each_descendant(:class).any? { |class_node| test_class?(class_node) }
         end
 
+        def inside_test_class?(node)
+          node.each_ancestor(:class).any? { |class_node| test_class?(class_node) }
+        end
+
         def possible_test_class?(node)
           node.is_a?(AST::ClassNode) && test_class?(node) && node.parent_class.source.include?('Test')
         end

data/lib/rubocop/minitest/assert_offense.rb

@@ -71,17 +71,138 @@ module RuboCop
     #
     #   assert_no_corrections
     #
+    # The cop under test is derived from the test class name: `FooTest` resolves
+    # the `Foo` constant in the test class's namespace, then `RuboCop::Cop::Minitest::Foo`.
+    # Define a `cop_class` method in the test class to specify the cop explicitly:
+    #
+    #   class AssertNilTest < RuboCop::TestCase
+    #     private
+    #
+    #     def cop_class
+    #       RuboCop::Cop::Minitest::AssertNil
+    #     end
+    #   end
+    #
+    # The configuration for the cop under test and the target Ruby version can be specified
+    # by overriding `cop_config`, `other_cops`, or `target_ruby_version` in the test class:
+    #
+    # @example `cop_config` and `target_ruby_version`
+    #
+    #   class MultipleAssertionsTest < RuboCop::TestCase
+    #     private
+    #
+    #     def cop_config
+    #       { 'Max' => 1 }
+    #     end
+    #
+    #     def target_ruby_version
+    #       3.0
+    #     end
+    #   end
+    #
+    # To change them for a single test, assign them in the test method.
+    # This makes it possible for tests targeting different Ruby versions to live in the same test class:
+    #
+    # @example assigning `target_ruby_version` per test
+    #
+    #   class MyCopTest < RuboCop::TestCase
+    #     def test_registers_offense_on_ruby31
+    #       self.target_ruby_version = 3.1
+    #
+    #       assert_offense(<<~RUBY)
+    #         ...
+    #       RUBY
+    #     end
+    #
+    #     def test_does_not_register_offense_on_ruby30
+    #       self.target_ruby_version = 3.0
+    #
+    #       assert_no_offenses(<<~RUBY)
+    #         ...
+    #       RUBY
+    #     end
+    #   end
+    #
     # rubocop:disable Metrics/ModuleLength
     module AssertOffense
+      PLUGIN_INTEGRATION_MUTEX = Mutex.new
+      private_constant :PLUGIN_INTEGRATION_MUTEX
+
+      # Initialized here so that reading it under `ruby -w` does not warn before the first assignment.
+      @integrated_plugins = nil
+
+      class << self
+        # Makes the default configuration of extensions registered as lint_roller plugins visible
+        # through `RuboCop::ConfigLoader.default_configuration`.
+        # Guarded by a mutex so that parallel test threads reaching their first assertion at the same time
+        # do not integrate plugins twice or race on the lazy initialization of the default configuration.
+        def integrate_plugins!
+          PLUGIN_INTEGRATION_MUTEX.synchronize do
+            next if @integrated_plugins
+
+            plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
+              feature_name if feature_specification.metadata['default_lint_roller_plugin']
+            end
+            RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
+
+            @integrated_plugins = true
+          end
+        end
+      end
+
       private
 
       def cop
         @cop ||= begin
-          cop_name = self.class.to_s.delete_suffix('Test')
-          raise "Cop not defined: #{cop_name}" unless RuboCop::Cop::Minitest.const_defined?(cop_name)
+          unless cop_class
+            raise "Could not determine the cop class under test from `#{self.class}`. " \
+                  'The cop class is derived from the test class name (e.g. `FooTest` resolves `Foo` ' \
+                  "in the test class's namespace, then `RuboCop::Cop::Minitest::Foo`). " \
+                  'Define a `cop_class` method in your test class to specify it explicitly.'
+          end
+
+          cop_class.new(configuration)
+        end
+      end
+
+      def cop_class
+        @cop_class ||= derive_cop_class
+      end
+
+      def cop_class=(cop_class)
+        @cop_class = cop_class
+
+        reset_memoization
+      end
+
+      def derive_cop_class
+        klass = self.class
+
+        while klass && klass != ::Minitest::Test
+          candidate = derive_cop_class_from_name(klass.name)
+          return candidate if candidate
 
-          RuboCop::Cop::Minitest.const_get(cop_name).new(configuration)
+          klass = klass.superclass
         end
+
+        nil
+      end
+
+      def derive_cop_class_from_name(test_class_name)
+        return unless test_class_name
+
+        cop_name = test_class_name.delete_suffix('Test')
+        return if cop_name.empty?
+
+        constant_from(Object, cop_name) || constant_from(RuboCop::Cop::Minitest, cop_name.split('::').last)
+      end
+
+      def constant_from(namespace, constant_name)
+        return unless namespace.const_defined?(constant_name)
+
+        candidate = namespace.const_get(constant_name)
+
+        candidate if candidate.is_a?(Class) && candidate < RuboCop::Cop::Base
       end
 
       def format_offense(source, **replacements)
@@ -97,7 +218,7 @@ module RuboCop
       def assert_no_offenses(source, file = nil)
         setup_assertion
 
-        offenses = inspect_source(source, cop, file)
+        offenses = inspect_source(source, file)
 
         expected_annotations = RuboCop::RSpec::ExpectOffense::AnnotatedSource.parse(source)
         actual_annotations = expected_annotations.with_offense_annotations(offenses)
@@ -180,19 +301,15 @@ module RuboCop
         RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
       end
 
-      def inspect_source(source, cop, file = nil)
+      def inspect_source(source, file = nil)
         processed_source = parse_source!(source, file)
         raise 'Error parsing example code' unless processed_source.valid_syntax?
 
         _investigate(cop, processed_source)
       end
 
-      def investigate(cop, processed_source)
-        needed = Hash.new { |h, k| h[k] = [] }
-        Array(cop.class.joining_forces).each { |force| needed[force] << cop }
-        forces = needed.map do |force_class, joining_cops|
-          force_class.new(joining_cops)
-        end
+      def investigate(processed_source)
+        forces = Array(cop.class.joining_forces).map { |force_class| force_class.new([cop]) }
 
         commissioner = RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
         commissioner.investigate(processed_source)
@@ -206,7 +323,7 @@ module RuboCop
           file = file.path
         end
 
-        processed_source = RuboCop::ProcessedSource.new(source, ruby_version, file, parser_engine: parser_engine)
+        processed_source = RuboCop::ProcessedSource.new(source, target_ruby_version, file, parser_engine: parser_engine)
         processed_source.config = configuration
         processed_source.registry = registry
         processed_source
@@ -216,22 +333,71 @@ module RuboCop
         @configuration ||= if defined?(config)
                              config
                            else
-                             RuboCop::Config.new({}, "#{Dir.pwd}/.rubocop.yml")
+                             RuboCop::Config.new(configuration_hash, "#{Dir.pwd}/.rubocop.yml")
                            end
       end
 
+      def configuration_hash
+        RuboCop::Minitest::AssertOffense.integrate_plugins!
+
+        hash = { 'AllCops' => { 'TargetRubyVersion' => target_ruby_version } }
+        if cop_class
+          hash[cop_class.cop_name] = RuboCop::ConfigLoader.default_configuration.for_cop(cop_class).merge(
+            'Enabled' => true, 'AutoCorrect' => 'always'
+          ).merge(cop_config)
+        end
+
+        hash.merge(other_cops)
+      end
+
+      def cop_config
+        @cop_config ||= {}
+      end
+
+      def cop_config=(config)
+        @cop_config = config
+
+        reset_memoization
+      end
+
+      def other_cops
+        @other_cops ||= {}
+      end
+
+      def other_cops=(other_cops)
+        @other_cops = other_cops
+
+        reset_memoization
+      end
+
       def registry
         @registry ||= begin
           cops = configuration.keys.map { |cop| RuboCop::Cop::Registry.global.find_by_cop_name(cop) }
-          cops << cop_class if defined?(cop_class) && !cops.include?(cop_class)
+          cops << cop_class if cop_class && !cops.include?(cop_class)
           cops.compact!
           RuboCop::Cop::Registry.new(cops)
         end
       end
 
-      def ruby_version
+      def target_ruby_version
         # Prism is the default backend parser for Ruby 3.4+.
-        ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.4 : RuboCop::TargetRuby::DEFAULT_VERSION
+        @target_ruby_version ||= (ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.4 : RuboCop::TargetRuby::DEFAULT_VERSION)
+      end
+
+      def target_ruby_version=(version)
+        @target_ruby_version = version
+
+        reset_memoization
+      end
+
+      def reset_memoization
+        @cop = nil
+        @configuration = nil
+        @registry = nil
+      end
+
+      def ruby_version
+        target_ruby_version
       end
 
       def parser_engine

data/lib/rubocop/minitest/support.rb

@@ -5,5 +5,6 @@
 require 'rubocop'
 require 'minitest'
 require_relative 'assert_offense'
+require_relative '../test_case'
 
 Minitest::Test.include RuboCop::Minitest::AssertOffense

data/lib/rubocop/minitest/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Minitest
     # This module holds the RuboCop Minitest version information.
     module Version
-      STRING = '0.39.1'
+      STRING = '0.40.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/lib/rubocop/test_case.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'minitest'
+require_relative 'minitest/assert_offense'
+
+module RuboCop
+  # Base test case class for testing custom cops with Minitest.
+  #
+  # @example Usage
+  #
+  #   class MyCopTest < RuboCop::TestCase
+  #     def test_registers_offense
+  #       assert_offense(<<~RUBY)
+  #         bad_method
+  #         ^^^^^^^^^^ Use `good_method` instead of `bad_method`.
+  #       RUBY
+  #
+  #       assert_correction(<<~RUBY)
+  #         good_method
+  #       RUBY
+  #     end
+  #   end
+  #
+  # See the documentation of `RuboCop::Minitest::AssertOffense` for details.
+  class TestCase < ::Minitest::Test
+    include RuboCop::Minitest::AssertOffense
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-minitest
 version: !ruby/object:Gem::Version
-  version: 0.39.1
+  version: 0.40.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -145,13 +145,14 @@ files:
 - lib/rubocop/minitest/plugin.rb
 - lib/rubocop/minitest/support.rb
 - lib/rubocop/minitest/version.rb
+- lib/rubocop/test_case.rb
 licenses:
 - MIT
 metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-minitest/
   changelog_uri: https://github.com/rubocop/rubocop-minitest/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-minitest
-  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.39
+  documentation_uri: https://docs.rubocop.org/rubocop-minitest/0.40
   bug_tracker_uri: https://github.com/rubocop/rubocop-minitest/issues
   rubygems_mfa_required: 'true'
   default_lint_roller_plugin: RuboCop::Minitest::Plugin
@@ -169,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0.dev
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Automatic Minitest code style checking tool.
 test_files: []