rubocop-minitest 0.9.0 → 0.10.0

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/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_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

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

@@ -72,11 +72,9 @@ module RuboCop
             receiver = node.receiver.source_range
 
             if BLOCK_MATCHERS.include?(node.method_name)
-              corrector.insert_before(receiver, '_ { ')
-              corrector.insert_after(receiver, ' }')
+              corrector.wrap(receiver, '_ { ', ' }')
             else
-              corrector.insert_before(receiver, '_(')
-              corrector.insert_after(receiver, ')')
+              corrector.wrap(receiver, '_(', ')')
             end
           end
         end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces correct order of expected and
+      # actual arguments for `assert_equal`.
+      #
+      # @example
+      #   # bad
+      #   assert_equal foo, 2
+      #   assert_equal foo, [1, 2]
+      #   assert_equal foo, [1, 2], 'message'
+      #
+      #   # good
+      #   assert_equal 2, foo
+      #   assert_equal [1, 2], foo
+      #   assert_equal [1, 2], foo, 'message'
+      #
+      class LiteralAsActualArgument < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Replace the literal with the first argument.'
+
+        def on_send(node)
+          return unless node.method?(:assert_equal)
+
+          actual = node.arguments[1]
+          return unless actual
+
+          add_offense(node, location: all_arguments_range(node)) if actual.recursive_basic_literal?
+        end
+
+        def autocorrect(node)
+          expected, actual, message = *node.arguments
+
+          lambda do |corrector|
+            new_actual_source =
+              if actual.hash_type? && !actual.braces?
+                "{#{actual.source}}"
+              else
+                actual.source
+              end
+            arguments = [new_actual_source, expected.source, message&.source].compact.join(', ')
+
+            corrector.replace(node, "assert_equal(#{arguments})")
+          end
+        end
+      end
+    end
+  end
+end