feat: support some "predicate" assertions in RSpec/Rails/MinitestAssertions

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - Support asserts with messages in `Rspec/BeEmpty`. ([@G-Rath])
 - Add support for `assert_empty`, `assert_not_empty` and `refute_empty` to `RSpec/Rails/MinitestAssertions`. ([@ydah])
+- Support correcting some `*_predicate` assertions in `RSpec/Rails/MinitestAssertions`. ([@G-Rath])
 - Support correcting `*_match` assertions in `RSpec/Rails/MinitestAssertions`. ([@G-Rath])
 - Support correcting `*_instance_of` assertions in `RSpec/Rails/MinitestAssertions`. ([@G-Rath])
 - Support correcting `*_includes` assertions in `RSpec/Rails/MinitestAssertions`. ([@G-Rath])

lib/rubocop/cop/rspec/rails/minitest_assertions.rb

@@ -34,6 +34,8 @@ class MinitestAssertions < Base
             assert_not_instance_of
             assert_includes
             assert_not_includes
+            assert_predicate
+            assert_not_predicate
             assert_match
             assert_nil
             assert_not_nil
@@ -42,6 +44,7 @@ class MinitestAssertions < Base
             refute_equal
             refute_instance_of
             refute_includes
+            refute_predicate
             refute_nil
             refute_empty
             refute_match
@@ -62,6 +65,11 @@ class MinitestAssertions < Base
             (send nil? {:assert_includes :assert_not_includes :refute_includes} $_ $_ $_?)
           PATTERN
 
+          # @!method minitest_predicate(node)
+          def_node_matcher :minitest_predicate, <<~PATTERN
+            (send nil? {:assert_predicate :assert_not_predicate :refute_predicate} $_ ${sym} $_?)
+          PATTERN
+
           # @!method minitest_match(node)
           def_node_matcher :minitest_match, <<~PATTERN
             (send nil? {:assert_match :refute_match} $_ $_ $_?)
@@ -88,6 +96,13 @@ def on_send(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
                                                          failure_message.first))
             end
 
+            minitest_predicate(node) do |subject, predicate, failure_message|
+              next unless predicate.value.end_with?('?')
+
+              on_assertion(node, PredicateAssertion.new(predicate, subject,
+                                                        failure_message.first))
+            end
+
             minitest_includes(node) do |collection, expected, failure_message|
               on_assertion(node, IncludesAssertion.new(expected, collection,
                                                        failure_message.first))
@@ -171,6 +186,17 @@ def assertion
             end
           end
 
+          # :nodoc:
+          class PredicateAssertion < BasicAssertion
+            def negated?(node)
+              !node.method?(:assert_predicate)
+            end
+
+            def assertion
+              "be_#{@expected.delete_prefix(':').delete_suffix('?')}"
+            end
+          end
+
           # :nodoc:
           class MatchAssertion < BasicAssertion
             def negated?(node)

spec/rubocop/cop/rspec/rails/minitest_assertions_spec.rb

@@ -507,4 +507,134 @@
       RUBY
     end
   end
+
+  context 'with predicate assertions' do
+    it 'registers an offense when using `assert_predicate` with ' \
+       'an actual predicate' do
+      expect_offense(<<~RUBY)
+        assert_predicate(a, :valid?)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `expect(a).to be_valid`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).to be_valid
+      RUBY
+    end
+
+    it 'registers an offense when using `assert_predicate` with ' \
+       'an actual predicate and no parentheses' do
+      expect_offense(<<~RUBY)
+        assert_predicate a, :valid?
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `expect(a).to be_valid`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).to be_valid
+      RUBY
+    end
+
+    it 'registers an offense when using `assert_predicate` with ' \
+       'an actual predicate and a failure message' do
+      expect_offense(<<~RUBY)
+        assert_predicate a, :valid?, "must be valid"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `expect(a).to(be_valid, "must be valid")`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).to(be_valid, "must be valid")
+      RUBY
+    end
+
+    it 'registers an offense when using `assert_predicate` with ' \
+       'an actual predicate and multi-line arguments' do
+      expect_offense(<<~RUBY)
+        assert_predicate(a,
+        ^^^^^^^^^^^^^^^^^^^ Use `expect(a).to(be_valid, "must be valid")`.
+                      :valid?,
+                      "must be valid")
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).to(be_valid, "must be valid")
+      RUBY
+    end
+
+    it 'registers an offense when using `assert_not_predicate` with ' \
+       'an actual predicate' do
+      expect_offense(<<~RUBY)
+        assert_not_predicate a, :valid?
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `expect(a).not_to be_valid`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).not_to be_valid
+      RUBY
+    end
+
+    it 'registers an offense when using `refute_predicate` with ' \
+       'an actual predicate' do
+      expect_offense(<<~RUBY)
+        refute_predicate a, :valid?
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `expect(a).not_to be_valid`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(a).not_to be_valid
+      RUBY
+    end
+
+    it 'does not register an offense when using `expect(a).to be_predicate`' do
+      expect_no_offenses(<<~RUBY)
+        expect(a).to be_predicate
+      RUBY
+    end
+
+    it 'does not register an offense when using ' \
+       '`expect(a).not_to be_predicate`' do
+      expect_no_offenses(<<~RUBY)
+        expect(a).not_to be_predicate
+      RUBY
+    end
+
+    it 'does not register an offense when using `assert_predicate` with ' \
+       'not a predicate' do
+      expect_no_offenses(<<~RUBY)
+        assert_predicate foo, :do_something
+      RUBY
+    end
+
+    it 'does not register an offense when using `assert_not_predicate` with ' \
+       'not a predicate' do
+      expect_no_offenses(<<~RUBY)
+        assert_not_predicate foo, :do_something
+      RUBY
+    end
+
+    it 'does not register an offense when using `refute_predicate` with ' \
+       'not a predicate' do
+      expect_no_offenses(<<~RUBY)
+        refute_predicate foo, :do_something
+      RUBY
+    end
+
+    it 'does not register an offense when the predicate is not a symbol' do
+      expect_no_offenses(<<~RUBY)
+        assert_predicate a, 1
+      RUBY
+    end
+
+    it 'does not register an offense when the predicate is missing' do
+      expect_no_offenses(<<~RUBY)
+        assert_predicate a, "whoops, we forgot about the actual predicate!"
+      RUBY
+    end
+
+    it 'does not register an offense when the predicate is a variable' do
+      expect_no_offenses(<<~RUBY)
+        foo = :foo?
+
+        assert_predicate a, foo
+      RUBY
+    end
+  end
 end