rubocop-minitest 0.2.1 → 0.5.1

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Minitest
+      # This cop enforces the test to use `refute_respond_to(object, :some_method)`
+      # over `refute(object.respond_to?(:some_method))`.
+      #
+      # @example
+      #   # bad
+      #   refute(object.respond_to?(:some_method))
+      #   refute(object.respond_to?(:some_method), 'the message')
+      #   refute(respond_to?(:some_method))
+      #
+      #   # good
+      #   refute_respond_to(object, :some_method)
+      #   refute_respond_to(object, :some_method, 'the message')
+      #   refute_respond_to(self, :some_method)
+      #
+      class RefuteRespondTo < Cop
+        include ArgumentRangeHelper
+
+        MSG = 'Prefer using `refute_respond_to(%<preferred>s)` over ' \
+              '`refute(%<over>s)`.'
+
+        def_node_matcher :refute_with_respond_to, <<~PATTERN
+          (send nil? :refute $(send $_ :respond_to? $_) $...)
+        PATTERN
+
+        def on_send(node)
+          refute_with_respond_to(node) do |over, object, method, rest_args|
+            custom_message = rest_args.first
+            preferred = build_preferred_arguments(object, method, custom_message)
+            over = [over, custom_message].compact.map(&:source).join(', ')
+            message = format(MSG, preferred: preferred, over: over)
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            refute_with_respond_to(node) do |_, object, method|
+              corrector.replace(node.loc.selector, 'refute_respond_to')
+
+              object = object ? object.source : 'self'
+              replacement = [object, method.source].join(', ')
+              corrector.replace(first_argument_range(node), replacement)
+            end
+          end
+        end
+
+        private
+
+        def build_preferred_arguments(receiver, method, message)
+          receiver = receiver ? receiver.source : 'self'
+
+          [receiver, method.source, message&.source].compact.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/minitest_cops.rb

@@ -1,7 +1,18 @@
 # frozen_string_literal: true
 
+require_relative 'mixin/argument_range_helper'
 require_relative 'minitest/assert_empty'
+require_relative 'minitest/assert_empty_literal'
+require_relative 'minitest/assert_equal'
 require_relative 'minitest/assert_nil'
 require_relative 'minitest/assert_includes'
+require_relative 'minitest/assert_instance_of'
+require_relative 'minitest/assert_respond_to'
 require_relative 'minitest/assert_truthy'
+require_relative 'minitest/refute_empty'
+require_relative 'minitest/refute_false'
+require_relative 'minitest/refute_equal'
 require_relative 'minitest/refute_nil'
+require_relative 'minitest/refute_includes'
+require_relative 'minitest/refute_instance_of'
+require_relative 'minitest/refute_respond_to'

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return `Parser::Source::Ranges`.
+    module ArgumentRangeHelper
+      include RangeHelp
+
+      private
+
+      def first_argument_range(node)
+        first_argument = node.first_argument
+
+        range_between(
+          first_argument.source_range.begin_pos,
+          first_argument.source_range.end_pos
+        )
+      end
+
+      def first_and_second_arguments_range(node)
+        first_argument = node.first_argument
+        second_argument = node.arguments[1]
+
+        range_between(
+          first_argument.source_range.begin_pos,
+          second_argument.source_range.end_pos
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/minitest/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Minitest
-    VERSION = '0.2.1'
+    VERSION = '0.5.1'
   end
 end

data/manual/cops.md

@@ -2,9 +2,19 @@
 #### Department [Minitest](cops_minitest.md)
 
 * [Minitest/AssertEmpty](cops_minitest.md#minitestassertempty)
+* [Minitest/AssertEmptyLiteral](cops_minitest.md#minitestassertemptyliteral)
+* [Minitest/AssertEqual](cops_minitest.md#minitestassertequal)
 * [Minitest/AssertIncludes](cops_minitest.md#minitestassertincludes)
+* [Minitest/AssertInstanceOf](cops_minitest.md#minitestassertinstanceof)
 * [Minitest/AssertNil](cops_minitest.md#minitestassertnil)
+* [Minitest/AssertRespondTo](cops_minitest.md#minitestassertrespondto)
 * [Minitest/AssertTruthy](cops_minitest.md#minitestasserttruthy)
+* [Minitest/RefuteEmpty](cops_minitest.md#minitestrefuteempty)
+* [Minitest/RefuteEqual](cops_minitest.md#minitestrefuteequal)
+* [Minitest/RefuteFalse](cops_minitest.md#minitestrefutefalse)
+* [Minitest/RefuteIncludes](cops_minitest.md#minitestrefuteincludes)
+* [Minitest/RefuteInstanceOf](cops_minitest.md#minitestrefuteinstanceof)
 * [Minitest/RefuteNil](cops_minitest.md#minitestrefutenil)
+* [Minitest/RefuteRespondTo](cops_minitest.md#minitestrefuterespondto)
 
 <!-- END_COP_LIST -->

data/manual/cops_minitest.md

@@ -6,56 +6,126 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `assert_empty` instead of `assert(actual.empty?)`.
+This cop enforces the test to use `assert_empty`
+instead of using `assert(object.empty?)`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(actual.empty?)
-assert(actual.empty?, 'the message')
+assert(object.empty?)
+assert(object.empty?, 'the message')
 
 # good
-assert_empty(actual)
-assert_empty(actual, 'the message')
+assert_empty(object)
+assert_empty(object, 'the message')
 ```
 
 ### References
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-empty](https://github.com/rubocop-hq/minitest-style-guide#assert-empty)
 
+## Minitest/AssertEmptyLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.5 | -
+
+This cop enforces the test to use `assert_empty`
+instead of using `assert([], object)`.
+
+### Examples
+
+```ruby
+# bad
+assert([], object)
+assert({}, object)
+
+# good
+assert_empty(object)
+```
+
+## Minitest/AssertEqual
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.4 | -
+
+This cop enforces the use of `assert_equal(expected, actual)`
+over `assert(expected == actual)`.
+
+### Examples
+
+```ruby
+# bad
+assert("rubocop-minitest" == actual)
+
+# good
+assert_equal("rubocop-minitest", actual)
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-equal-arguments-order](https://github.com/rubocop-hq/minitest-style-guide#assert-equal-arguments-order)
+
 ## Minitest/AssertIncludes
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `assert_includes`
-instead of `assert(collection.includes?(actual))`.
+This cop enforces the test to use `assert_includes`
+instead of using `assert(collection.include?(object))`.
 
 ### Examples
 
 ```ruby
 # bad
-assert(collection.includes?(actual))
-assert(collection.includes?(actual), 'the message')
+assert(collection.include?(object))
+assert(collection.include?(object), 'the message')
 
 # good
-assert_includes(collection, actual)
-assert_includes(collection, actual, 'the message')
+assert_includes(collection, object)
+assert_includes(collection, object, 'the message')
 ```
 
 ### References
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-includes](https://github.com/rubocop-hq/minitest-style-guide#assert-includes)
 
+## Minitest/AssertInstanceOf
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.4 | -
+
+This cop enforces the test to use `assert_instance_of(Class, object)`
+over `assert(object.instance_of?(Class))`.
+
+### Examples
+
+```ruby
+# bad
+assert(object.instance_of?(Class))
+assert(object.instance_of?(Class), 'the message')
+
+# good
+assert_instance_of(Class, object)
+assert_instance_of(Class, object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-instance-of](https://github.com/rubocop-hq/minitest-style-guide#assert-instance-of)
+
 ## Minitest/AssertNil
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.1 | -
 
-Check if your test uses `assert_nil` instead of `assert_equal(nil, something)`.
+This cop enforces the test to use `assert_nil`
+instead of using `assert_equal(nil, something)`.
 
 ### Examples
 
@@ -73,14 +143,41 @@ assert_nil(actual, 'the message')
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-nil](https://github.com/rubocop-hq/minitest-style-guide#assert-nil)
 
+## Minitest/AssertRespondTo
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `assert_respond_to(object, :some_method)`
+over `assert(object.respond_to?(:some_method))`.
+
+### Examples
+
+```ruby
+# bad
+assert(object.respond_to?(:some_method))
+assert(object.respond_to?(:some_method), 'the message')
+assert(respond_to?(:some_method))
+
+# good
+assert_respond_to(object, :some_method)
+assert_respond_to(object, :some_method, 'the message')
+assert_respond_to(self, some_method)
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method](https://github.com/rubocop-hq/minitest-style-guide#assert-responds-to-method)
+
 ## Minitest/AssertTruthy
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `assert(actual)`
-instead of `assert_equal(true, actual)`.
+This cop enforces the test to use `assert(actual)`
+instead of using `assert_equal(true, actual)`.
 
 ### Examples
 
@@ -98,13 +195,138 @@ assert(actual, 'the message')
 
 * [https://github.com/rubocop-hq/minitest-style-guide#assert-truthy](https://github.com/rubocop-hq/minitest-style-guide#assert-truthy)
 
+## Minitest/RefuteEmpty
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces to use `refute_empty` instead of
+using `refute(object.empty?)`.
+
+### Examples
+
+```ruby
+# bad
+refute(object.empty?)
+refute(object.empty?, 'the message')
+
+# good
+refute_empty(object)
+refute_empty(object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-empty](https://github.com/rubocop-hq/minitest-style-guide#refute-empty)
+
+## Minitest/RefuteEqual
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `refute_equal(expected, object)`
+over `assert_equal(expected != actual)` or `assert(! expected == actual)`.
+
+### Examples
+
+```ruby
+# bad
+assert("rubocop-minitest" != actual)
+assert(! "rubocop-minitest" == actual)
+
+# good
+refute_equal("rubocop-minitest", actual)
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-equal](https://github.com/rubocop-hq/minitest-style-guide#refute-equal)
+
+## Minitest/RefuteFalse
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the use of `refute(object)`
+over `assert_equal(false, object)`.
+
+### Examples
+
+```ruby
+# bad
+assert_equal(false, actual)
+assert_equal(false, actual, 'the message')
+
+# good
+refute(actual)
+refute(actual, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-false](https://github.com/rubocop-hq/minitest-style-guide#refute-false)
+
+## Minitest/RefuteIncludes
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3 | -
+
+This cop enforces the test to use `refute_includes`
+instead of using `refute(collection.include?(object))`.
+
+### Examples
+
+```ruby
+# bad
+refute(collection.include?(object))
+refute(collection.include?(object), 'the message')
+
+# good
+refute_includes(collection, object)
+refute_includes(collection, object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-includes](https://github.com/rubocop-hq/minitest-style-guide#refute-includes)
+
+## Minitest/RefuteInstanceOf
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.4 | -
+
+This cop enforces the use of `refute_instance_of(Class, object)`
+over `refute(object.instance_of?(Class))`.
+
+### Examples
+
+```ruby
+# bad
+refute(object.instance_of?(Class))
+refute(object.instance_of?(Class), 'the message')
+
+# good
+refute_instance_of(Class, object)
+refute_instance_of(Class, object, 'the message')
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-instance-of](https://github.com/rubocop-hq/minitest-style-guide#refute-instance-of)
+
 ## Minitest/RefuteNil
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.2 | -
 
-Check if your test uses `refute_nil` instead of `refute_equal(nil, something)`.
+This cop enforces the test to use `refute_nil`
+instead of using `refute_equal(nil, something)`.
 
 ### Examples
 
@@ -121,3 +343,30 @@ refute_nil(actual, 'the message')
 ### References
 
 * [https://github.com/rubocop-hq/minitest-style-guide#refute-nil](https://github.com/rubocop-hq/minitest-style-guide#refute-nil)
+
+## Minitest/RefuteRespondTo
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+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))`.
+
+### Examples
+
+```ruby
+# bad
+refute(object.respond_to?(:some_method))
+refute(object.respond_to?(:some_method), 'the message')
+refute(respond_to?(:some_method))
+
+# good
+refute_respond_to(object, :some_method)
+refute_respond_to(object, :some_method, 'the message')
+refute_respond_to(self, :some_method)
+```
+
+### References
+
+* [https://github.com/rubocop-hq/minitest-style-guide#refute-respond-to](https://github.com/rubocop-hq/minitest-style-guide#refute-respond-to)