rubocop-rspec 1.6.0 → 1.7.0

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

@@ -35,4 +35,41 @@ describe RuboCop::Cop::RSpec::InstanceVariable do
       @foo.empty?
     RUBY
   end
+
+  # Regression test for nevir/rubocop-rspec#115
+  it 'ignores instance variables outside of specs' do
+    expect_no_violations(<<-RUBY, filename: 'lib/source_code.rb')
+      feature do
+        @foo = bar
+
+        @foo
+      end
+    RUBY
+  end
+
+  context 'when configured with AssignmentOnly', :config do
+    subject(:cop) { described_class.new(config) }
+
+    let(:cop_config) do
+      { 'AssignmentOnly' => true }
+    end
+
+    it 'flags an instance variable when it is also assigned' do
+      expect_violation(<<-RUBY)
+        describe MyClass do
+          before { @foo = [] }
+          it { expect(@foo).to be_empty }
+                      ^^^^ Use `let` instead of an instance variable
+        end
+      RUBY
+    end
+
+    it 'ignores an instance variable when it is not assigned' do
+      expect_no_violations(<<-RUBY)
+        describe MyClass do
+          it { expect(@foo).to be_empty }
+        end
+      RUBY
+    end
+  end
 end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::LeadingSubject do
+  subject(:cop) { described_class.new }
+
+  it 'checks subject below let' do
+    expect_violation(<<-RUBY)
+      RSpec.describe User do
+        let(:params) { foo }
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `let` declarations
+      end
+    RUBY
+  end
+
+  it 'approves of subject above let' do
+    expect_no_violations(<<-RUBY)
+      RSpec.describe User do
+        context 'blah' do
+        end
+
+        subject { described_class.new }
+
+        let(:params) { foo }
+      end
+    RUBY
+  end
+
+  it 'handles subjects in contexts' do
+    expect_no_violations(<<-RUBY)
+      RSpec.describe User do
+        let(:params) { foo }
+
+        context "when something happens" do
+          subject { described_class.new }
+        end
+      end
+    RUBY
+  end
+
+  it 'handles subjects in tests' do
+    expect_no_violations(<<-RUBY)
+      RSpec.describe User do
+        # This shouldn't really ever happen in a sane codebase but I still
+        # want to avoid false positives
+        it "doesn't mind me calling a method called subject in the test" do
+          let(foo)
+          subject { bar }
+        end
+      end
+    RUBY
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,63 @@
+# 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_expectations_spec.rb

@@ -0,0 +1,84 @@
+# 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/nested_groups_spec.rb

@@ -0,0 +1,55 @@
+# 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

@@ -18,7 +18,12 @@ describe RuboCop::Cop::RSpec::NotToNot, :config do
     end
 
     it 'auto-corrects `to_not` to `not_to`' do
-      corrected = autocorrect_source(cop, ['it { expect(0).to_not equal 1 }'])
+      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
@@ -40,7 +45,12 @@ describe RuboCop::Cop::RSpec::NotToNot, :config do
     end
 
     it 'auto-corrects `not_to` to `to_not`' do
-      corrected = autocorrect_source(cop, ['it { expect(0).not_to equal 1 }'])
+      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

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

@@ -0,0 +1,183 @@
+# 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