rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ItBehavesLike, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) do
-    { 'EnforcedStyle' => enforced_style }
-  end
-
-  context 'when the enforced style is `it_behaves_like`' do
-    let(:enforced_style) { :it_behaves_like }
-
-    it 'flags a violation for it_should_behave_like' do
-      expect_offense(<<-RUBY)
-        it_should_behave_like 'a foo'
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `it_behaves_like` over `it_should_behave_like` when including examples in a nested context.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it_behaves_like 'a foo'
-      RUBY
-    end
-
-    it 'does not flag a violation for it_behaves_like' do
-      expect_no_offenses("it_behaves_like 'a foo'")
-    end
-  end
-
-  context 'when the enforced style is `it_should_behave_like`' do
-    let(:enforced_style) { :it_should_behave_like }
-
-    it 'flags a violation for it_behaves_like' do
-      expect_offense(<<-RUBY)
-        it_behaves_like 'a foo'
-        ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `it_should_behave_like` over `it_behaves_like` when including examples in a nested context.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it_should_behave_like 'a foo'
-      RUBY
-    end
-
-    it 'does not flag a violation for it_behaves_like' do
-      expect_no_offenses("it_should_behave_like 'a foo'")
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::IteratedExpectation do
-  subject(:cop) { described_class.new }
-
-  it 'flags `each` with an expectation' do
-    expect_offense(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each { |user| expect(user).to be_valid }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
-      end
-    RUBY
-  end
-
-  it 'flags `each` when expectation calls method with arguments' do
-    expect_offense(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each { |user| expect(user).to be_a(User) }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
-      end
-    RUBY
-  end
-
-  it 'ignores `each` without expectation' do
-    expect_no_offenses(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each { |user| allow(user).to receive(:method) }
-      end
-    RUBY
-  end
-
-  it 'flags `each` with multiple expectations' do
-    expect_offense(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each do |user|
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
-          expect(user).to receive(:method)
-          expect(user).to receive(:other_method)
-        end
-      end
-    RUBY
-  end
-
-  it 'ignore `each` when the body does not contain only expectations' do
-    expect_no_offenses(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each do |user|
-          allow(Something).to receive(:method).and_return(user)
-          expect(user).to receive(:method)
-          expect(user).to receive(:other_method)
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores `each` with expectation on property' do
-    expect_no_offenses(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each { |user| expect(user.name).to be }
-      end
-    RUBY
-  end
-
-  it 'ignores assignments in the iteration' do
-    expect_no_offenses(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each { |user| array = array.concat(user) }
-      end
-    RUBY
-  end
-
-  it 'ignores `each` when there is a negative expectation' do
-    expect_no_offenses(<<-RUBY)
-      it 'validates users' do
-        [user1, user2, user3].each do |user|
-          expect(user).not_to receive(:method)
-          expect(user).to receive(:other_method)
-        end
-      end
-    RUBY
-  end
-end

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::LeadingSubject do
-  subject(:cop) { described_class.new }
-
-  it 'checks subject below let' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:params) { foo }
-
-        subject { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `let` declarations.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-        let(:params) { foo }
-
-      end
-    RUBY
-  end
-
-  it 'checks subject below let!' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let!(:params) { foo }
-
-        subject { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `let!` declarations.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-        let!(:params) { foo }
-
-      end
-    RUBY
-  end
-
-  it 'approves of subject above let' do
-    expect_no_offenses(<<-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_offenses(<<-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_offenses(<<-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
-
-  it 'checks subject below hook' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        before { allow(Foo).to receive(:bar) }
-
-        subject { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `before` declarations.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-        before { allow(Foo).to receive(:bar) }
-
-      end
-    RUBY
-  end
-
-  it 'checks subject below example' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        it { is_expected.to be_present }
-
-        subject { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `it` declarations.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        subject { described_class.new }
-        it { is_expected.to be_present }
-
-      end
-    RUBY
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::LeakyConstantDeclaration do
-  subject(:cop) { described_class.new }
-
-  describe 'constant assignment' do
-    it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
-        describe SomeClass do
-          CONSTANT = "Accessible as ::CONSTANT".freeze
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub constant instead of declaring explicitly.
-        end
-      RUBY
-    end
-
-    it 'flags inside shared example group' do
-      expect_offense(<<-RUBY)
-        RSpec.shared_examples 'shared example' do
-          CONSTANT = "Accessible as ::CONSTANT".freeze
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub constant instead of declaring explicitly.
-        end
-      RUBY
-    end
-
-    it 'flags inside an example' do
-      expect_offense(<<-RUBY)
-        describe SomeClass do
-          specify do
-            CONSTANT = "Accessible as ::CONSTANT".freeze
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub constant instead of declaring explicitly.
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores outside of example/shared group' do
-      expect_no_offenses(<<-RUBY)
-        factory :some_class do
-          CONSTANT = "Accessible as ::CONSTANT".freeze
-        end
-      RUBY
-    end
-  end
-
-  describe 'class defined' do
-    it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
-        describe SomeClass do
-          class DummyClass < described_class
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub class constant instead of declaring explicitly.
-          end
-        end
-      RUBY
-    end
-
-    it 'ignores anonymous classes' do
-      expect_no_offenses(<<-RUBY)
-        describe SomeClass do
-          let(:dummy_playbook) do
-            Class.new do
-              def method
-              end
-            end
-          end
-         end
-      RUBY
-    end
-
-    it 'flags namespaced class' do
-      expect_offense(<<-RUBY)
-        describe SomeClass do
-          class SomeModule::AnotherModule::DummyClass
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub class constant instead of declaring explicitly.
-          end
-        end
-      RUBY
-    end
-  end
-
-  describe 'module defined' do
-    it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
-        describe SomeClass do
-          module DummyModule
-          ^^^^^^^^^^^^^^^^^^ Stub module constant instead of declaring explicitly.
-          end
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::LetBeforeExamples do
-  subject(:cop) { described_class.new }
-
-  it 'flags `let` after `it`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        it { is_expected.to be_after_let }
-        let(:foo) { bar }
-        ^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) { bar }
-        it { is_expected.to be_after_let }
-      end
-    RUBY
-  end
-
-  it 'flags `let` after `context`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        context 'a context' do
-          it { is_expected.to be_after_let }
-        end
-
-        let(:foo) { bar }
-        ^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) { bar }
-        context 'a context' do
-          it { is_expected.to be_after_let }
-        end
-
-      end
-    RUBY
-  end
-
-  it 'flags `let` after `include_examples`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        include_examples('should be after let')
-
-        let(:foo) { bar }
-        ^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) { bar }
-        include_examples('should be after let')
-
-      end
-    RUBY
-  end
-
-  it 'does not flag `let` before the examples' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) { bar }
-
-        it { is_expected.to be_after_let }
-
-        context 'a context' do
-          it { is_expected.to work }
-        end
-
-        include_examples('everything is fine')
-      end
-    RUBY
-  end
-
-  it 'does not flag `let` in a nested context' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) { bar }
-
-        context 'something else' do
-          let(:foo) { baz }
-          it { is_expected.to work }
-        end
-
-        include_examples('everything is fine')
-      end
-    RUBY
-  end
-
-  it 'allows inclusion of context before `let`' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        include_context 'special user'
-
-        let(:foo) { bar }
-      end
-    RUBY
-  end
-
-  it 'ignores single-line example blocks' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        include_examples 'special user' do
-          let(:foo) { bar }
-        end
-      end
-    RUBY
-  end
-
-  bad_code = <<-RUBY
-    RSpec.describe User do
-      include_examples('should be after let')
-
-      let(:foo) { (<<-SOURCE) }
-      some long text here
-      SOURCE
-    end
-  RUBY
-
-  good_code = <<-RUBY
-    RSpec.describe User do
-      let(:foo) { (<<-SOURCE) }
-      some long text here
-      SOURCE
-      include_examples('should be after let')
-
-    end
-  RUBY
-
-  include_examples 'autocorrect', bad_code, good_code
-end