rubocop-minitest 0.6.2 → 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/{manual → legacy-docs}/cops.md

@@ -10,6 +10,7 @@
 * [Minitest/AssertNil](cops_minitest.md#minitestassertnil)
 * [Minitest/AssertRespondTo](cops_minitest.md#minitestassertrespondto)
 * [Minitest/AssertTruthy](cops_minitest.md#minitestasserttruthy)
+* [Minitest/GlobalExpectations](cops_minitest.md#minitestglobalexpectations)
 * [Minitest/RefuteEmpty](cops_minitest.md#minitestrefuteempty)
 * [Minitest/RefuteEqual](cops_minitest.md#minitestrefuteequal)
 * [Minitest/RefuteFalse](cops_minitest.md#minitestrefutefalse)

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

@@ -14,11 +14,11 @@ instead of using `assert(object.empty?)`.
 ```ruby
 # bad
 assert(object.empty?)
-assert(object.empty?, 'the message')
+assert(object.empty?, 'message')
 
 # good
 assert_empty(object)
-assert_empty(object, 'the message')
+assert_empty(object, 'message')
 ```
 
 ### References
@@ -82,11 +82,11 @@ instead of using `assert(collection.include?(object))`.
 ```ruby
 # bad
 assert(collection.include?(object))
-assert(collection.include?(object), 'the message')
+assert(collection.include?(object), 'message')
 
 # good
 assert_includes(collection, object)
-assert_includes(collection, object, 'the message')
+assert_includes(collection, object, 'message')
 ```
 
 ### References
@@ -107,11 +107,11 @@ over `assert(object.instance_of?(Class))`.
 ```ruby
 # bad
 assert(object.instance_of?(Class))
-assert(object.instance_of?(Class), 'the message')
+assert(object.instance_of?(Class), 'message')
 
 # good
 assert_instance_of(Class, object)
-assert_instance_of(Class, object, 'the message')
+assert_instance_of(Class, object, 'message')
 ```
 
 ### References
@@ -132,11 +132,11 @@ instead of using `assert(matcher.match(string))`.
 ```ruby
 # bad
 assert(matcher.match(string))
-assert(matcher.match(string), 'the message')
+assert(matcher.match(string), 'message')
 
 # good
 assert_match(regex, string)
-assert_match(matcher, string, 'the message')
+assert_match(matcher, string, 'message')
 ```
 
 ### References
@@ -157,11 +157,11 @@ instead of using `assert_equal(nil, something)`.
 ```ruby
 # bad
 assert_equal(nil, actual)
-assert_equal(nil, actual, 'the message')
+assert_equal(nil, actual, 'message')
 
 # good
 assert_nil(actual)
-assert_nil(actual, 'the message')
+assert_nil(actual, 'message')
 ```
 
 ### References
@@ -174,21 +174,21 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.3 | -
 
-This cop enforces the use of `assert_respond_to(object, :some_method)`
-over `assert(object.respond_to?(:some_method))`.
+This cop enforces the use of `assert_respond_to(object, :do_something)`
+over `assert(object.respond_to?(:do_something))`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(object.respond_to?(:some_method))
-assert(object.respond_to?(:some_method), 'the message')
-assert(respond_to?(:some_method))
+assert(object.respond_to?(:do_something))
+assert(object.respond_to?(:do_something), 'message')
+assert(respond_to?(:do_something))
 
 # good
-assert_respond_to(object, :some_method)
-assert_respond_to(object, :some_method, 'the message')
-assert_respond_to(self, some_method)
+assert_respond_to(object, :do_something)
+assert_respond_to(object, :do_something, 'message')
+assert_respond_to(self, :do_something)
 ```
 
 ### References
@@ -209,17 +209,40 @@ instead of using `assert_equal(true, actual)`.
 ```ruby
 # bad
 assert_equal(true, actual)
-assert_equal(true, actual, 'the message')
+assert_equal(true, actual, 'message')
 
 # good
 assert(actual)
-assert(actual, 'the message')
+assert(actual, 'message')
 ```
 
 ### References
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-truthy](https://github.com/rubocop-hq/minitest-style-guide#assert-truthy)
 
+## Minitest/GlobalExpectations
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.7 | -
+
+This cop checks for deprecated global expectations
+and autocorrects them to use expect format.
+
+### Examples
+
+```ruby
+# 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
+```
+
 ## Minitest/RefuteEmpty
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -234,11 +257,11 @@ using `refute(object.empty?)`.
 ```ruby
 # bad
 refute(object.empty?)
-refute(object.empty?, 'the message')
+refute(object.empty?, 'message')
 
 # good
 refute_empty(object)
-refute_empty(object, 'the message')
+refute_empty(object, 'message')
 ```
 
 ### References
@@ -283,14 +306,14 @@ over `assert_equal(false, object)`.
 ```ruby
 # bad
 assert_equal(false, actual)
-assert_equal(false, actual, 'the message')
+assert_equal(false, actual, 'message')
 
 assert(!test)
-assert(!test, 'the message')
+assert(!test, 'message')
 
 # good
 refute(actual)
-refute(actual, 'the message')
+refute(actual, 'message')
 ```
 
 ### References
@@ -311,11 +334,11 @@ instead of using `refute(collection.include?(object))`.
 ```ruby
 # bad
 refute(collection.include?(object))
-refute(collection.include?(object), 'the message')
+refute(collection.include?(object), 'message')
 
 # good
 refute_includes(collection, object)
-refute_includes(collection, object, 'the message')
+refute_includes(collection, object, 'message')
 ```
 
 ### References
@@ -336,11 +359,11 @@ over `refute(object.instance_of?(Class))`.
 ```ruby
 # bad
 refute(object.instance_of?(Class))
-refute(object.instance_of?(Class), 'the message')
+refute(object.instance_of?(Class), 'message')
 
 # good
 refute_instance_of(Class, object)
-refute_instance_of(Class, object, 'the message')
+refute_instance_of(Class, object, 'message')
 ```
 
 ### References
@@ -361,11 +384,11 @@ instead of using `refute(matcher.match(string))`.
 ```ruby
 # bad
 refute(matcher.match(string))
-refute(matcher.match(string), 'the message')
+refute(matcher.match(string), 'message')
 
 # good
 refute_match(matcher, string)
-refute_match(matcher, string, 'the message')
+refute_match(matcher, string, 'message')
 ```
 
 ### References
@@ -386,11 +409,11 @@ instead of using `refute_equal(nil, something)`.
 ```ruby
 # bad
 refute_equal(nil, actual)
-refute_equal(nil, actual, 'the message')
+refute_equal(nil, actual, 'message')
 
 # good
 refute_nil(actual)
-refute_nil(actual, 'the message')
+refute_nil(actual, 'message')
 ```
 
 ### References
@@ -403,21 +426,21 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.4 | -
 
-This cop enforces the test to use `refute_respond_to(object, :some_method)`
-over `refute(object.respond_to?(:some_method))`.
+This cop enforces the test to use `refute_respond_to(object, :do_something)`
+over `refute(object.respond_to?(:do_something))`.
 
 ### Examples
 
 ```ruby
 # bad
-refute(object.respond_to?(:some_method))
-refute(object.respond_to?(:some_method), 'the message')
-refute(respond_to?(:some_method))
+refute(object.respond_to?(:do_something))
+refute(object.respond_to?(:do_something), 'message')
+refute(respond_to?(:do_something))
 
 # good
-refute_respond_to(object, :some_method)
-refute_respond_to(object, :some_method, 'the message')
-refute_respond_to(self, :some_method)
+refute_respond_to(object, :do_something)
+refute_respond_to(object, :do_something, 'message')
+refute_respond_to(self, :do_something)
 ```
 
 ### References

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.rb

@@ -9,42 +9,16 @@ module RuboCop
       # @example
       #   # bad
       #   assert(object.empty?)
-      #   assert(object.empty?, 'the message')
+      #   assert(object.empty?, 'message')
       #
       #   # good
       #   assert_empty(object)
-      #   assert_empty(object, 'the message')
+      #   assert_empty(object, 'message')
       #
       class AssertEmpty < Cop
-        include ArgumentRangeHelper
+        extend MinitestCopRule
 
-        MSG = 'Prefer using `assert_empty(%<arguments>s)` over ' \
-              '`assert(%<receiver>s)`.'
-
-        def_node_matcher :assert_with_empty, <<~PATTERN
-          (send nil? :assert $(send $_ :empty?) $...)
-        PATTERN
-
-        def on_send(node)
-          assert_with_empty(node) do |first_receiver_arg, actual, rest_receiver_arg|
-            message = rest_receiver_arg.first
-
-            arguments = [actual.source, message&.source].compact.join(', ')
-            receiver = [first_receiver_arg.source, message&.source].compact.join(', ')
-
-            offense_message = format(MSG, arguments: arguments, receiver: receiver)
-            add_offense(node, message: offense_message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            assert_with_empty(node) do |_, actual_arg|
-              corrector.replace(node.loc.selector, 'assert_empty')
-              corrector.replace(first_argument_range(node), actual_arg.source)
-            end
-          end
-        end
+        define_rule :assert, target_method: :empty?
       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