rubocop-rspec 1.7.0 → 3.0.2

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

@@ -1,219 +0,0 @@
-describe RuboCop::Cop::RSpec::DescribedClass, :config do
-  subject(:cop) { described_class.new(config) }
-
-  shared_examples 'SkipBlocks enabled' do
-    it 'does not flag violations within non-rspec blocks' do
-      expect_violation(<<-RUBY)
-        describe MyClass do
-          controller(ApplicationController) do
-            bar = MyClass
-          end
-
-          before do
-            MyClass
-            ^^^^^^^ Use `described_class` instead of `MyClass`
-
-            Foo.custom_block do
-              MyClass
-            end
-          end
-        end
-      RUBY
-    end
-  end
-
-  shared_examples 'SkipBlocks disabled' do
-    it 'flags violations within all blocks' do
-      expect_violation(<<-RUBY)
-        describe MyClass do
-          controller(ApplicationController) do
-            bar = MyClass
-                  ^^^^^^^ Use `described_class` instead of `MyClass`
-          end
-
-          before(:each) do
-            MyClass
-            ^^^^^^^ Use `described_class` instead of `MyClass`
-
-            Foo.custom_block do
-              MyClass
-              ^^^^^^^ Use `described_class` instead of `MyClass`
-            end
-          end
-        end
-      RUBY
-    end
-  end
-
-  context 'when SkipBlocks is `true`' do
-    let(:cop_config) { { 'SkipBlocks' => true } }
-
-    include_examples 'SkipBlocks enabled'
-  end
-
-  context 'when SkipBlocks anything besides `true`' do
-    let(:cop_config) { { 'SkipBlocks' => 'yes' } }
-
-    include_examples 'SkipBlocks disabled'
-  end
-
-  context 'when SkipBlocks is not set' do
-    let(:cop_config) { Hash.new }
-
-    include_examples 'SkipBlocks disabled'
-  end
-
-  context 'when SkipBlocks is `false`' do
-    let(:cop_config) { { 'SkipBlocks' => false } }
-
-    include_examples 'SkipBlocks disabled'
-  end
-
-  it 'checks for the use of the described class' do
-    expect_violation(<<-RUBY)
-      describe MyClass do
-        include MyClass
-                ^^^^^^^ Use `described_class` instead of `MyClass`
-
-        subject { MyClass.do_something }
-                  ^^^^^^^ Use `described_class` instead of `MyClass`
-
-        before { MyClass.do_something }
-                 ^^^^^^^ Use `described_class` instead of `MyClass`
-      end
-    RUBY
-  end
-
-  it 'ignores described class as string' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        subject { "MyClass" }
-      end
-    RUBY
-  end
-
-  it 'ignores describe that do not reference to a class' do
-    expect_no_violations(<<-RUBY)
-      describe "MyClass" do
-        subject { "MyClass" }
-      end
-    RUBY
-  end
-
-  it 'ignores class if the scope is changing' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        Class.new  { foo = MyClass }
-        Module.new { bar = MyClass }
-
-        def method
-          include MyClass
-        end
-
-        class OtherClass
-          include MyClass
-        end
-
-        module MyModle
-          include MyClass
-        end
-      end
-    RUBY
-  end
-
-  it 'only takes class from top level describes' do
-    expect_violation(<<-RUBY)
-      describe MyClass do
-        describe MyClass::Foo do
-          subject { MyClass::Foo }
-
-          let(:foo) { MyClass }
-                      ^^^^^^^ Use `described_class` instead of `MyClass`
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores subclasses' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        subject { MyClass::SubClass }
-      end
-    RUBY
-  end
-
-  it 'ignores if namespace is not matching' do
-    expect_no_violations(<<-RUBY)
-      describe MyNamespace::MyClass do
-        subject { ::MyClass }
-        let(:foo) { MyClass }
-      end
-    RUBY
-  end
-
-  it 'checks for the use of described class with namespace' do
-    expect_violation(<<-RUBY)
-      describe MyNamespace::MyClass do
-        subject { MyNamespace::MyClass }
-                  ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
-      end
-    RUBY
-  end
-
-  it 'does not flag violations within a scope change' do
-    expect_no_violations(<<-RUBY)
-      describe MyNamespace::MyClass do
-        before do
-          class Foo
-            thing = MyNamespace::MyClass.new
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag violations within a scope change' do
-    expect_no_violations(<<-RUBY)
-      describe do
-        before do
-          MyNamespace::MyClass.new
-        end
-      end
-    RUBY
-  end
-
-  it 'checks for the use of described class with module' do
-    skip
-
-    expect_violation(<<-RUBY)
-      module MyNamespace
-        describe MyClass do
-          subject { MyNamespace::MyClass }
-                    ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
-        end
-      end
-    RUBY
-  end
-
-  it 'autocorrects an offenses' do
-    new_source = autocorrect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  include MyClass',
-        '  subject { MyClass.do_something }',
-        '  before { MyClass.do_something }',
-        'end'
-      ], 'spec/foo_spec.rb'
-    )
-    expect(new_source).to eq(
-      [
-        'describe MyClass do',
-        '  include described_class',
-        '  subject { described_class.do_something }',
-        '  before { described_class.do_something }',
-        'end'
-      ].join("\n")
-    )
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::EmptyExampleGroup, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'flags an empty context' do
-    expect_violation(<<-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_violation(<<-RUBY)
-      describe Foo do
-      ^^^^^^^^^^^^ Empty example group detected.
-      end
-    RUBY
-  end
-
-  it 'does not flag include_examples' do
-    expect_no_violations(<<-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 recognize custom include methods by default' do
-    expect_violation(<<-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_violations(<<-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/example_length_spec.rb

@@ -1,117 +0,0 @@
-describe RuboCop::Cop::RSpec::ExampleLength, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'Max' => 3 } }
-
-  it 'ignores non-spec blocks' do
-    inspect_source(
-      cop,
-      [
-        'foo do',
-        '  line 1',
-        '  line 2',
-        '  line 3',
-        '  line 4',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'allows an empty example' do
-    inspect_source(
-      cop,
-      [
-        'it do',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'allows a short example' do
-    inspect_source(
-      cop,
-      [
-        'it do',
-        '  line 1',
-        '  line 2',
-        '  line 3',
-        'end'
-      ],
-      'spec/foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores comments' do
-    inspect_source(
-      cop,
-      [
-        'it do',
-        '  line 1',
-        '  line 2',
-        '  # comment',
-        '  line 3',
-        'end'
-      ],
-      'spec/foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
-  end
-
-  shared_examples 'large example violation' do
-    before do
-      inspect_source(cop, source, 'spec/foo_spec.rb')
-    end
-
-    it 'flags an offense' do
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'registers the offense on line 1' do
-      expect(cop.offenses.map(&:line)).to eq([1])
-    end
-
-    it 'adds a message saying the example has too many lines' do
-      expect(cop.messages).to eq(['Example has too many lines. [4/3]'])
-    end
-  end
-
-  context 'when inspecting large examples' do
-    let(:source) do
-      [
-        'it do',
-        '  line 1',
-        '  line 2',
-        '  line 3',
-        '  line 4',
-        'end'
-      ]
-    end
-
-    include_examples 'large example violation'
-  end
-
-  context 'with CountComments enabled' do
-    let(:cop_config) do
-      { 'Max' => 3, 'CountComments' => true }
-    end
-
-    let(:source) do
-      [
-        'it do',
-        '  line 1',
-        '  line 2',
-        '  # comment',
-        '  line 3',
-        'end'
-      ]
-    end
-
-    include_examples 'large example violation'
-  end
-end

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

@@ -1,82 +0,0 @@
-describe RuboCop::Cop::RSpec::ExampleWording, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'with configuration' do
-    let(:cop_config) do
-      {
-        'CustomTransform' => { 'have' => 'has', 'not' => 'does not' },
-        'IgnoredWords' => %w(only really)
-      }
-    end
-
-    it 'ignores non-example blocks' do
-      expect_no_violations('foo "should do something" do; end')
-    end
-
-    it 'finds description with `should` at the beginning' do
-      expect_violation(<<-RUBY)
-        it 'should do something' do
-            ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
-    end
-
-    it 'finds description with `Should` at the beginning' do
-      expect_violation(<<-RUBY)
-        it 'Should do something' do
-            ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
-    end
-
-    it 'finds description with `shouldn\'t` at the beginning' do
-      expect_violation(<<-RUBY)
-        it "shouldn't do something" do
-            ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
-    end
-
-    it 'skips descriptions without `should` at the beginning' do
-      expect_no_violations(<<-RUBY)
-        it 'finds no should here' do
-        end
-      RUBY
-    end
-
-    it 'corrects `it "should only have"` to it "only has"' do
-      corrected =
-        autocorrect_source(
-          cop,
-          'it "should only have trait" do end',
-          'spec/foo_spec.rb'
-        )
-
-      expect(corrected).to eql('it "only has trait" do end')
-    end
-  end
-
-  context 'when configuration is empty' do
-    it 'only does not correct "have"' do
-      corrected =
-        autocorrect_source(
-          cop,
-          'it "should have trait" do end',
-          'spec/foo_spec.rb'
-        )
-
-      expect(corrected).to eql('it "haves trait" do end')
-    end
-
-    it 'only does not make an exception for the word "only"' do
-      corrected =
-        autocorrect_source(
-          cop,
-          'it "should only fail" do end',
-          'spec/foo_spec.rb'
-        )
-
-      expect(corrected).to eql('it "onlies fail" do end')
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-describe RuboCop::Cop::RSpec::ExpectActual do
-  subject(:cop) { described_class.new }
-
-  it 'flags numeric literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(123).to eq(bar)
-                 ^^^ Provide the actual you are testing to `expect(...)`
-          expect(12.3).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`
-          expect(1i).to eq(bar)
-                 ^^ Provide the actual you are testing to `expect(...)`
-          expect(1r).to eq(bar)
-                 ^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags boolean literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(true).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`
-          expect(false).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags string and symbol literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect("foo").to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`
-          expect(:foo).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags literal nil value within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(nil).to eq(bar)
-                 ^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag dynamic values within expect(...)' do
-    expect_no_violations(<<-'RUBY')
-      describe Foo do
-        it 'uses expect correctly' do
-          expect(foo).to eq(bar)
-          expect("foo#{baz}").to eq(bar)
-          expect(:"foo#{baz}").to  eq(bar)
-        end
-      end
-    RUBY
-  end
-
-  it 'flags arrays containing only literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect([123]).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`
-          expect([[123]]).to eq(bar)
-                 ^^^^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags hashes containing only literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(foo: 1, bar: 2).to eq(bar)
-                 ^^^^^^^^^^^^^^ Provide the actual you are testing to `expect(...)`
-          expect(foo: 1, bar: [{}]).to eq(bar)
-                 ^^^^^^^^^^^^^^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags ranges containing only literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(1..2).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`
-          expect(1...2).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'flags regexps containing only literal values within expect(...)' do
-    expect_violation(<<-RUBY)
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect(/foo|bar/).to eq(bar)
-                 ^^^^^^^^^ Provide the actual you are testing to `expect(...)`
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag complex values with dynamic parts within expect(...)' do
-    expect_no_violations(<<-'RUBY')
-      describe Foo do
-        it 'uses expect incorrectly' do
-          expect([foo]).to eq(bar)
-          expect([[foo]]).to eq(bar)
-          expect(foo: 1, bar: foo).to eq(bar)
-          expect(1..foo).to eq(bar)
-          expect(1...foo).to eq(bar)
-          expect(/foo|#{bar}/).to eq(bar)
-        end
-      end
-    RUBY
-  end
-end