rubocop-minitest 0.15.1 → 0.17.1

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

@@ -6,17 +6,83 @@ module RuboCop
       # This cop checks for deprecated global expectations
       # and autocorrects them to use expect format.
       #
-      # @example
+      # @example EnforcedStyle: _
       #   # bad
       #   musts.must_equal expected_musts
       #   wonts.wont_match expected_wonts
       #   musts.must_raise TypeError
       #
+      #   expect(musts).must_equal expected_musts
+      #   expect(wonts).wont_match expected_wonts
+      #   expect { musts }.must_raise TypeError
+      #
+      #   value(musts).must_equal expected_musts
+      #   value(wonts).wont_match expected_wonts
+      #   value { musts }.must_raise TypeError
+      #
       #   # good
       #   _(musts).must_equal expected_musts
       #   _(wonts).wont_match expected_wonts
       #   _ { musts }.must_raise TypeError
+      #
+      # @example EnforcedStyle: any (default)
+      #   # bad
+      #   musts.must_equal expected_musts
+      #   wonts.wont_match expected_wonts
+      #   musts.must_raise TypeError
+      #
+      #   # good
+      #   _(musts).must_equal expected_musts
+      #   _(wonts).wont_match expected_wonts
+      #   _ { musts }.must_raise TypeError
+      #
+      #   expect(musts).must_equal expected_musts
+      #   expect(wonts).wont_match expected_wonts
+      #   expect { musts }.must_raise TypeError
+      #
+      #   value(musts).must_equal expected_musts
+      #   value(wonts).wont_match expected_wonts
+      #   value { musts }.must_raise TypeError
+      #
+      # @example EnforcedStyle: expect
+      #   # bad
+      #   musts.must_equal expected_musts
+      #   wonts.wont_match expected_wonts
+      #   musts.must_raise TypeError
+      #
+      #   _(musts).must_equal expected_musts
+      #   _(wonts).wont_match expected_wonts
+      #   _ { musts }.must_raise TypeError
+      #
+      #   value(musts).must_equal expected_musts
+      #   value(wonts).wont_match expected_wonts
+      #   value { musts }.must_raise TypeError
+      #
+      #   # good
+      #   expect(musts).must_equal expected_musts
+      #   expect(wonts).wont_match expected_wonts
+      #   expect { musts }.must_raise TypeError
+      #
+      # @example EnforcedStyle: value
+      #   # bad
+      #   musts.must_equal expected_musts
+      #   wonts.wont_match expected_wonts
+      #   musts.must_raise TypeError
+      #
+      #   _(musts).must_equal expected_musts
+      #   _(wonts).wont_match expected_wonts
+      #   _ { musts }.must_raise TypeError
+      #
+      #   expect(musts).must_equal expected_musts
+      #   expect(wonts).wont_match expected_wonts
+      #   expect { musts }.must_raise TypeError
+      #
+      #   # good
+      #   value(musts).must_equal expected_musts
+      #   value(wonts).wont_match expected_wonts
+      #   value { musts }.must_raise TypeError
       class GlobalExpectations < Base
+        include ConfigurableEnforcedStyle
         extend AutoCorrector
 
         MSG = 'Use `%<preferred>s` instead.'
@@ -34,58 +100,63 @@ module RuboCop
 
         RESTRICT_ON_SEND = VALUE_MATCHERS + BLOCK_MATCHERS
 
-        VALUE_MATCHERS_STR = VALUE_MATCHERS.map do |m|
-          ":#{m}"
-        end.join(' ').freeze
+        # There are aliases for the `_` method - `expect` and `value`
+        DSL_METHODS = %i[_ expect value].freeze
 
-        BLOCK_MATCHERS_STR = BLOCK_MATCHERS.map do |m|
-          ":#{m}"
-        end.join(' ').freeze
+        def on_send(node)
+          receiver = node.receiver
+          return unless receiver
 
-        # There are aliases for the `_` method - `expect` and `value`
-        DSL_METHODS_LIST = %w[_ value expect].map do |n|
-          ":#{n}"
-        end.join(' ').freeze
+          method = block_receiver?(receiver) || value_receiver?(receiver)
+          return if method == preferred_method || (method && style == :any)
+
+          register_offense(node, method)
+        end
 
-        def_node_matcher :value_global_expectation?, <<~PATTERN
-          (send !(send nil? {#{DSL_METHODS_LIST}} _) {#{VALUE_MATCHERS_STR}} ...)
+        private
+
+        def_node_matcher :block_receiver?, <<~PATTERN
+          (block (send nil? $#method_allowed?) _ _)
         PATTERN
 
-        def_node_matcher :block_global_expectation?, <<~PATTERN
-          (send
-            [
-              !(send nil? {#{DSL_METHODS_LIST}} _)
-              !(block (send nil? {#{DSL_METHODS_LIST}}) _ _)
-            ]
-            {#{BLOCK_MATCHERS_STR}}
-            _
-          )
+        def_node_matcher :value_receiver?, <<~PATTERN
+          (send nil? $#method_allowed? _)
         PATTERN
 
-        def on_send(node)
-          return unless value_global_expectation?(node) || block_global_expectation?(node)
+        def method_allowed?(method)
+          DSL_METHODS.include?(method)
+        end
 
-          message = format(MSG, preferred: preferred_receiver(node))
+        def preferred_method
+          style == :any ? :_ : style
+        end
 
-          add_offense(node.receiver.source_range, message: message) do |corrector|
-            receiver = node.receiver.source_range
+        def preferred_receiver(node)
+          receiver = node.receiver
 
-            if BLOCK_MATCHERS.include?(node.method_name)
-              corrector.wrap(receiver, '_ { ', ' }')
-            else
-              corrector.wrap(receiver, '_(', ')')
-            end
+          if BLOCK_MATCHERS.include?(node.method_name)
+            body = receiver.lambda? ? receiver.body : receiver
+            "#{preferred_method} { #{body.source} }"
+          else
+            "#{preferred_method}(#{receiver.source})"
           end
         end
 
-        private
+        def register_offense(node, method)
+          receiver = node.receiver
 
-        def preferred_receiver(node)
-          source = node.receiver.source
-          if BLOCK_MATCHERS.include?(node.method_name)
-            "_ { #{source} }"
+          if method
+            preferred = preferred_method
+            replacement = receiver.source.sub(method.to_s, preferred_method.to_s)
           else
-            "_(#{source})"
+            preferred = preferred_receiver(node)
+            replacement = preferred
+          end
+
+          message = format(MSG, preferred: preferred)
+
+          add_offense(receiver, message: message) do |corrector|
+            corrector.replace(receiver, replacement)
           end
         end
       end

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

@@ -50,7 +50,7 @@ module RuboCop
         private
 
         def assertions_count(node)
-          base = assertion?(node) ? 1 : 0
+          base = assertion_method?(node) ? 1 : 0
           base + node.each_child_node.sum { |c| assertions_count(c) }
         end
 

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

@@ -39,7 +39,7 @@ module RuboCop
         private
 
         def assertions_count(node)
-          base = assertion?(node) ? 1 : 0
+          base = assertion_method?(node) ? 1 : 0
           base + node.each_child_node.sum { |c| assertions_count(c) }
         end
       end

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

@@ -19,6 +19,18 @@ module RuboCop
         extend MinitestCopRule
 
         define_rule :refute, target_method: :empty?
+
+        remove_method :on_send
+        def on_send(node)
+          return unless node.method?(:refute)
+          return unless (arguments = peel_redundant_parentheses_from(node.arguments))
+          return unless arguments.first.respond_to?(:method?) && arguments.first.method?(:empty?)
+          return unless arguments.first.arguments.empty?
+
+          add_offense(node, message: offense_message(arguments)) do |corrector|
+            autocorrect(corrector, node, arguments)
+          end
+        end
       end
     end
   end

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

@@ -30,11 +30,9 @@ module RuboCop
 
           last_node = body.begin_type? ? body.children.last : body
           return unless last_node.send_type?
+          return unless assertion_method?(last_node)
 
-          method_name = last_node.method_name
-          return unless assertion_method?(method_name)
-
-          add_offense(last_node, message: format(MSG, assertion_method: method_name))
+          add_offense(last_node, message: format(MSG, assertion_method: last_node.method_name))
         end
       end
     end

data/lib/rubocop/cop/mixin/minitest_exploration_helpers.rb

@@ -10,17 +10,6 @@ module RuboCop
 
       ASSERTION_PREFIXES = %w[assert refute].freeze
 
-      ASSERTION_METHODS = %i[
-        assert assert_empty assert_equal assert_in_delta assert_in_epsilon assert_includes assert_instance_of
-        assert_kind_of assert_match assert_nil assert_operator assert_output assert_path_exists assert_predicate
-        assert_raises assert_respond_to assert_same assert_send assert_silent assert_throws
-        refute refute_empty refute_equal refute_in_delta refute_in_epsilon refute_includes refute_instance_of
-        refute_kind_of refute_match refute_nil refute_operator refute_path_exists refute_predicate
-        refute_respond_to refute_same
-      ].freeze
-
-      FLUNK = 'flunk'
-
       LIFECYCLE_HOOK_METHODS = %i[
         before_setup
         setup
@@ -84,19 +73,18 @@ module RuboCop
             method_def.each_child_node(:send)
           end
 
-        send_nodes.select { |send_node| assertion?(send_node) }
+        send_nodes.select { |send_node| assertion_method?(send_node) }
       end
 
-      def assertion?(node)
-        node.send_type? &&
-          ASSERTION_PREFIXES.any? do |prefix|
-            method_name = node.method_name.to_s
-            method_name == FLUNK || method_name.start_with?(prefix)
-          end
-      end
+      def assertion_method?(node)
+        return false unless node.send_type?
+
+        ASSERTION_PREFIXES.any? do |prefix|
+          method_name = node.method_name
 
-      def assertion_method?(method_name)
-        method_name == FLUNK || ASSERTION_METHODS.include?(method_name)
+          # TODO: Remove the fllowing `to_s` since Ruby 2.7 that supports `Symbol#start_with?`.
+          method_name.to_s.start_with?(prefix) || node.method?(:flunk)
+        end
       end
 
       def lifecycle_hook_method?(node)

data/lib/rubocop/minitest/assert_offense.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Laziness copied from rubocop source code
+require 'rubocop/rspec/expect_offense'
+require 'rubocop/cop/legacy/corrector'
+
+module RuboCop
+  module Minitest
+    # Mixin for `assert_offense` and `assert_no_offenses`
+    #
+    # This mixin makes it easier to specify strict offense assertions
+    # in a declarative and visual fashion. Just type out the code that
+    # should generate a offense, annotate code by writing '^'s
+    # underneath each character that should be highlighted, and follow
+    # the carets with a string (separated by a space) that is the
+    # message of the offense. You can include multiple offenses in
+    # one code snippet.
+    #
+    # @example Usage
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    # Auto-correction can be tested using `assert_correction` after
+    # `assert_offense`.
+    #
+    # @example `assert_offense` and `assert_correction`
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    #   assert_correction(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_nil(somestuff)
+    #       end
+    #     end
+    #   RUBY
+    #
+    # If you do not want to specify an offense then use the
+    # companion method `assert_no_offenses`. This method is a much
+    # simpler assertion since it just inspects the source and checks
+    # that there were no offenses. The `assert_offense` method has
+    # to do more work by parsing out lines that contain carets.
+    #
+    # If the code produces an offense that could not be auto-corrected, you can
+    # use `assert_no_corrections` after `assert_offense`.
+    #
+    # @example `assert_offense` and `assert_no_corrections`
+    #
+    #   assert_offense(<<~RUBY)
+    #     class FooTest < Minitest::Test
+    #       def test_do_something
+    #         assert_equal(nil, somestuff)
+    #         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `assert_nil(somestuff)` over `assert_equal(nil, somestuff)`.
+    #       end
+    #     end
+    #   RUBY
+    #
+    #   assert_no_corrections
+    module AssertOffense
+      private
+
+      def setup
+        cop_name = self.class.to_s.delete_suffix('Test')
+
+        @cop = RuboCop::Cop::Minitest.const_get(cop_name).new
+      end
+
+      def assert_no_offenses(source, file = nil)
+        setup_assertion
+
+        offenses = inspect_source(source, @cop, file)
+
+        expected_annotations = RuboCop::RSpec::ExpectOffense::AnnotatedSource.parse(source)
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
+
+        assert_equal(source, actual_annotations.to_s)
+      end
+
+      def assert_offense(source, file = nil)
+        setup_assertion
+
+        @cop.instance_variable_get(:@options)[:auto_correct] = true
+
+        expected_annotations = RuboCop::RSpec::ExpectOffense::AnnotatedSource.parse(source)
+        if expected_annotations.plain_source == source
+          raise 'Use `assert_no_offenses` to assert that no offenses are found'
+        end
+
+        @processed_source = parse_source!(expected_annotations.plain_source, file)
+
+        offenses = _investigate(@cop, @processed_source)
+
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
+
+        assert_equal(expected_annotations.to_s, actual_annotations.to_s)
+      end
+
+      def _investigate(cop, processed_source)
+        team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
+        report = team.investigate(processed_source)
+        @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
+        report.offenses
+      end
+
+      def assert_correction(correction, loop: true)
+        raise '`assert_correction` must follow `assert_offense`' unless @processed_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrected_source = @last_corrector.rewrite
+
+          break corrected_source unless loop
+          break corrected_source if @last_corrector.empty? || corrected_source == @processed_source.buffer.source
+
+          if iteration > RuboCop::Runner::MAX_ITERATIONS
+            raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [])
+          end
+
+          # Prepare for next loop
+          @processed_source = parse_source!(corrected_source, @processed_source.path)
+
+          _investigate(@cop, @processed_source)
+        end
+
+        assert_equal(correction, new_source)
+      end
+
+      def setup_assertion
+        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+      end
+
+      def inspect_source(source, cop, 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
+
+        commissioner = RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+        commissioner.investigate(processed_source)
+        commissioner
+      end
+
+      def parse_source!(source, file = nil)
+        if file.respond_to?(:write)
+          file.write(source)
+          file.rewind
+          file = file.path
+        end
+
+        RuboCop::ProcessedSource.new(source, ruby_version, file)
+      end
+
+      def ruby_version
+        2.5
+      end
+    end
+  end
+end

data/lib/rubocop/minitest/support.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Require this file to load code that supports testing using Minitest.
+
+require 'rubocop'
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative 'assert_offense'
+
+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.15.1'
+      STRING = '0.17.1'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/mkdocs.yml

@@ -1,7 +1,7 @@
 site_name: "A RuboCop extension focused on enforcing Minitest best practices and coding conventions."
 repo_url: https://github.com/rubocop/rubocop-minitest
 edit_uri: edit/master/legacy-docs/
-copyright: "Copyright © 2021 Bozhidar Batsov, Jonas Arvidsson, Koichi ITO, and RuboCop contributors"
+copyright: "Copyright © 2022 Bozhidar Batsov, Jonas Arvidsson, Koichi ITO, and RuboCop contributors"
 docs_dir: legacy-docs
 pages:
 - Home: index.md

data/relnotes/v0.15.2.md

@@ -0,0 +1,5 @@
+### Bug fixes
+
+* [#145](https://github.com/rubocop/rubocop-minitest/pull/145): Mark `Minitest/AssertEmptyLiteral` as safe auto-correction. ([@koic][])
+
+[@koic]: https://github.com/koic

data/relnotes/v0.16.0.md

@@ -0,0 +1,11 @@
+### New features
+
+* [#147](https://github.com/rubocop/rubocop-minitest/issues/147): Add `EnforcedStyle` config parameter for `Minitest/GlobalExpectations`. ([@gi][])
+
+### Bug fixes
+
+* [#142](https://github.com/rubocop/rubocop-minitest/issues/142): Fix `Minitest/GlobalExpectations` autocorrect when receiver is lambda. ([@gi][])
+* [#150](https://github.com/rubocop/rubocop-minitest/issues/150): Fix a false positive for `Minitest/AssertEmpty` and `RefuteEmpty` cops when using `empty` method with any arguments. ([@koic][])
+
+[@gi]: https://github.com/gi
+[@koic]: https://github.com/koic

data/relnotes/v0.17.0.md

@@ -0,0 +1,5 @@
+### New features
+
+* [#155](https://github.com/rubocop/rubocop-minitest/issues/155): Provide `assert_offense`, `assert_correction`, and `assert_no_offenses` testing APIs for custom Minitest cop development. ([@koic][])
+
+[@koic]: https://github.com/koic

data/relnotes/v0.17.1.md

@@ -0,0 +1,5 @@
+### Changes
+
+* [#158](https://github.com/rubocop/rubocop-minitest/pull/158): Make `Minitest/UnreachableAssertion` aware of `assert` and `refute` prefix methods. ([@koic][])
+
+[@koic]: https://github.com/koic

data/rubocop-minitest.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |spec|
     '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/#{RuboCop::Minitest::Version.document_version}",
-    'bug_tracker_uri' => 'https://github.com/rubocop/rubocop-minitest/issues'
+    'bug_tracker_uri' => 'https://github.com/rubocop/rubocop-minitest/issues',
+    'rubygems_mfa_required' => 'true'
   }
 
   # Specify which files should be added to the gem when it is released.

data/tasks/changelog.rake

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+autoload :Changelog, "#{__dir__}/changelog"
+
+namespace :changelog do
+  %i[new fix change].each do |type|
+    desc "Create a Changelog entry (#{type})"
+    task type, [:id] do |_task, args|
+      ref_type = :pull if args[:id]
+      path = Changelog::Entry.new(type: type, ref_id: args[:id], ref_type: ref_type).write
+      cmd = "git add #{path}"
+      system cmd
+      puts "Entry '#{path}' created and added to git index"
+    end
+  end
+
+  desc 'Merge entries and delete them'
+  task :merge do
+    raise 'No entries!' unless Changelog.pending?
+
+    Changelog.new.merge!.and_delete!
+    cmd = "git commit -a -m 'Update Changelog'"
+    puts cmd
+    system cmd
+  end
+
+  task :check_clean do
+    next unless Changelog.pending?
+
+    puts '*** Pending changelog entries!'
+    puts 'Do `bundle exec rake changelog:merge`'
+    exit(1)
+  end
+end