rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Dialect, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) do
-    {
-      'PreferredMethods' => {
-        'context' => 'describe'
-      }
-    }
-  end
-
-  it 'allows describe blocks' do
-    expect_no_offenses(<<-RUBY)
-      describe 'display name presence' do
-      end
-    RUBY
-  end
-
-  it 'allows calling methods named context in examples' do
-    expect_no_offenses(<<-RUBY)
-      it 'tests common context invocations' do
-        expect(request.context).to be_empty?
-      end
-    RUBY
-  end
-
-  it 'registers an offense for context blocks' do
-    expect_offense(<<-RUBY)
-      context 'display name presence' do
-      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `describe` over `context`.
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      describe 'display name presence' do
-      end
-    RUBY
-  end
-
-  it 'registers an offense for RSpec.context blocks' do
-    expect_offense(<<-RUBY)
-      RSpec.context 'context' do
-      ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `describe` over `context`.
-        it 'tests common context invocations' do
-          expect(request.context).to be_empty?
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe 'context' do
-        it 'tests common context invocations' do
-          expect(request.context).to be_empty?
-        end
-      end
-    RUBY
-  end
-
-  context 'without preferred methods' do
-    let(:cop_config) do
-      {
-        'PreferredMethods' => {}
-      }
-    end
-
-    it 'allows all methods blocks' do
-      expect_no_offenses(<<-RUBY)
-        context 'is important' do
-          specify 'for someone to work' do
-            everyone.should have_some_leeway
-          end
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::EmptyExampleGroup, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'flags an empty context' do
-    expect_offense(<<-RUBY)
-      describe Foo do
-        context 'when bar' do
-        ^^^^^^^^^^^^^^^^^^ Empty example group detected.
-
-          let(:foo) { bar }
-        end
-
-        describe '#thingy?' do
-          specify do
-            expect(whatever.thingy?).to be(true)
-          end
-        end
-
-        it { should be_true }
-      end
-    RUBY
-  end
-
-  it 'flags an empty top level describe' do
-    expect_offense(<<-RUBY)
-      describe Foo do
-      ^^^^^^^^^^^^ Empty example group detected.
-      end
-    RUBY
-  end
-
-  it 'does not flag include_examples' do
-    expect_no_offenses(<<-RUBY)
-      describe Foo do
-        context "when something is true" do
-          include_examples "some expectations"
-        end
-
-        context "when something else is true" do
-          include_context "some expectations"
-        end
-
-        context "when a third thing is true" do
-          it_behaves_like "some thingy"
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag methods matching example group names' do
-    expect_no_offenses(<<-RUBY)
-      describe Foo do
-        it 'yields a block when given' do
-          value = nil
-
-          helper.feature('whatevs') { value = 5 }
-
-          expect(value).to be 5
-        end
-      end
-    RUBY
-  end
-
-  it 'does not recognize custom include methods by default' do
-    expect_offense(<<-RUBY)
-      describe Foo do
-      ^^^^^^^^^^^^ Empty example group detected.
-        context "when I do something clever" do
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
-          it_has_special_behavior
-        end
-      end
-    RUBY
-  end
-
-  context 'when a custom include method is specified' do
-    let(:cop_config) do
-      { 'CustomIncludeMethods' => %w[it_has_special_behavior] }
-    end
-
-    it 'does not flag an otherwise empty example group' do
-      expect_no_offenses(<<-RUBY)
-        describe Foo do
-          context "when I do something clever" do
-            it_has_special_behavior
-          end
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup do
-  subject(:cop) { described_class.new }
-
-  it 'checks for empty line after describe' do
-    expect_offense(<<-RUBY)
-      RSpec.describe Foo do
-        describe '#bar' do
-        end
-        ^^^ Add an empty line after `describe`.
-        describe '#baz' do
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe Foo do
-        describe '#bar' do
-        end
-
-        describe '#baz' do
-        end
-      end
-    RUBY
-  end
-
-  it 'highlights single line formulations correctly' do
-    expect_offense(<<-RUBY)
-      RSpec.describe Foo do
-        describe('#bar') { }
-        ^^^^^^^^^^^^^^^^^^^^ Add an empty line after `describe`.
-        describe '#baz' do
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe Foo do
-        describe('#bar') { }
-
-        describe '#baz' do
-        end
-      end
-    RUBY
-  end
-
-  it 'checks for empty line after context' do
-    expect_offense(<<-RUBY)
-      RSpec.context 'foo' do
-        context 'bar' do
-        end
-        ^^^ Add an empty line after `context`.
-        context 'baz' do
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.context 'foo' do
-        context 'bar' do
-        end
-
-        context 'baz' do
-        end
-      end
-    RUBY
-  end
-
-  it 'approves empty line after describe' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe Foo do
-        describe '#bar' do
-        end
-
-        describe '#baz' do
-        end
-      end
-    RUBY
-  end
-
-  it 'approves empty line after context' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.context 'foo' do
-        context 'bar' do
-        end
-
-        context 'baz' do
-        end
-      end
-    RUBY
-  end
-
-  it 'handles describes in an if block' do
-    expect_offense(<<-RUBY)
-      if RUBY_VERSION < 2.3
-        describe 'skips checks under old ruby' do
-        end
-      else
-        describe 'first check' do
-        end
-        ^^^ Add an empty line after `describe`.
-        describe 'second check' do
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      if RUBY_VERSION < 2.3
-        describe 'skips checks under old ruby' do
-        end
-      else
-        describe 'first check' do
-        end
-
-        describe 'second check' do
-        end
-      end
-    RUBY
-  end
-end

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

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterFinalLet do
-  subject(:cop) { described_class.new }
-
-  it 'checks for empty line after last let' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-        ^^^^^^^^^^^^^ Add an empty line after the last `let` block.
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'check for empty line after the last `let!`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let!(:b) do
-          b
-        end
-        ^^^ Add an empty line after the last `let` block.
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let!(:b) do
-          b
-        end
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'approves empty line after let' do
-    expect_no_offenses(<<-RUBY)
-    RSpec.describe User do
-      let(:a) { a }
-      let(:b) { b }
-
-      it { expect(a).to eq(b) }
-    end
-    RUBY
-  end
-
-  it 'allows comment followed by an empty line after let' do
-    expect_no_offenses(<<-RUBY)
-    RSpec.describe User do
-      let(:a) { a }
-      let(:b) { b }
-      # end of setup
-
-      it { expect(a).to eq(b) }
-    end
-    RUBY
-  end
-
-  it 'flags missing empty line after the comment that comes after last let' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-        # end of setup
-        ^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-        # end of setup
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'flags missing empty line after a multiline comment after last let' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-        # a multiline comment marking
-        # the end of setup
-        ^^^^^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-        # a multiline comment marking
-        # the end of setup
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'ignores empty lines between the lets' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-
-        subject { described_class }
-
-        let!(:b) { b }
-        ^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-
-        subject { described_class }
-
-        let!(:b) { b }
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'handles let 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 let in the test" do
-          let(foo)
-          subject { bar }
-        end
-      end
-    RUBY
-  end
-
-  it 'handles multiline let block' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) do
-          b
-        end
-
-        it { expect(a).to eq(b) }
-      end
-    RUBY
-  end
-
-  it 'handles let being the latest node' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        let(:a) { a }
-        let(:b) { b }
-      end
-    RUBY
-  end
-
-  it 'handles HEREDOC for let' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        let(:foo) do
-          <<-BAR
-          hello
-          world
-          BAR
-        end
-
-        it 'uses heredoc' do
-          expect(foo).to eql("  hello\n  world\n")
-        end
-      end
-    RUBY
-  end
-
-  it 'handles silly HEREDOC syntax for let' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe 'silly heredoc syntax' do
-        let(:foo) { <<-BAR }
-        hello
-        world
-        BAR
-
-        it 'has tricky syntax' do
-          expect(foo).to eql("  hello\n  world\n")
-        end
-      end
-    RUBY
-  end
-
-  it 'handles silly HEREDOC offense' do
-    expect_offense(<<-RUBY)
-      RSpec.describe 'silly heredoc syntax' do
-        let(:foo) { <<-BAR }
-        hello
-        world
-        BAR
-        ^^^ Add an empty line after the last `let` block.
-        it 'has tricky syntax' do
-          expect(foo).to eql("  hello\n  world\n")
-        end
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      RSpec.describe 'silly heredoc syntax' do
-        let(:foo) { <<-BAR }
-        hello
-        world
-        BAR
-
-        it 'has tricky syntax' do
-          expect(foo).to eql("  hello\n  world\n")
-        end
-      end
-    RUBY
-  end
-end