rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::BeEql do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for `eql` when argument is a boolean' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to eql(true) }
-                          ^^^ Prefer `be` over `eql`.
-      it { expect(foo).to eql(false) }
-                          ^^^ Prefer `be` over `eql`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it { expect(foo).to be(true) }
-      it { expect(foo).to be(false) }
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is an integer' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to eql(0) }
-                          ^^^ Prefer `be` over `eql`.
-      it { expect(foo).to eql(123) }
-                          ^^^ Prefer `be` over `eql`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it { expect(foo).to be(0) }
-      it { expect(foo).to be(123) }
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is a float' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to eql(1.0) }
-                          ^^^ Prefer `be` over `eql`.
-      it { expect(foo).to eql(1.23) }
-                          ^^^ Prefer `be` over `eql`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it { expect(foo).to be(1.0) }
-      it { expect(foo).to be(1.23) }
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is a symbol' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to eql(:foo) }
-                          ^^^ Prefer `be` over `eql`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it { expect(foo).to be(:foo) }
-    RUBY
-  end
-
-  it 'registers an offense for `eql` when argument is nil' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to eql(nil) }
-                          ^^^ Prefer `be` over `eql`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it { expect(foo).to be(nil) }
-    RUBY
-  end
-
-  it 'does not register an offense for `eql` when argument is a string' do
-    expect_no_offenses(<<-RUBY)
-      it { expect(foo).to eql('foo') }
-    RUBY
-  end
-
-  it 'does not register an offense for `eql` when expectation is negated' do
-    expect_no_offenses(<<-RUBY)
-      it { expect(foo).to_not eql(1) }
-    RUBY
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Be do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for `be` without an argument' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).to be }
-                          ^^ Don't use `be` without an argument.
-    RUBY
-  end
-
-  it 'registers an offense for not_to be' do
-    expect_offense(<<-RUBY)
-      it { expect(foo).not_to be }
-                              ^^ Don't use `be` without an argument.
-      it { expect(foo).to_not be }
-                              ^^ Don't use `be` without an argument.
-    RUBY
-  end
-
-  it 'allows `be` with an argument' do
-    expect_no_offenses(<<-RUBY)
-      it { expect(foo).to be(1) }
-      it { expect(foo).not_to be(0) }
-    RUBY
-  end
-
-  it 'allows specific `be_` matchers' do
-    expect_no_offenses(<<-RUBY)
-      it { expect(foo).to be_truthy }
-      it { expect(foo).not_to be_falsy }
-    RUBY
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::BeforeAfterAll do
-  subject(:cop) { described_class.new }
-
-  def message(hook)
-    "Beware of using `#{hook}` as it may cause state to leak between tests. "\
-    'If you are using `rspec-rails`, and `use_transactional_fixtures` is '\
-    "enabled, then records created in `#{hook}` are not automatically rolled "\
-    'back.'
-  end
-
-  context 'when using before all' do
-    it 'registers an offense' do
-      expect_offense(<<-RUBY)
-        before(:all) { do_something }
-        ^^^^^^^^^^^^ #{message('before(:all)')}
-        before(:context) { do_something }
-        ^^^^^^^^^^^^^^^^ #{message('before(:context)')}
-      RUBY
-    end
-  end
-
-  context 'when using after all' do
-    it 'registers an offense' do
-      expect_offense(<<-RUBY)
-        after(:all) { do_something }
-        ^^^^^^^^^^^ #{message('after(:all)')}
-        after(:context) { do_something }
-        ^^^^^^^^^^^^^^^ #{message('after(:context)')}
-      RUBY
-    end
-  end
-
-  context 'when using before each' do
-    it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
-        before(:each) { do_something }
-        before(:example) { do_something }
-      RUBY
-    end
-  end
-
-  context 'when using after each' do
-    it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
-        after(:each) { do_something }
-        after(:example) { do_something }
-      RUBY
-    end
-  end
-end

data/spec/rubocop/cop/rspec/capybara/current_path_expectation_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation do
-  subject(:cop) { described_class.new }
-
-  it 'flags violations for `expect(current_path)`' do
-    expect_offense(<<-RUBY)
-      expect(current_path).to eq("/callback")
-      ^^^^^^ Do not set an RSpec expectation on `current_path` in Capybara feature specs - instead, use the `have_current_path` matcher on `page`
-    RUBY
-  end
-
-  it 'flags violations for `expect(page.current_path)`' do
-    expect_offense(<<-RUBY)
-      expect(page.current_path).to eq("/callback")
-      ^^^^^^ Do not set an RSpec expectation on `current_path` in Capybara feature specs - instead, use the `have_current_path` matcher on `page`
-    RUBY
-  end
-
-  it "doesn't flag a violation for other expectations" do
-    expect_no_offenses(<<-RUBY)
-      expect(current_user).to eq(user)
-    RUBY
-  end
-
-  it "doesn't flag a violation for other references to `current_path`" do
-    expect_no_offenses(<<-RUBY)
-      current_path = WalkingRoute.last.path
-    RUBY
-  end
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to eq expected_path',
-                   'expect(page).to have_current_path expected_path'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to eq(foo(bar).path)',
-                   'expect(page).to have_current_path(foo(bar).path)'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).not_to eq expected_path',
-                   'expect(page).to have_no_current_path expected_path'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to_not eq expected_path',
-                   'expect(page).to have_no_current_path expected_path'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match(/regexp/i)',
-                   'expect(page).to have_current_path(/regexp/i)'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match("string/")',
-                   'expect(page).to have_current_path(/string\//)'
-
-  # Unsupported, no change.
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match(variable)',
-                   'expect(page.current_path).to match(variable)'
-
-  # Unsupported, no change.
-  include_examples 'autocorrect',
-                   'expect(page.current_path)',
-                   'expect(page.current_path)'
-end

data/spec/rubocop/cop/rspec/capybara/feature_methods_spec.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Capybara::FeatureMethods, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'EnabledMethods' => [] } }
-
-  it 'flags violations for `background`' do
-    expect_offense(<<-RUBY)
-      describe 'some feature' do
-        background do; end
-        ^^^^^^^^^^ Use `before` instead of `background`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `scenario`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe 'some feature' do
-        scenario 'Foo' do; end
-        ^^^^^^^^ Use `it` instead of `scenario`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `xscenario`' do
-    expect_offense(<<-RUBY)
-      describe 'Foo' do
-        RSpec.xscenario 'Baz' do; end
-              ^^^^^^^^^ Use `xit` instead of `xscenario`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `given`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe 'Foo' do
-        given(:foo) { :foo }
-        ^^^^^ Use `let` instead of `given`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `given!`' do
-    expect_offense(<<-RUBY)
-      describe 'Foo' do
-        given!(:foo) { :foo }
-        ^^^^^^ Use `let!` instead of `given!`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `feature`' do
-    expect_offense(<<-RUBY)
-      RSpec.feature 'Foo' do; end
-            ^^^^^^^ Use `describe` instead of `feature`.
-    RUBY
-  end
-
-  it 'ignores variables inside examples' do
-    expect_no_offenses(<<-RUBY)
-      it 'is valid code' do
-        given(feature)
-        assign(background)
-        run scenario
-      end
-    RUBY
-  end
-
-  it 'ignores feature calls outside spec' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :company do
-          feature { "a company" }
-          background { Faker::Lorem.sentence }
-        end
-      end
-    RUBY
-  end
-
-  it 'allows includes before the spec' do
-    expect_offense(<<-RUBY)
-      require 'rails_helper'
-
-      RSpec.feature 'Foo' do; end
-            ^^^^^^^ Use `describe` instead of `feature`.
-    RUBY
-  end
-
-  context 'with configured `EnabledMethods`' do
-    let(:cop_config) { { 'EnabledMethods' => %w[feature] } }
-
-    it 'ignores usage of the enabled method' do
-      expect_no_offenses(<<-RUBY)
-        RSpec.feature 'feature is enabled' do; end
-      RUBY
-    end
-
-    it 'flags other methods' do
-      expect_offense(<<-RUBY)
-        RSpec.feature 'feature is enabled' do
-          given(:foo) { :foo }
-          ^^^^^ Use `let` instead of `given`.
-        end
-      RUBY
-    end
-  end
-
-  shared_examples 'autocorrect_spec' do |original, corrected|
-    original = <<-RUBY
-      describe Foo do
-        #{original}
-      end
-    RUBY
-    corrected = <<-RUBY
-      describe Foo do
-        #{corrected}
-      end
-    RUBY
-
-    include_examples 'autocorrect', original, corrected
-  end
-
-  include_examples 'autocorrect_spec', 'background { }',    'before { }'
-  include_examples 'autocorrect_spec', 'scenario { }',      'it { }'
-  include_examples 'autocorrect_spec', 'xscenario { }',     'xit { }'
-  include_examples 'autocorrect_spec', 'given(:foo) { }',   'let(:foo) { }'
-  include_examples 'autocorrect_spec', 'given!(:foo) { }',  'let!(:foo) { }'
-  include_examples 'autocorrect_spec', 'RSpec.feature { }', 'RSpec.describe { }'
-end

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ContextWording, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'Prefixes' => %w[when with] } }
-
-  it 'skips describe blocks' do
-    expect_no_offenses(<<-RUBY)
-      describe 'the display name not present' do
-      end
-    RUBY
-  end
-
-  it 'finds context without `when` at the beginning' do
-    expect_offense(<<-RUBY)
-      context 'the display name not present' do
-              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-      end
-    RUBY
-  end
-
-  it 'finds shared_context without `when` at the beginning' do
-    expect_offense(<<-RUBY)
-      shared_context 'the display name not present' do
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-      end
-    RUBY
-  end
-
-  it "skips descriptions beginning with 'when'" do
-    expect_no_offenses(<<-RUBY)
-      context 'when the display name is not present' do
-      end
-    RUBY
-  end
-
-  it 'finds context without separate `when` at the beginning' do
-    expect_offense(<<-RUBY)
-      context 'whenever you do' do
-              ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-      end
-    RUBY
-  end
-
-  context 'with metadata hash' do
-    it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
-        context 'whenever you do', legend: true do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-        end
-      RUBY
-    end
-  end
-
-  context 'with symbol metadata' do
-    it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
-        context 'whenever you do', :legend do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-        end
-      RUBY
-    end
-  end
-
-  context 'with mixed metadata' do
-    it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
-        context 'whenever you do', :legend, myth: true do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
-        end
-      RUBY
-    end
-  end
-
-  context 'when configured' do
-    let(:cop_config) { { 'Prefixes' => %w[if] } }
-
-    it 'finds context without whitelisted prefixes at the beginning' do
-      expect_offense(<<-RUBY)
-        context 'when display name is present' do
-                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'if'.
-        end
-      RUBY
-    end
-
-    it 'skips descriptions with whitelisted prefixes at the beginning' do
-      expect_no_offenses(<<-RUBY)
-        context 'if display name is present' do
-        end
-      RUBY
-    end
-  end
-end