rubocop-rspec 1.7.0 → 3.0.2

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::LetSetup do
-  subject(:cop) { described_class.new }
-
-  it 'complains when let! is used and not referenced' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        let!(:foo) { bar }
-        ^^^^^^^^^^ Do not use `let!` for test setup.
-
-        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_violations(<<-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_violations(<<-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_violation(<<-RUBY)
-      describe Foo do
-        context 'when something special happens' do
-          let!(:foo) { bar }
-          ^^^^^^^^^^ Do not use `let!` for test setup.
-
-          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,21 +0,0 @@
-describe RuboCop::Cop::RSpec::MessageChain do
-  subject(:cop) { described_class.new }
-
-  it 'finds `receive_message_chain`' do
-    expect_violation(<<-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_violation(<<-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,63 +0,0 @@
-# frozen_string_literal: true
-
-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_violation(<<-RUBY)
-        expect(foo).to receive(:bar)
-        ^^^^^^ Prefer `allow` for setting message expectations.
-      RUBY
-    end
-
-    it 'approves of allow(...).to receive' do
-      expect_no_violations('allow(foo).to receive(:bar)')
-    end
-
-    it 'generates a todo based on the usage of the correct style' do
-      inspect_source(cop, 'allow(foo).to receive(:bar)', 'foo_spec.rb')
-
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'allow')
-    end
-
-    it 'generates a todo based on the usage of the alternate style' do
-      inspect_source(cop, 'expect(foo).to receive(:bar)', 'foo_spec.rb')
-
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'expect')
-    end
-  end
-
-  context 'when EnforcedStyle is expect' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'expect' }
-    end
-
-    it 'flags allow(...).to receive' do
-      expect_violation(<<-RUBY)
-        allow(foo).to receive(:bar)
-        ^^^^^ Prefer `expect` for setting message expectations.
-      RUBY
-    end
-
-    it 'approves of expect(...).to receive' do
-      expect_no_violations('expect(foo).to receive(:bar)')
-    end
-
-    it 'generates a todo based on the usage of the correct style' do
-      inspect_source(cop, 'expect(foo).to receive(:bar)', 'foo_spec.rb')
-
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'expect')
-    end
-
-    it 'generates a todo based on the usage of the alternate style' do
-      inspect_source(cop, 'allow(foo).to receive(:bar)', 'foo_spec.rb')
-
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'allow')
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-describe RuboCop::Cop::RSpec::MultipleDescribes do
-  subject(:cop) { described_class.new }
-
-  it 'finds multiple top level describes with class and method' do
-    expect_violation(<<-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_violation(<<-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_violations(<<-RUBY)
-      require 'spec_helper'
-
-      describe MyClass do
-      end
-    RUBY
-  end
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'without configuration' do
-    let(:cop_config) { Hash.new }
-
-    it 'flags multiple expectations' do
-      expect_violation(<<-RUBY)
-        describe Foo do
-          it 'uses expect twice' do
-          ^^^^^^^^^^^^^^^^^^^^^^ Too many expectations.
-            expect(foo).to eq(bar)
-            expect(baz).to eq(bar)
-          end
-        end
-      RUBY
-    end
-
-    it 'approves of one expectation per example' do
-      expect_no_violations(<<-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
-  end
-
-  context 'with configuration' do
-    let(:cop_config) do
-      { 'Max' => '2' }
-    end
-
-    it 'permits two expectations' do
-      expect_no_violations(<<-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_violation(<<-RUBY)
-        describe Foo do
-          it 'uses expect three times' do
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Too many expectations.
-            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(cop, <<-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).to eq('Max' => 3)
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-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)
-      RSpec.describe User do
-        subject { described_class.new }
-
-        it "is valid" do
-          expect(subject.valid?).to be(true)
-                 ^^^^^^^ Name your test subject if you need to reference it explicitly.
-        end
-
-        specify do
-          expect(subject.valid?).to be(true)
-                 ^^^^^^^ Name your test subject if you need to reference it explicitly.
-        end
-      end
-    RUBY
-  end
-
-  it 'checks before and after for explicit subject usage' do
-    expect_violation(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-
-        before(:each) do
-          do_something_with(subject)
-                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
-        end
-
-        after do
-          do_something_with(subject)
-                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
-        end
-      end
-    RUBY
-  end
-
-  it 'checks around(:each) for explicit subject usage' do
-    expect_violation(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-
-        around(:each) do |test|
-          do_something_with(subject)
-                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores subject when not wrapped inside a test' do
-    expect_no_violations(<<-RUBY)
-      def foo
-        it(subject)
-      end
-    RUBY
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::NestedGroups, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'flags nested contexts' do
-    expect_violation(<<-RUBY)
-      describe MyClass do
-        context 'when foo' do
-          context 'when bar' do
-          ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded
-            context 'when baz' do
-            ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded
-            end
-          end
-        end
-
-        context 'when qux' do
-          context 'when norf' do
-          ^^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores non-spec context methods' do
-    expect_no_violations(<<-RUBY)
-      class MyThingy
-        context 'this is not rspec' do
-          context 'but it uses contexts' do
-          end
-        end
-      end
-    RUBY
-  end
-
-  context 'when MaxNesting is configured as 2' do
-    let(:cop_config) { { 'MaxNesting' => '3' } }
-
-    it 'only flags third level of nesting' do
-      expect_violation(<<-RUBY)
-        describe MyClass do
-          context 'when foo' do
-            context 'when bar' do
-              context 'when baz' do
-              ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded
-              end
-            end
-          end
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-describe RuboCop::Cop::RSpec::NotToNot, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is `not_to`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'not_to' } }
-
-    it 'detects the `to_not` offense' do
-      expect_violation(<<-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)
-        it { expect(false).not_to be_true }
-      RUBY
-    end
-
-    it 'auto-corrects `to_not` to `not_to`' do
-      corrected =
-        autocorrect_source(
-          cop,
-          ['it { expect(0).to_not equal 1 }'],
-          'spec/foo_spec.rb'
-        )
-      expect(corrected).to eq 'it { expect(0).not_to equal 1 }'
-    end
-  end
-
-  context 'when AcceptedMethod is `to_not`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'to_not' } }
-
-    it 'detects the `not_to` offense' do
-      expect_violation(<<-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)
-        it { expect(false).to_not be_true }
-      RUBY
-    end
-
-    it 'auto-corrects `not_to` to `to_not`' do
-      corrected =
-        autocorrect_source(
-          cop,
-          ['it { expect(0).not_to equal 1 }'],
-          'spec/foo_spec.rb'
-        )
-      expect(corrected).to eq 'it { expect(0).to_not equal 1 }'
-    end
-  end
-end

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

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::SubjectStub do
-  subject(:cop) { described_class.new }
-
-  it 'complains when subject is stubbed' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        before do
-          allow(foo).to receive(:bar).and_return(baz)
-          ^^^^^^^^^^ Do not stub your test subject.
-        end
-
-        it 'uses expect twice' do
-          expect(foo.bar).to eq(baz)
-        end
-      end
-    RUBY
-  end
-
-  it 'complains when subject is mocked' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        before do
-          expect(foo).to receive(:bar).and_return(baz)
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub your test subject.
-          expect(foo).to receive(:bar)
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub your test subject.
-          expect(foo).to receive(:bar).with(1)
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub your test subject.
-          expect(foo).to receive(:bar).with(1).and_return(2)
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub your test subject.
-        end
-
-        it 'uses expect twice' do
-          expect(foo.bar).to eq(baz)
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores stub within context where subject name changed' do
-    expect_no_violations(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I shake things up' do
-          subject(:bar) { described_class.new }
-
-          it 'tries to trick rubocop-rspec' do
-            allow(foo).to receive(:baz)
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'flags nested subject stubs when nested subject uses same name' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I shake things up' do
-          subject(:foo) { described_class.new }
-
-          before do
-            allow(foo).to receive(:wow)
-            ^^^^^^^^^^ Do not stub your test subject.
-          end
-
-          it 'tries to trick rubocop-rspec' do
-            expect(foo).to eql(:neat)
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores nested stubs when nested subject is anonymous' do
-    expect_no_violations(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I shake things up' do
-          subject { described_class.new }
-
-          before do
-            allow(foo).to receive(:wow)
-          end
-
-          it 'tries to trick rubocop-rspec' do
-            expect(foo).to eql(:neat)
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'flags nested subject stubs when example group does not define subject' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I shake things up' do
-          before do
-            allow(foo).to receive(:wow)
-            ^^^^^^^^^^ Do not stub your test subject.
-          end
-
-          it 'tries to trick rubocop-rspec' do
-            expect(foo).to eql(:neat)
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'flags nested subject stubs' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I shake things up' do
-          subject(:bar) { described_class.new }
-
-          before do
-            allow(foo).to receive(:wow)
-            allow(bar).to receive(:wow)
-            ^^^^^^^^^^ Do not stub your test subject.
-          end
-
-          it 'tries to trick rubocop-rspec' do
-            expect(bar).to eql(foo)
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'flags nested subject stubs when adjacent context redefines' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'when I do something in a context' do
-          subject { blah }
-        end
-
-        it 'still flags this test' do
-          allow(foo).to receive(:blah)
-          ^^^^^^^^^^ Do not stub your test subject.
-        end
-      end
-    RUBY
-  end
-
-  it 'flags deeply nested subject stubs' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        subject(:foo) { described_class.new }
-
-        context 'level 1' do
-          subject(:bar) { described_class.new }
-
-          context 'level 2' do
-            subject(:baz) { described_class.new }
-
-            before do
-              allow(foo).to receive(:wow)
-              allow(bar).to receive(:wow)
-              allow(baz).to receive(:wow)
-              ^^^^^^^^^^ Do not stub your test subject.
-            end
-          end
-        end
-      end
-    RUBY
-  end
-end

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

@@ -1,71 +0,0 @@
-describe RuboCop::Cop::RSpec::VerifiedDoubles, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'finds a `double` instead of an `instance_double`' do
-    expect_violation(<<-RUBY)
-      it do
-        foo = double("Widget")
-              ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-      end
-    RUBY
-  end
-
-  context 'when configuration does not specify IgnoreSymbolicNames' do
-    let(:cop_config) { Hash.new }
-
-    it 'find doubles whose name is a symbol' do
-      expect_violation(<<-RUBY)
-        it do
-          foo = double(:widget)
-                ^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-
-    it 'finds a `spy` instead of an `instance_spy`' do
-      expect_violation(<<-RUBY)
-        it do
-          foo = spy("Widget")
-                ^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-  end
-
-  context 'when configured to ignore symbolic names' do
-    let(:cop_config) { { 'IgnoreSymbolicNames' => true } }
-
-    it 'ignores doubles whose name is a symbol' do
-      expect_no_violations(<<-RUBY)
-        it do
-          foo = double(:widget)
-        end
-      RUBY
-    end
-
-    it 'still flags doubles whose name is a string' do
-      expect_violation(<<-RUBY)
-        it do
-          foo = double("widget")
-                ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-  end
-
-  it 'ignores doubles without a name' do
-    expect_no_violations(<<-RUBY)
-      it do
-        foo = double
-      end
-    RUBY
-  end
-
-  it 'ignores instance_doubles' do
-    expect_no_violations(<<-RUBY)
-      it do
-        foo = instance_double("Foo")
-      end
-    RUBY
-  end
-end