rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ImplicitExpect, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is is_expected' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'is_expected' }
-    end
-
-    it 'flags it { should }' do
-      expect_offense(<<-RUBY)
-        it { should be_truthy }
-             ^^^^^^ Prefer `is_expected.to` over `should`.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { is_expected.to be_truthy }
-      RUBY
-    end
-
-    it 'flags it { should_not }' do
-      expect_offense(<<-RUBY)
-        it { should_not be_truthy }
-             ^^^^^^^^^^ Prefer `is_expected.to_not` over `should_not`.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { is_expected.to_not be_truthy }
-      RUBY
-    end
-
-    it 'approves of is_expected.to' do
-      expect_no_offenses('it { is_expected.to be_truthy }')
-    end
-
-    it 'approves of is_expected.to_not' do
-      expect_no_offenses('it { is_expected.to_not be_truthy }')
-    end
-
-    it 'approves of is_expected.not_to' do
-      expect_no_offenses('it { is_expected.not_to be_truthy }')
-    end
-
-    include_examples 'detects style', 'it { should be_truthy }', 'should'
-  end
-
-  context 'when EnforcedStyle is should' do
-    let(:cop_config) do
-      { 'EnforcedStyle' => 'should' }
-    end
-
-    it 'flags it { is_expected.to }' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to be_truthy }
-             ^^^^^^^^^^^^^^ Prefer `should` over `is_expected.to`.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { should be_truthy }
-      RUBY
-    end
-
-    it 'flags it { is_expected.to_not }' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to_not be_truthy }
-             ^^^^^^^^^^^^^^^^^^ Prefer `should_not` over `is_expected.to_not`.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { should_not be_truthy }
-      RUBY
-    end
-
-    it 'flags it { is_expected.not_to }' do
-      expect_offense(<<-RUBY)
-        it { is_expected.not_to be_truthy }
-             ^^^^^^^^^^^^^^^^^^ Prefer `should_not` over `is_expected.not_to`.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { should_not be_truthy }
-      RUBY
-    end
-
-    it 'approves of should' do
-      expect_no_offenses('it { should be_truthy }')
-    end
-
-    it 'approves of should_not' do
-      expect_no_offenses('it { should_not be_truthy }')
-    end
-
-    include_examples 'detects style',
-                     'it { is_expected.to be_truthy }',
-                     'is_expected'
-
-    include_examples 'detects style',
-                     'it { should be_truthy }',
-                     'should'
-  end
-end

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

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ImplicitSubject, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) do
-    { 'EnforcedStyle' => enforced_style }
-  end
-
-  context 'with EnforcedStyle `single_line_only`' do
-    let(:enforced_style) { 'single_line_only' }
-
-    it 'flags `is_expected` in multi-line examples' do
-      expect_offense(<<-RUBY)
-        it 'expect subject to be used' do
-          is_expected.to be_good
-          ^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it 'expect subject to be used' do
-          expect(subject).to be_good
-        end
-      RUBY
-    end
-
-    it 'allows `is_expected` inside `its` block, in multi-line examples' do
-      expect_no_offenses(<<-RUBY)
-        its(:quality) do
-          is_expected.to be :high
-        end
-      RUBY
-    end
-
-    it 'flags `should` in multi-line examples' do
-      expect_offense(<<-RUBY)
-        it 'expect subject to be used' do
-          should be_good
-          ^^^^^^^^^^^^^^ Don't use implicit subject.
-          should_not be_bad
-          ^^^^^^^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it 'expect subject to be used' do
-          expect(subject).to be_good
-          expect(subject).not_to be_bad
-        end
-      RUBY
-    end
-
-    it 'allows `is_expected` in single-line examples' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to be_good }
-      RUBY
-    end
-
-    it 'allows `should` in single-line examples' do
-      expect_no_offenses(<<-RUBY)
-        it { should be_good }
-      RUBY
-    end
-
-    it 'does not flag methods called is_expected and should' do
-      expect_no_offenses(<<-RUBY)
-        it 'uses some similar sounding methods' do
-          expect(baz).to receive(:is_expected)
-          baz.is_expected
-          foo.should(deny_access)
-        end
-      RUBY
-    end
-
-    it 'detects usage of `is_expected` inside helper methods' do
-      expect_offense(<<-RUBY)
-        def permits(actions)
-          actions.each { |action| is_expected.to permit_action(action) }
-                                  ^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        def permits(actions)
-          actions.each { |action| expect(subject).to permit_action(action) }
-        end
-      RUBY
-    end
-  end
-
-  context 'with EnforcedStyle `single_statement_only`' do
-    let(:enforced_style) { 'single_statement_only' }
-
-    it 'allows `is_expected` in multi-line example with single statement' do
-      expect_no_offenses(<<-RUBY)
-        it 'expect subject to be used' do
-          is_expected.to be_good
-        end
-      RUBY
-    end
-
-    it 'flags `is_expected` in multi-statement examples' do
-      expect_offense(<<-RUBY)
-        it 'expect subject to be used' do
-          subject.age = 18
-          is_expected.to be_valid
-          ^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it 'expect subject to be used' do
-          subject.age = 18
-          expect(subject).to be_valid
-        end
-      RUBY
-    end
-  end
-
-  context 'with EnforcedStyle `disallow`' do
-    let(:enforced_style) { 'disallow' }
-
-    it 'flags `is_expected` in multi-line examples' do
-      expect_offense(<<-RUBY)
-        it 'expect subject to be used' do
-          is_expected.to be_good
-          ^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it 'expect subject to be used' do
-          expect(subject).to be_good
-        end
-      RUBY
-    end
-
-    it 'flags `is_expected` in single-line examples' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to be_good }
-             ^^^^^^^^^^^ Don't use implicit subject.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { expect(subject).to be_good }
-      RUBY
-    end
-
-    it 'flags `should` in multi-line examples' do
-      expect_offense(<<-RUBY)
-        it 'expect subject to be used' do
-          should be_good
-          ^^^^^^^^^^^^^^ Don't use implicit subject.
-          should_not be_bad
-          ^^^^^^^^^^^^^^^^^ Don't use implicit subject.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it 'expect subject to be used' do
-          expect(subject).to be_good
-          expect(subject).not_to be_bad
-        end
-      RUBY
-    end
-
-    it 'flags `should` in single-line examples' do
-      expect_offense(<<-RUBY)
-        it { should be_good }
-             ^^^^^^^^^^^^^^ Don't use implicit subject.
-        it { should_not be_bad }
-             ^^^^^^^^^^^^^^^^^ Don't use implicit subject.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it { expect(subject).to be_good }
-        it { expect(subject).not_to be_bad }
-      RUBY
-    end
-
-    it 'allows `is_expected` inside `its` block' do
-      expect_no_offenses(<<-RUBY)
-        its(:quality) { is_expected.to be :high }
-      RUBY
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::InstanceSpy do
-  subject(:cop) { described_class.new }
-
-  context 'when used with `have_received`' do
-    it 'adds an offense for an instance_double with single argument' do
-      expect_offense(<<-RUBY)
-        it do
-          foo = instance_double(Foo).as_null_object
-                ^^^^^^^^^^^^^^^^^^^^ Use `instance_spy` when you check your double with `have_received`.
-          expect(foo).to have_received(:bar)
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          foo = instance_spy(Foo)
-          expect(foo).to have_received(:bar)
-        end
-      RUBY
-    end
-
-    it 'adds an offense for an instance_double with multiple arguments' do
-      expect_offense(<<-RUBY)
-        it do
-          foo = instance_double(Foo, :name).as_null_object
-                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `instance_spy` when you check your double with `have_received`.
-          expect(foo).to have_received(:bar)
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          foo = instance_spy(Foo, :name)
-          expect(foo).to have_received(:bar)
-        end
-      RUBY
-    end
-
-    it 'ignores instance_double when it is not used with as_null_object' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          foo = instance_double(Foo)
-          expect(bar).to have_received(:bar)
-       end
-      RUBY
-    end
-  end
-
-  context 'when not used with `have_received`' do
-    it 'does not add an offence' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          foo = instance_double(Foo).as_null_object
-          expect(bar).to have_received(:bar)
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::InstanceVariable do
-  subject(:cop) { described_class.new }
-
-  it 'finds an instance variable inside a describe' do
-    expect_offense(<<-RUBY)
-      describe MyClass do
-        before { @foo = [] }
-        it { expect(@foo).to be_empty }
-                    ^^^^ Replace instance variable with local variable or `let`.
-      end
-    RUBY
-  end
-
-  it 'ignores non-spec blocks' do
-    expect_no_offenses(<<-RUBY)
-      not_rspec do
-        before { @foo = [] }
-        it { expect(@foo).to be_empty }
-      end
-    RUBY
-  end
-
-  it 'finds an instance variable inside a shared example' do
-    expect_offense(<<-RUBY)
-      shared_examples 'shared example' do
-        it { expect(@foo).to be_empty }
-                    ^^^^ Replace instance variable with local variable or `let`.
-      end
-    RUBY
-  end
-
-  it 'ignores an instance variable without describe' do
-    expect_no_offenses(<<-RUBY)
-      @foo = []
-      @foo.empty?
-    RUBY
-  end
-
-  it 'ignores an instance variable inside a dynamic class' do
-    expect_no_offenses(<<-RUBY)
-      describe MyClass do
-        let(:object) do
-          Class.new(OtherClass) do
-            def initialize(resource)
-              @resource = resource
-            end
-
-            def serialize
-              @resource.to_json
-            end
-          end
-        end
-      end
-    RUBY
-  end
-
-  # Regression test for nevir/rubocop-rspec#115
-  it 'ignores instance variables outside of specs' do
-    expect_no_offenses(<<-RUBY, '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_offense(<<-RUBY)
-        describe MyClass do
-          before { @foo = [] }
-          it { expect(@foo).to be_empty }
-                      ^^^^ Replace instance variable with local variable or `let`.
-        end
-      RUBY
-    end
-
-    it 'ignores an instance variable when it is not assigned' do
-      expect_no_offenses(<<-RUBY)
-        describe MyClass do
-          it { expect(@foo).to be_empty }
-        end
-      RUBY
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::InvalidPredicateMatcher do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for double question' do
-    expect_offense(<<-RUBY)
-      expect(foo).to be_something?
-                     ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `not_to`' do
-    expect_offense(<<-RUBY)
-      expect(foo).not_to be_something?
-                         ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `to_not`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to_not be_something?
-                         ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `have_something?`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to have_something?
-                     ^^^^^^^^^^^^^^^ Omit `?` from `have_something?`.
-    RUBY
-  end
-
-  it 'accepts valid predicate matcher' do
-    expect_no_offenses(<<-RUBY)
-      expect(foo).to be_something
-    RUBY
-  end
-end