rubocop-rspec 1.15.1 → 1.16.0

data/spec/rubocop/cop/rspec/multiple_expectations_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     let(:cop_config) { {} }
 
     it 'flags multiple expectations' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         describe Foo do
           it 'uses expect twice' do
           ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -19,7 +19,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'approves of one expectation per example' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         describe Foo do
           it 'does something neat' do
             expect(neat).to be(true)
@@ -32,8 +32,44 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
       RUBY
     end
 
+    it 'flags multiple expect_any_instance_of' do
+      expect_offense(<<-RUBY)
+        describe Foo do
+          it 'uses expect_any_instance_of twice' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
+            expect_any_instance_of(Foo).to receive(:bar)
+            expect_any_instance_of(Foo).to receive(:baz)
+          end
+        end
+      RUBY
+    end
+
+    it 'flags multiple is_expected' do
+      expect_offense(<<-RUBY)
+        describe Foo do
+          it 'uses expect_any_instance_of twice' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
+            is_expected.to receive(:bar)
+            is_expected.to receive(:baz)
+          end
+        end
+      RUBY
+    end
+
+    it 'flags multiple expects with blocks' do
+      expect_offense(<<-RUBY)
+        describe Foo do
+          it 'uses expect with block twice' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
+            expect { something }.to change(Foo.count)
+            expect { something }.to change(Bar.count)
+          end
+        end
+      RUBY
+    end
+
     it 'counts aggregate_failures as one expectation' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         describe Foo do
           it 'aggregates failures' do
             aggregate_failures do
@@ -46,7 +82,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'counts every aggregate_failures as an expectation' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         describe Foo do
           it 'has multiple aggregate_failures calls' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -62,7 +98,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
 
   context 'with meta data' do
     it 'ignores examples with `:aggregate_failures`' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         describe Foo do
           it 'uses expect twice', :aggregate_failures do
             expect(foo).to eq(bar)
@@ -73,7 +109,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'ignores examples with `aggregate_failures: true`' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         describe Foo do
           it 'uses expect twice', aggregate_failures: true do
             expect(foo).to eq(bar)
@@ -84,7 +120,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'checks examples with `aggregate_failures: false`' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         describe Foo do
           it 'uses expect twice', aggregate_failures: false do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -102,7 +138,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'permits two expectations' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         describe Foo do
           it 'uses expect twice' do
             expect(foo).to eq(bar)
@@ -113,7 +149,7 @@ RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
     end
 
     it 'flags three expectations' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         describe Foo do
           it 'uses expect three times' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [3/2].

data/spec/rubocop/cop/rspec/multiple_subjects_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::MultipleSubjects do
+  let(:cop) { described_class.new }
+
+  it 'registers an offense for every overwritten subject' do
+    expect_offense(<<-RUBY)
+      describe 'hello there' do
+        subject(:foo) { 1 }
+        ^^^^^^^^^^^^^^^^^^^ Do not set more than one subject per example group
+        subject(:bar) { 2 }
+        ^^^^^^^^^^^^^^^^^^^ Do not set more than one subject per example group
+        subject { 3 }
+        ^^^^^^^^^^^^^ Do not set more than one subject per example group
+        subject(:baz) { 4 }
+
+        describe 'baz' do
+          subject(:norf) { 1 }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not try to autocorrect subject!' do
+    source = <<-RUBY
+      describe Foo do
+        subject! { a }
+        subject! { b }
+      end
+    RUBY
+
+    expect(autocorrect_source(cop, source, 'example_spec.rb')).to eql(source)
+  end
+
+  it 'does not flag shared example groups' do
+    expect_no_offenses(<<-RUBY)
+      describe Foo do
+        it_behaves_like 'user' do
+          subject { described_class.new(user, described_class) }
+
+          it { expect(subject).not_to be_accessible }
+        end
+
+        it_behaves_like 'admin' do
+          subject { described_class.new(user, described_class) }
+
+          it { expect(subject).to be_accessible }
+        end
+      end
+    RUBY
+  end
+
+  include_examples(
+    'autocorrect',
+    <<-RUBY,
+      describe 'hello there' do
+        subject(:foo) { 1 }
+        subject(:bar) { 2 }
+        subject(:baz) { 3 }
+
+        describe 'baz' do
+          subject(:norf) { 1 }
+        end
+      end
+    RUBY
+    <<-RUBY
+      describe 'hello there' do
+        let(:foo) { 1 }
+        let(:bar) { 2 }
+        subject(:baz) { 3 }
+
+        describe 'baz' do
+          subject(:norf) { 1 }
+        end
+      end
+    RUBY
+  )
+
+  include_examples(
+    'autocorrect',
+    <<-RUBY.strip_indent.chomp,
+      describe 'hello there' do
+        subject { 1 }
+        subject { 2 }
+        subject { 3 }
+      end
+    RUBY
+    [
+      "describe 'hello there' do",
+      '  ',
+      '  ',
+      '  subject { 3 }',
+      'end'
+    ].join("\n")
+  )
+end

data/spec/rubocop/cop/rspec/named_subject_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
   subject(:cop) { described_class.new }
 
   it 'checks `it` and `specify` for explicit subject usage' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         subject { described_class.new }
 
@@ -22,7 +22,7 @@ RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
   end
 
   it 'checks before and after for explicit subject usage' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         subject { described_class.new }
 
@@ -40,7 +40,7 @@ RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
   end
 
   it 'checks around(:each) for explicit subject usage' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         subject { described_class.new }
 
@@ -53,7 +53,7 @@ RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
   end
 
   it 'ignores subject when not wrapped inside a test' do
-    expect_no_violations(<<-RUBY)
+    expect_no_offenses(<<-RUBY)
       def foo
         it(subject)
       end

data/spec/rubocop/cop/rspec/nested_groups_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe RuboCop::Cop::RSpec::NestedGroups, :config do
   subject(:cop) { described_class.new(config) }
 
   it 'flags nested contexts' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       describe MyClass do
         context 'when foo' do
           context 'when bar' do
@@ -23,7 +23,7 @@ RSpec.describe RuboCop::Cop::RSpec::NestedGroups, :config do
   end
 
   it 'ignores non-spec context methods' do
-    expect_no_violations(<<-RUBY)
+    expect_no_offenses(<<-RUBY)
       class MyThingy
         context 'this is not rspec' do
           context 'but it uses contexts' do
@@ -37,7 +37,7 @@ RSpec.describe RuboCop::Cop::RSpec::NestedGroups, :config do
     let(:cop_config) { { 'Max' => '2' } }
 
     it 'flags two levels of nesting' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         describe MyClass do
           context 'when foo' do
             context 'when bar' do

data/spec/rubocop/cop/rspec/not_to_not_spec.rb

@@ -5,14 +5,14 @@ RSpec.describe RuboCop::Cop::RSpec::NotToNot, :config do
     let(:cop_config) { { 'EnforcedStyle' => 'not_to' } }
 
     it 'detects the `to_not` offense' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         it { expect(false).to_not be_true }
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to` over `to_not`.
       RUBY
     end
 
     it 'detects no offense when using `not_to`' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         it { expect(false).not_to be_true }
       RUBY
     end
@@ -26,14 +26,14 @@ RSpec.describe RuboCop::Cop::RSpec::NotToNot, :config do
     let(:cop_config) { { 'EnforcedStyle' => 'to_not' } }
 
     it 'detects the `not_to` offense' do
-      expect_violation(<<-RUBY)
+      expect_offense(<<-RUBY)
         it { expect(false).not_to be_true }
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `to_not` over `not_to`.
       RUBY
     end
 
     it 'detects no offense when using `to_not`' do
-      expect_no_violations(<<-RUBY)
+      expect_no_offenses(<<-RUBY)
         it { expect(false).to_not be_true }
       RUBY
     end

data/spec/rubocop/cop/rspec/overwriting_setup_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe RuboCop::Cop::RSpec::OverwritingSetup do
   subject(:cop) { described_class.new }
 
   it 'finds overwriten `let`' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:a) { b }
@@ -12,7 +12,7 @@ RSpec.describe RuboCop::Cop::RSpec::OverwritingSetup do
   end
 
   it 'finds overwriten `subject`' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         subject(:a) { a }
 
@@ -23,7 +23,7 @@ RSpec.describe RuboCop::Cop::RSpec::OverwritingSetup do
   end
 
   it 'finds `let!` overwriting `let`' do
-    expect_violation(<<-RUBY)
+    expect_offense(<<-RUBY)
       RSpec.describe User do
         let(:a) { b }
         let!(:a) { b }
@@ -33,7 +33,7 @@ RSpec.describe RuboCop::Cop::RSpec::OverwritingSetup do
   end
 
   it 'ignores overwriting in different context' do
-    expect_no_violations(<<-RUBY)
+    expect_no_offenses(<<-RUBY)
       RSpec.describe User do
         let(:a) { a }
 

data/spec/rubocop/cop/rspec/predicate_matcher_spec.rb

@@ -0,0 +1,335 @@
+RSpec.describe RuboCop::Cop::RSpec::PredicateMatcher, :config do
+  subject(:cop) { described_class.new(config) }
+
+  let(:cop_config) do
+    { 'EnforcedStyle' => enforced_style,
+      'Strict' => strict }
+  end
+
+  context 'when enforced style is `inflected`' do
+    let(:enforced_style) { 'inflected' }
+
+    shared_examples :inflected_common do
+      it 'registers an offense for a predicate method in actual' do
+        expect_offense(<<-RUBY)
+          expect(foo.empty?).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to_not be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to be_falsey
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.has_something?).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `have_something` matcher over `has_something?`.
+          expect(foo.include?(something)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include` matcher over `include?`.
+          expect(foo.respond_to?(:bar)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `respond_to` matcher over `respond_to?`.
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with argument' do
+        expect_offense(<<-RUBY)
+          expect(foo.something?('foo')).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+          expect(foo.something?('foo', 'bar')).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+          expect(foo.has_key?('foo')).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `have_key` matcher over `has_key?`.
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with a block' do
+        expect_offense(<<-RUBY)
+          expect(foo.all?(&:present?)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.all? { |x| x.present? }).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.all? { present }).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.something?(x) { |y| y.present? }).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+        RUBY
+      end
+
+      it 'accepts a predicate method that is not ckeced true/false' do
+        expect_no_offenses(<<-RUBY)
+          expect(foo.something?).to eq "something"
+          expect(foo.has_something?).to eq "something"
+        RUBY
+      end
+
+      it 'accepts non-predicate method' do
+        expect_no_offenses(<<-RUBY)
+          expect(foo.something).to be(true)
+          expect(foo.has_something).to be(true)
+        RUBY
+      end
+
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to be_truthy',
+                       'expect(foo).to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).not_to be_truthy',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to_not be_truthy',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to be_falsey',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).not_to be_falsey',
+                       'expect(foo).to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).not_to a_truthy_value',
+                       'expect(foo).not_to be_empty'
+
+      include_examples 'autocorrect',
+                       'expect(foo.is_a?(Array)).to be_truthy',
+                       'expect(foo).to be_a(Array)'
+
+      include_examples 'autocorrect',
+                       'expect(foo.has_something?).to be_truthy',
+                       'expect(foo).to have_something'
+      include_examples 'autocorrect',
+                       'expect(foo.has_something?).not_to be_truthy',
+                       'expect(foo).not_to have_something'
+      include_examples 'autocorrect',
+                       'expect(foo.include?(something)).to be_truthy',
+                       'expect(foo).to include(something)'
+      include_examples 'autocorrect',
+                       'expect(foo.respond_to?(:bar)).to be_truthy',
+                       'expect(foo).to respond_to(:bar)'
+
+      include_examples 'autocorrect',
+                       'expect(foo.something?()).to be_truthy',
+                       'expect(foo).to be_something()'
+      include_examples 'autocorrect',
+                       'expect(foo.something? 1, 2).to be_truthy',
+                       'expect(foo).to be_something 1, 2'
+      include_examples 'autocorrect',
+                       'expect(foo.has_key?("foo")).to be_truthy',
+                       'expect(foo).to have_key("foo")'
+      include_examples 'autocorrect',
+                       'expect(foo.something?(1, 2)).to be_truthy',
+                       'expect(foo).to be_something(1, 2)'
+
+      include_examples 'autocorrect',
+                       'expect(foo.all? { |x| x.present? }).to be_truthy',
+                       'expect(foo).to be_all { |x| x.present? }'
+      include_examples 'autocorrect',
+                       'expect(foo.all?(n) { |x| x.present? }).to be_truthy',
+                       'expect(foo).to be_all(n) { |x| x.present? }'
+      include_examples 'autocorrect',
+                       'expect(foo.all? { present }).to be_truthy',
+                       'expect(foo).to be_all { present }'
+      include_examples 'autocorrect',
+                       'expect(foo.all? { }).to be_truthy',
+                       'expect(foo).to be_all { }'
+      include_examples 'autocorrect',
+                       <<-BEFORE, <<-AFTER
+                         expect(foo.all? do |x|
+                           x + 1
+                           x >= 2
+                         end).to be_truthy
+                       BEFORE
+                         expect(foo).to be_all do |x|
+                           x + 1
+                           x >= 2
+                         end
+                       AFTER
+      include_examples 'autocorrect',
+                       'expect(foo.all? do; end).to be_truthy',
+                       'expect(foo).to be_all do; end'
+    end
+
+    context 'when strict is true' do
+      let(:strict) { true }
+
+      include_examples :inflected_common
+
+      it 'accepts strict checking boolean matcher' do
+        expect_no_offenses(<<-RUBY)
+          expect(foo.empty?).to eq(true)
+          expect(foo.empty?).to be(true)
+          expect(foo.empty?).to be(false)
+          expect(foo.empty?).not_to be true
+          expect(foo.empty?).not_to be false
+        RUBY
+      end
+    end
+
+    context 'when strict is false' do
+      let(:strict) { false }
+
+      include_examples :inflected_common
+
+      it 'registers an offense for a predicate method in actual' do
+        expect_offense(<<-RUBY)
+          expect(foo.empty?).to eq(true)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to be(true)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to be(false)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to be true
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to be false
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+        RUBY
+      end
+
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to eq(true)',
+                       'expect(foo).to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to eq(false)',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to be(true)',
+                       'expect(foo).to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).to be(false)',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).not_to be(true)',
+                       'expect(foo).not_to be_empty'
+      include_examples 'autocorrect',
+                       'expect(foo.empty?).not_to be(false)',
+                       'expect(foo).to be_empty'
+    end
+  end
+
+  context 'when enforced style is `explicit`' do
+    let(:enforced_style) { 'explicit' }
+
+    shared_examples :explicit_common do
+      it 'registers an offense for a predicate mather' do
+        expect_offense(<<-RUBY)
+          expect(foo).to be_empty
+          ^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `empty?` over `be_empty` matcher.
+          expect(foo).not_to be_empty
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `empty?` over `be_empty` matcher.
+          expect(foo).to have_something
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `has_something?` over `have_something` matcher.
+        RUBY
+      end
+
+      it 'registers an offense for a predicate mather with argument' do
+        expect_offense(<<-RUBY)
+          expect(foo).to be_something(1, 2)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).to have_key(1)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `has_key?` over `have_key` matcher.
+        RUBY
+      end
+
+      it 'registers an offense for a predicate matcher with a block' do
+        expect_offense(<<-RUBY)
+          expect(foo).to be_all(&:present?)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all { |x| x.present? }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all { present }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_something(x) { |y| y.present? }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+        RUBY
+      end
+
+      it 'accepts built in matchers' do
+        expect_no_offenses(<<-RUBY)
+          expect(foo).to be_truthy
+          expect(foo).to be_falsey
+          expect(foo).to be_falsy
+          expect(foo).to have_attributes(name: 'foo')
+          expect(foo).to have_received(:foo)
+          expect(foo).to be_between(1, 10)
+          expect(foo).to be_within(0.1).of(10.0)
+        RUBY
+      end
+
+      it 'accepts non-predicate matcher' do
+        expect_no_offenses(<<-RUBY)
+          expect(foo).to be(true)
+        RUBY
+      end
+    end
+
+    shared_examples :explicit_autocorrect do |matcher_true, matcher_false|
+      include_examples 'autocorrect',
+                       'expect(foo).to be_something',
+                       "expect(foo.something?).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).not_to be_something',
+                       "expect(foo.something?).to #{matcher_false}"
+      include_examples 'autocorrect',
+                       'expect(foo).to have_something',
+                       "expect(foo.has_something?).to #{matcher_true}"
+
+      include_examples 'autocorrect',
+                       'expect(foo).to be_a(Array)',
+                       "expect(foo.is_a?(Array)).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_instance_of(Array)',
+                       "expect(foo.instance_of?(Array)).to #{matcher_true}"
+
+      include_examples 'autocorrect',
+                       'expect(foo).to be_something()',
+                       "expect(foo.something?()).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_something(1)',
+                       "expect(foo.something?(1)).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_something(1, 2)',
+                       "expect(foo.something?(1, 2)).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_something 1, 2',
+                       "expect(foo.something? 1, 2).to #{matcher_true}"
+
+      include_examples 'autocorrect',
+                       'expect(foo).to be_all { |x| x.present? }',
+                       "expect(foo.all? { |x| x.present? }).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_all(n) { |x| x.ok? }',
+                       "expect(foo.all?(n) { |x| x.ok? }).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_all { present }',
+                       "expect(foo.all? { present }).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       'expect(foo).to be_all { }',
+                       "expect(foo.all? { }).to #{matcher_true}"
+      include_examples 'autocorrect',
+                       <<-BEFORE, <<-AFTER
+                         expect(foo).to be_all do |x|
+                           x + 1
+                           x >= 2
+                         end
+                       BEFORE
+                         expect(foo.all? do |x|
+                           x + 1
+                           x >= 2
+                         end).to #{matcher_true}
+                       AFTER
+      include_examples 'autocorrect',
+                       'expect(foo).to be_all do; end',
+                       "expect(foo.all? do; end).to #{matcher_true}"
+    end
+
+    context 'when strict is true' do
+      let(:strict) { true }
+
+      include_examples :explicit_common
+      include_examples :explicit_autocorrect, 'be(true)', 'be(false)'
+    end
+
+    context 'when strict is false' do
+      let(:strict) { false }
+
+      include_examples :explicit_common
+      include_examples :explicit_autocorrect, 'be_truthy', 'be_falsey'
+    end
+  end
+end