rubocop-minitest 0.7.0 → 0.10.1

data/docs/modules/ROOT/pages/index.adoc

@@ -0,0 +1,5 @@
+= RuboCop Minitest
+
+A https://github.com/rubocop-hq/rubocop[RuboCop] extension focused on enforcing Minitest best practices and coding conventions.
+
+It's based on the community-driven https://minitest.rubystyle.guide[Minitest style guide].

data/docs/modules/ROOT/pages/installation.adoc

@@ -0,0 +1,15 @@
+= Installation
+
+Just install the `rubocop-minitest` gem
+
+[source,sh]
+----
+gem install rubocop-minitest
+----
+
+or if you use bundler put this in your `Gemfile`
+
+[source,ruby]
+----
+gem 'rubocop-minitest'
+----

data/docs/modules/ROOT/pages/usage.adoc

@@ -0,0 +1,32 @@
+= Usage
+
+You need to tell RuboCop to load the Minitest extension. There are three
+ways to do this:
+
+== RuboCop configuration file
+
+Put this into your `.rubocop.yml`.
+
+[source,yaml]
+----
+require: rubocop-minitest
+----
+
+Now you can run `rubocop` and it will automatically load the RuboCop Minitest
+cops together with the standard cops.
+
+== Command line
+
+[source,sh]
+----
+rubocop --require rubocop-minitest
+----
+
+== Rake task
+
+[source,ruby]
+----
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-minitest'
+end
+----

data/{manual → legacy-docs}/cops_minitest.md

@@ -226,19 +226,21 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.7 | -
 
-This Cop checks for deprecated global expectations
+This cop checks for deprecated global expectations
 and autocorrects them to use expect format.
 
 ### Examples
 
 ```ruby
 # bad
-n.must_equal 42
-n.wont_match b
+musts.must_equal expected_musts
+wonts.wont_match expected_wonts
+musts.must_raise TypeError
 
 # good
-_(n).must_equal 42
-_(n).wont_match b
+_(musts).must_equal expected_musts
+_(wonts).wont_match expected_wonts
+_ { musts }.must_raise TypeError
 ```
 
 ## Minitest/RefuteEmpty

data/lib/rubocop/cop/generator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Source and test generator for new cops
+    #
+    # This generator will take a cop name and generate a source file
+    # and test file when given a valid qualified cop name.
+    class Generator
+      TEST_TEMPLATE = <<~TEST
+        # frozen_string_literal: true
+
+        require 'test_helper'
+
+        class %<cop_name>sTest < Minitest::Test
+          def test_registers_offense_when_using_bad_method
+            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_when_using_good_method
+            assert_no_offenses(<<~RUBY)
+              good_method
+            RUBY
+          end
+        end
+      TEST
+
+      def write_test
+        write_unless_file_exists(test_path, generated_test)
+      end
+
+      private
+
+      def test_path
+        File.join(
+          'test',
+          'rubocop',
+          'cop',
+          'minitest',
+          "#{snake_case(badge.cop_name.to_s)}_test.rb"
+        )
+      end
+
+      def generated_test
+        generate(TEST_TEMPLATE)
+      end
+    end
+  end
+end

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

@@ -15,6 +15,8 @@ module RuboCop
       #   assert_empty(object)
       #
       class AssertEmptyLiteral < Cop
+        include ArgumentRangeHelper
+
         MSG = 'Prefer using `assert_empty(%<arguments>s)` over ' \
               '`assert(%<literal>s, %<arguments>s)`.'
 
@@ -24,12 +26,25 @@ module RuboCop
 
         def on_send(node)
           assert_with_empty_literal(node) do |literal, matchers|
+            return unless literal.values.empty?
+
             args = matchers.map(&:source).join(', ')
 
             message = format(MSG, literal: literal.source, arguments: args)
             add_offense(node, message: message)
           end
         end
+
+        def autocorrect(node)
+          assert_with_empty_literal(node) do |_literal, matchers|
+            object = matchers.first
+
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, 'assert_empty')
+              corrector.replace(first_and_second_arguments_range(node), object.source)
+            end
+          end
+        end
       end
     end
   end

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

@@ -14,38 +14,9 @@ module RuboCop
       #   assert_equal("rubocop-minitest", actual)
       #
       class AssertEqual < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_equal(%<preferred>s)` over ' \
-              '`assert(%<over>s)`.'
-
-        def_node_matcher :assert_equal, <<~PATTERN
-          (send nil? :assert $(send $_ :== $_) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_equal(node) do |first_receiver_arg, expected, actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
-            preferred = [expected.source, actual.source, message&.source]
-                        .compact.join(', ')
-            over = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, preferred: preferred, over: over)
-
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            assert_equal(node) do |_, expected, actual|
-              corrector.replace(node.loc.selector, 'assert_equal')
-
-              replacement = [expected, actual].map(&:source).join(', ')
-              corrector.replace(first_argument_range(node), replacement)
-            end
-          end
-        end
+        define_rule :assert, target_method: :==, preferred_method: :assert_equal
       end
     end
   end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_in_delta`
+      # instead of using `assert_equal` to compare floats.
+      #
+      # @example
+      #   # bad
+      #   assert_equal(0.2, actual)
+      #   assert_equal(0.2, actual, 'message')
+      #
+      #   # good
+      #   assert_in_delta(0.2, actual)
+      #   assert_in_delta(0.2, actual, 0.001, 'message')
+      #
+      class AssertInDelta < Cop
+        include InDeltaMixin
+
+        def_node_matcher :equal_floats_call, <<~PATTERN
+          (send nil? :assert_equal $_ $_ $...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_kind_of(Class, object)`
+      # over `assert(object.kind_of?(Class))`.
+      #
+      # @example
+      #   # bad
+      #   assert(object.kind_of?(Class))
+      #   assert(object.kind_of?(Class), 'message')
+      #
+      #   # good
+      #   assert_kind_of(Class, object)
+      #   assert_kind_of(Class, object, 'message')
+      #
+      class AssertKindOf < Cop
+        extend MinitestCopRule
+
+        define_rule :assert, target_method: :kind_of?, inverse: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for opportunities to use `assert_output`.
+      #
+      # @example
+      #   # bad
+      #   $stdout = StringIO.new
+      #   puts object.method
+      #   $stdout.rewind
+      #   assert_match expected, $stdout.read
+      #
+      #   # good
+      #   assert_output(expected) { puts object.method }
+      #
+      class AssertOutput < Cop
+        include MinitestExplorationHelpers
+
+        MSG = 'Use `assert_output` instead of mutating %<name>s.'
+        OUTPUT_GLOBAL_VARIABLES = %i[$stdout $stderr].freeze
+
+        def on_gvasgn(node)
+          test_case_node = find_test_case(node)
+          return unless test_case_node
+
+          gvar_name = node.children.first
+          return unless OUTPUT_GLOBAL_VARIABLES.include?(gvar_name)
+
+          assertions(test_case_node).each do |assertion|
+            add_offense(assertion, message: format(MSG, name: gvar_name)) if references_gvar?(assertion, gvar_name)
+          end
+        end
+
+        private
+
+        def find_test_case(node)
+          def_ancestor = node.each_ancestor(:def).first
+          def_ancestor if test_case?(def_ancestor)
+        end
+
+        def references_gvar?(assertion, gvar_name)
+          assertion.each_descendant(:gvar).any? { |d| d.children.first == gvar_name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_path_exists`
+      # instead of using `assert(File.exist?(path))`.
+      #
+      # @example
+      #   # bad
+      #   assert(File.exist?(path))
+      #   assert(File.exist?(path), 'message')
+      #
+      #   # good
+      #   assert_path_exists(path)
+      #   assert_path_exists(path, 'message')
+      #
+      class AssertPathExists < Cop
+        MSG = 'Prefer using `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :assert_file_exists, <<~PATTERN
+          (send nil? :assert
+            (send
+              (const _ :File) {:exist? :exists?} $_)
+              $...)
+        PATTERN
+
+        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)
+            message = format(MSG, good_method: good_method, bad_method: node.source)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          assert_file_exists(node) do |path, failure_message|
+            failure_message = failure_message.first
+
+            lambda do |corrector|
+              replacement = build_good_method(path, failure_message)
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def build_good_method(path, message)
+          args = [path.source, message&.source].compact.join(', ')
+          "assert_path_exists(#{args})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `assert_silent { ... }`
+      # instead of using `assert_output('', '') { ... }`.
+      #
+      # @example
+      #   # bad
+      #   assert_output('', '') { puts object.do_something }
+      #
+      #   # good
+      #   assert_silent { puts object.do_something }
+      #
+      class AssertSilent < Cop
+        MSG = 'Prefer using `assert_silent` over `assert_output("", "")`.'
+
+        def_node_matcher :assert_silent_candidate?, <<~PATTERN
+          (block
+            (send nil? :assert_output
+              #empty_string?
+              #empty_string?)
+            ...)
+        PATTERN
+
+        def on_block(node)
+          add_offense(node.send_node) if assert_silent_candidate?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, 'assert_silent')
+          end
+        end
+
+        private
+
+        def empty_string?(node)
+          node.str_type? && node.value.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop checks for usage of assertions in lifecycle hooks.
+      #
+      # @example
+      #   # bad
+      #   class FooTest < Minitest::Test
+      #     def setup
+      #       assert_equal(foo, bar)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class FooTest < Minitest::Test
+      #     def test_something
+      #       assert_equal(foo, bar)
+      #     end
+      #   end
+      #
+      class AssertionInLifecycleHook < Cop
+        include MinitestExplorationHelpers
+
+        MSG = 'Do not use `%<assertion>s` in `%<hook>s` hook.'
+
+        def on_class(class_node)
+          return unless test_class?(class_node)
+
+          lifecycle_hooks(class_node).each do |hook_node|
+            hook_node.each_descendant(:send) do |node|
+              if assertion?(node)
+                message = format(MSG, assertion: node.method_name, hook: hook_node.method_name)
+                add_offense(node, message: message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end