rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::LetSetup do
-  subject(:cop) { described_class.new }
-
-  it 'complains when let! is used and not referenced' do
-    expect_offense(<<-RUBY)
-      describe Foo do
-        let!(:foo) { bar }
-        ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
-
-        it 'does not use foo' do
-          expect(baz).to eq(qux)
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores let! when used in `before`' do
-    expect_no_offenses(<<-RUBY)
-      describe Foo do
-        let!(:foo) { bar }
-
-        before do
-          foo
-        end
-
-        it 'does not use foo' do
-          expect(baz).to eq(qux)
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores let! when used in example' do
-    expect_no_offenses(<<-RUBY)
-      describe Foo do
-        let!(:foo) { bar }
-
-        it 'uses foo' do
-          foo
-          expect(baz).to eq(qux)
-        end
-      end
-    RUBY
-  end
-
-  it 'complains when let! is used and not referenced within nested group' do
-    expect_offense(<<-RUBY)
-      describe Foo do
-        context 'when something special happens' do
-          let!(:foo) { bar }
-          ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
-
-          it 'does not use foo' do
-            expect(baz).to eq(qux)
-          end
-        end
-
-        it 'references some other foo' do
-          foo
-        end
-      end
-    RUBY
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MessageChain do
-  subject(:cop) { described_class.new }
-
-  it 'finds `receive_message_chain`' do
-    expect_offense(<<-RUBY)
-      before do
-        allow(foo).to receive_message_chain(:one, :two) { :three }
-                      ^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `receive_message_chain`.
-      end
-    RUBY
-  end
-
-  it 'finds old `stub_chain` syntax' do
-    expect_offense(<<-RUBY)
-      before do
-        foo.stub_chain(:one, :two).and_return(:three)
-            ^^^^^^^^^^ Avoid stubbing using `stub_chain`.
-      end
-    RUBY
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MessageExpectation, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is allow' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'allow' }
-    end
-
-    it 'flags expect(...).to receive' do
-      expect_offense(<<-RUBY)
-        expect(foo).to receive(:bar)
-        ^^^^^^ Prefer `allow` for setting message expectations.
-      RUBY
-    end
-
-    it 'approves of allow(...).to receive' do
-      expect_no_offenses('allow(foo).to receive(:bar)')
-    end
-
-    include_examples 'detects style', 'allow(foo).to receive(:bar)',  'allow'
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'expect'
-  end
-
-  context 'when EnforcedStyle is expect' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'expect' }
-    end
-
-    it 'flags allow(...).to receive' do
-      expect_offense(<<-RUBY)
-        allow(foo).to receive(:bar)
-        ^^^^^ Prefer `expect` for setting message expectations.
-      RUBY
-    end
-
-    it 'approves of expect(...).to receive' do
-      expect_no_offenses('expect(foo).to receive(:bar)')
-    end
-
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'expect'
-    include_examples 'detects style', 'allow(foo).to receive(:bar)',  'allow'
-  end
-end

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

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MessageSpies, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is have_received' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'have_received' }
-    end
-
-    it 'flags expect(send).to receive' do
-      expect_offense(<<-RUBY)
-        expect(foo).to receive(:bar)
-                       ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(lvar).to receive' do
-      expect_offense(<<-RUBY)
-        foo = baz
-        expect(foo).to receive(:bar)
-                       ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(ivar).to receive' do
-      expect_offense(<<-RUBY)
-        expect(@foo).to receive(:bar)
-                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `@foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(const).to receive' do
-      expect_offense(<<-RUBY)
-        expect(Foo).to receive(:bar)
-                       ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `Foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(...).not_to receive' do
-      expect_offense(<<-RUBY)
-        expect(foo).not_to receive(:bar)
-                           ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(...).to_not receive' do
-      expect_offense(<<-RUBY)
-        expect(foo).to_not receive(:bar)
-                           ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(...).to receive with' do
-      expect_offense(<<-RUBY)
-        expect(foo).to receive(:bar).with(:baz)
-                       ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'flags expect(...).to receive at_most' do
-      expect_offense(<<-RUBY)
-        expect(foo).to receive(:bar).at_most(42).times
-                       ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
-      RUBY
-    end
-
-    it 'approves of expect(...).to have_received' do
-      expect_no_offenses('expect(foo).to have_received(:bar)')
-    end
-
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'receive'
-
-    include_examples 'detects style',
-                     'expect(foo).to have_received(:bar)',
-                     'have_received'
-  end
-
-  context 'when EnforcedStyle is receive' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'receive' }
-    end
-
-    it 'flags expect(send).to have_received' do
-      expect_offense(<<-RUBY)
-        expect(foo).to have_received(:bar)
-                       ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(lvar).to have_received' do
-      expect_offense(<<-RUBY)
-        foo = baz
-        expect(foo).to have_received(:bar)
-                       ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(ivar).to have_received' do
-      expect_offense(<<-RUBY)
-        expect(@foo).to have_received(:bar)
-                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(const).to have_received' do
-      expect_offense(<<-RUBY)
-        expect(Foo).to have_received(:bar)
-                       ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(...).not_to have_received' do
-      expect_offense(<<-RUBY)
-        expect(foo).not_to have_received(:bar)
-                           ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(...).to_not have_received' do
-      expect_offense(<<-RUBY)
-        expect(foo).to_not have_received(:bar)
-                           ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(...).to have_received with' do
-      expect_offense(<<-RUBY)
-        expect(foo).to have_received(:bar).with(:baz)
-                       ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'flags expect(...).to have_received at_most' do
-      expect_offense(<<-RUBY)
-        expect(foo).to have_received(:bar).at_most(42).times
-                       ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
-      RUBY
-    end
-
-    it 'approves of expect(...).to receive' do
-      expect_no_offenses('expect(foo).to receive(:bar)')
-    end
-
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'receive'
-
-    include_examples 'detects style',
-                     'expect(foo).to have_received(:bar)',
-                     'have_received'
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MissingExampleGroupArgument do
-  subject(:cop) { described_class.new }
-
-  it 'accepts describe with an argument' do
-    expect_no_offenses(<<-RUBY)
-      describe FooClass do
-      end
-
-      RSpec.describe FooClass do
-      end
-    RUBY
-  end
-
-  it 'accepts methods with a name like an example block' do
-    expect_no_offenses(<<-RUBY)
-      Scenario.context do
-        'static'
-      end
-    RUBY
-  end
-
-  it 'checks first argument of describe' do
-    expect_offense(<<-RUBY)
-      describe do
-      ^^^^^^^^^^^ The first argument to `describe` should not be empty.
-      end
-
-      RSpec.describe do
-      ^^^^^^^^^^^^^^^^^ The first argument to `describe` should not be empty.
-      end
-    RUBY
-  end
-
-  it 'checks first argument of nested describe' do
-    expect_offense(<<-RUBY)
-      describe FooClass do
-        describe do
-        ^^^^^^^^^^^ The first argument to `describe` should not be empty.
-        end
-
-        RSpec.describe do
-        ^^^^^^^^^^^^^^^^^ The first argument to `describe` should not be empty.
-        end
-      end
-    RUBY
-  end
-
-  it 'checks first argument of context' do
-    expect_offense(<<-RUBY)
-      context do
-      ^^^^^^^^^^ The first argument to `context` should not be empty.
-      end
-    RUBY
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MultipleDescribes do
-  subject(:cop) { described_class.new }
-
-  it 'finds multiple top level describes with class and method' do
-    expect_offense(<<-RUBY)
-      describe MyClass, '.do_something' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
-      describe MyClass, '.do_something_else' do; end
-    RUBY
-  end
-
-  it 'finds multiple top level describes only with class' do
-    expect_offense(<<-RUBY)
-      describe MyClass do; end
-      ^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
-      describe MyOtherClass do; end
-    RUBY
-  end
-
-  it 'skips single top level describe' do
-    expect_no_offenses(<<-RUBY)
-      require 'spec_helper'
-
-      describe MyClass do
-      end
-    RUBY
-  end
-end

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

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'without configuration' do
-    let(:cop_config) { {} }
-
-    it 'flags multiple expectations' do
-      expect_offense(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice' do
-          ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'approves of one expectation per example' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo do
-          it 'does something neat' do
-            expect(neat).to be(true)
-          end
-
-          it 'does something cool' do
-            expect(cool).to be(true)
-          end
-        end
-      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_offenses(<<-RUBY)
-        describe Foo do
-          it 'aggregates failures' do
-            aggregate_failures do
-              expect(foo).to eq(bar)
-              expect(baz).to eq(bar)
-            end
-          end
-        end
-      RUBY
-    end
-
-    it 'counts every aggregate_failures as an expectation' do
-      expect_offense(<<-RUBY)
-        describe Foo do
-          it 'has multiple aggregate_failures calls' do
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            aggregate_failures do
-            end
-            aggregate_failures do
-            end
-          end
-        end
-      RUBY
-    end
-  end
-
-  context 'with metadata' do
-    it 'ignores examples with `:aggregate_failures`' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice', :foo, :aggregate_failures do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores example groups with `:aggregate_failures`' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo, :foo, :aggregate_failures do
-          it 'uses expect twice' do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores examples with `aggregate_failures: true`' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice', :foo, bar: 1, aggregate_failures: true do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores example groups with `aggregate_failures: true`' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo, :foo, bar: 1, aggregate_failures: true do
-          it 'uses expect twice' do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'prefers example metadata over example group metadata' do
-      expect_offense(<<-RUBY)
-        describe Foo, aggregate_failures: true do
-          it 'uses expect twice', aggregate_failures: false do
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'checks examples with `aggregate_failures: false`' do
-      expect_offense(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice', aggregate_failures: false do
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'checks example groups with `aggregate_failures: false`' do
-      expect_offense(<<-RUBY)
-        describe Foo, aggregate_failures: false do
-          it 'uses expect twice' do
-          ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'checks examples with siblings with `aggregate_failures: true`' do
-      expect_offense(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice' do
-          ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-          it 'with aggregate_failures', aggregate_failures: true do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores examples with `aggregate_failures: true` defined deeply' do
-      expect_no_offenses(<<-RUBY)
-        describe Bar, aggregate_failures: true do
-          describe Foo do
-            it 'uses expect twice' do
-              expect(foo).to eq(bar)
-              expect(baz).to eq(bar)
-            end
-            it 'with aggregate_failures', aggregate_failures: false do
-              expect(foo).to eq(bar)
-            end
-          end
-        end
-      RUBY
-    end
-  end
-
-  context 'with Max configuration' do
-    let(:cop_config) do
-      { 'Max' => '2' }
-    end
-
-    it 'permits two expectations' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice' do
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'flags three expectations' do
-      expect_offense(<<-RUBY)
-        describe Foo do
-          it 'uses expect three times' do
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [3/2].
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-            expect(qux).to eq(bar)
-          end
-        end
-      RUBY
-    end
-  end
-
-  it 'generates a todo based on the worst violation' do
-    inspect_source(<<-RUBY, 'spec/foo_spec.rb')
-      describe Foo do
-        it 'uses expect twice' do
-          expect(foo).to eq(bar)
-          expect(baz).to eq(bar)
-        end
-
-        it 'uses expect three times' do
-          expect(foo).to eq(bar)
-          expect(baz).to eq(bar)
-          expect(qux).to eq(bar)
-        end
-      end
-    RUBY
-
-    expect(cop.config_to_allow_offenses[:exclude_limit]).to eq('Max' => 3)
-  end
-end