rubocop-rspec 1.12.0 → 1.13.0

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

@@ -1,30 +1,119 @@
-describe RuboCop::Cop::RSpec::AroundBlock do
+RSpec.describe RuboCop::Cop::RSpec::AroundBlock do
   subject(:cop) { described_class.new }
 
-  it 'finds `around` block without block arguments' do
-    expect_violation(<<-RUBY)
-      around do
-      ^^^^^^^^^ Test object should be passed to around block
-        do_something
-      end
-    RUBY
-  end
-
-  it 'finds `around` block with unused argument' do
-    expect_violation(<<-RUBY)
-      around do |test|
-                 ^^^^ You should call `test.call` or `test.run`
-        do_something
-      end
-    RUBY
-  end
-
-  it 'checks the first argument of the block' do
-    expect_violation(<<-RUBY)
-      around do |test, unused|
-                 ^^^^ You should call `test.call` or `test.run`
-        unused.run
-      end
-    RUBY
+  context 'when no value is yielded' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        around do
+        ^^^^^^^^^ Test object should be passed to around block.
+          do_something
+        end
+      RUBY
+    end
+  end
+
+  context 'when the hook is scoped with a symbol' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        around(:each) do
+        ^^^^^^^^^^^^^^^^ Test object should be passed to around block.
+          do_something
+        end
+      RUBY
+    end
+  end
+
+  context 'when the yielded value is unused' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        around do |test|
+                   ^^^^ You should call `test.call` or `test.run`.
+          do_something
+        end
+      RUBY
+    end
+  end
+
+  context 'when two values are yielded and the first is unused' do
+    it 'registers an offense for the first argument' do
+      expect_violation(<<-RUBY)
+        around do |test, unused|
+                   ^^^^ You should call `test.call` or `test.run`.
+          unused.run
+        end
+      RUBY
+    end
+  end
+
+  context 'when the yielded value is referenced but not used' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        around do |test|
+                   ^^^^ You should call `test.call` or `test.run`.
+          test
+        end
+      RUBY
+    end
+  end
+
+  context 'when a method other than #run or #call is called' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        around do |test|
+                   ^^^^ You should call `test.call` or `test.run`.
+          test.inspect
+        end
+      RUBY
+    end
+  end
+
+  context 'when #run is called' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        around do |test|
+          test.run
+        end
+      RUBY
+    end
+  end
+
+  context 'when #call is called' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        around do |test|
+          test.call
+        end
+      RUBY
+    end
+  end
+
+  context 'when used as a block arg' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        around do |test|
+          1.times(&test)
+        end
+      RUBY
+    end
+  end
+
+  context 'when passed to another method' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        around do |test|
+          something_that_might_run_test(test, another_arg)
+        end
+      RUBY
+    end
+  end
+
+  context 'when yielded to another block' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        around do |test|
+          foo { yield(some_arg, test) }
+        end
+      RUBY
+    end
   end
 end

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

@@ -1,44 +1,44 @@
-describe RuboCop::Cop::RSpec::BeEql do
+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_violation(<<-RUBY)
       it { expect(foo).to eql(true) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(false) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is an integer' do
     expect_violation(<<-RUBY)
       it { expect(foo).to eql(0) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(123) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is a float' do
     expect_violation(<<-RUBY)
       it { expect(foo).to eql(1.0) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(1.23) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is a symbol' do
     expect_violation(<<-RUBY)
       it { expect(foo).to eql(:foo) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is nil' do
     expect_violation(<<-RUBY)
       it { expect(foo).to eql(nil) }
-                          ^^^ Prefer `be` over `eql`
+                          ^^^ Prefer `be` over `eql`.
     RUBY
   end
 

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

@@ -1,92 +1,50 @@
-describe RuboCop::Cop::RSpec::BeforeAfterAll, :config do
+RSpec.describe RuboCop::Cop::RSpec::BeforeAfterAll, :config do
   subject(:cop) { described_class.new(config) }
 
-  context 'when offenses detected' do
-    let(:code) do
-      [
-        'describe MyClass do',
-        '  before(:all) { do_something}',
-        '  after(:all) { do_something_else }',
-        'end'
-      ]
-    end
-
-    let(:expected_error) do
-      'Beware of using `before/after(:all)` 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 '\
-        '`before(:all)` are not rolled back.'
-    end
-
-    it 'reports 2 offenses' do
-      inspect_source(cop, code, 'foo_spec.rb')
-      expect(cop.offenses.size).to eq(2)
-    end
-
-    it 'reports the lines for these offenses' do
-      inspect_source(cop, code, 'foo_spec.rb')
-      expect(cop.offenses.map(&:line).sort).to eq([2, 3])
-    end
-
-    it 'describes the offenses' do
-      inspect_source(cop, code, 'foo_spec.rb')
-      expect(cop.messages).to eq([expected_error, expected_error])
-    end
+  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
 
-  it 'complains for :context' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  before(:context) { do_something }',
-        '  after(:context) { do_something_else }',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(2)
+  context 'when using before all' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        before(:all) { do_something }
+        ^^^^^^^^^^^^ #{message('before(:all)')}
+        before(:context) { do_something }
+        ^^^^^^^^^^^^^^^^ #{message('before(:context)')}
+      RUBY
+    end
   end
 
-  it 'does not complain for before/after :each' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  before(:each) { do_something }',
-        '  after(:each) { do_something_else }',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
+  context 'when using after all' do
+    it 'registers an offense' do
+      expect_violation(<<-RUBY)
+        after(:all) { do_something }
+        ^^^^^^^^^^^ #{message('after(:all)')}
+        after(:context) { do_something }
+        ^^^^^^^^^^^^^^^ #{message('after(:context)')}
+      RUBY
+    end
   end
 
-  it 'does not complain for before/after :example' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  before(:example) { do_something }',
-        '  after(:example) { do_something_else }',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
+  context 'when using before each' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        before(:each) { do_something }
+        before(:example) { do_something }
+      RUBY
+    end
   end
 
-  it 'does not complain for before/after' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  before { do_something }',
-        '  after { do_something_else }',
-        'end'
-      ],
-      'foo_spec.rb'
-    )
-    expect(cop.offenses).to be_empty
+  context 'when using after each' do
+    it 'does not register an offense' do
+      expect_no_violations(<<-RUBY)
+        after(:each) { do_something }
+        after(:example) { do_something }
+      RUBY
+    end
   end
 end

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

@@ -1,4 +1,4 @@
-describe RuboCop::Cop::RSpec::DescribeClass do
+RSpec.describe RuboCop::Cop::RSpec::DescribeClass do
   subject(:cop) { described_class.new }
 
   it 'checks first-line describe statements' do

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

@@ -1,4 +1,4 @@
-describe RuboCop::Cop::RSpec::DescribeMethod do
+RSpec.describe RuboCop::Cop::RSpec::DescribeMethod do
   subject(:cop) { described_class.new }
 
   it 'ignores describes with only a class' do
@@ -8,7 +8,7 @@ describe RuboCop::Cop::RSpec::DescribeMethod do
   it 'enforces non-method names' do
     expect_violation(<<-RUBY)
       describe Some::Class, 'nope', '.incorrect_usage' do
-                            ^^^^^^ The second argument to describe should be the method being tested. '#instance' or '.class'
+                            ^^^^^^ The second argument to describe should be the method being tested. '#instance' or '.class'.
       end
     RUBY
   end

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

@@ -1,4 +1,4 @@
-describe RuboCop::Cop::RSpec::DescribedClass, :config do
+RSpec.describe RuboCop::Cop::RSpec::DescribedClass, :config do
   subject(:cop) { described_class.new(config) }
 
   let(:cop_config) do
@@ -15,7 +15,7 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
 
           before do
             MyClass
-            ^^^^^^^ Use `described_class` instead of `MyClass`
+            ^^^^^^^ Use `described_class` instead of `MyClass`.
 
             Foo.custom_block do
               MyClass
@@ -32,16 +32,16 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
         describe MyClass do
           controller(ApplicationController) do
             bar = MyClass
-                  ^^^^^^^ Use `described_class` instead of `MyClass`
+                  ^^^^^^^ Use `described_class` instead of `MyClass`.
           end
 
           before(:each) do
             MyClass
-            ^^^^^^^ Use `described_class` instead of `MyClass`
+            ^^^^^^^ Use `described_class` instead of `MyClass`.
 
             Foo.custom_block do
               MyClass
-              ^^^^^^^ Use `described_class` instead of `MyClass`
+              ^^^^^^^ Use `described_class` instead of `MyClass`.
             end
           end
         end
@@ -80,13 +80,13 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
       expect_violation(<<-RUBY)
         describe MyClass do
           include MyClass
-                  ^^^^^^^ Use `described_class` instead of `MyClass`
+                  ^^^^^^^ Use `described_class` instead of `MyClass`.
 
           subject { MyClass.do_something }
-                    ^^^^^^^ Use `described_class` instead of `MyClass`
+                    ^^^^^^^ Use `described_class` instead of `MyClass`.
 
           before { MyClass.do_something }
-                   ^^^^^^^ Use `described_class` instead of `MyClass`
+                   ^^^^^^^ Use `described_class` instead of `MyClass`.
         end
       RUBY
     end
@@ -135,7 +135,7 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
             subject { MyClass::Foo }
 
             let(:foo) { MyClass }
-                        ^^^^^^^ Use `described_class` instead of `MyClass`
+                        ^^^^^^^ Use `described_class` instead of `MyClass`.
           end
         end
       RUBY
@@ -162,7 +162,7 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
       expect_violation(<<-RUBY)
         describe MyNamespace::MyClass do
           subject { MyNamespace::MyClass }
-                    ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
+                    ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`.
         end
       RUBY
     end
@@ -222,13 +222,13 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
       expect_violation(<<-RUBY)
         describe MyClass do
           include described_class
-                  ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
+                  ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`.
 
           subject { described_class.do_something }
-                    ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
+                    ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`.
 
           before { described_class.do_something }
-                   ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
+                   ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`.
         end
       RUBY
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe RuboCop::Cop::RSpec::EmptyExampleGroup, :config do
+RSpec.describe RuboCop::Cop::RSpec::EmptyExampleGroup, :config do
   subject(:cop) { described_class.new(config) }
 
   it 'flags an empty context' do

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

@@ -1,4 +1,4 @@
-describe RuboCop::Cop::RSpec::ExampleLength, :config do
+RSpec.describe RuboCop::Cop::RSpec::ExampleLength, :config do
   subject(:cop) { described_class.new(config) }
 
   let(:cop_config) { { 'Max' => 3 } }
@@ -42,29 +42,11 @@ describe RuboCop::Cop::RSpec::ExampleLength, :config do
     RUBY
   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
     it 'flags the example' do
       expect_violation(<<-RUBY)
         it do
-        ^^^^^ Example has too many lines. [4/3]
+        ^^^^^ Example has too many lines [4/3].
           line 1
           line 2
           line 3
@@ -79,21 +61,10 @@ describe RuboCop::Cop::RSpec::ExampleLength, :config do
       { 'Max' => 3, 'CountComments' => true }
     end
 
-    let(:source) do
-      [
-        'it do',
-        '  line 1',
-        '  line 2',
-        '  # comment',
-        '  line 3',
-        'end'
-      ]
-    end
-
     it 'flags the example' do
       expect_violation(<<-RUBY)
         it do
-        ^^^^^ Example has too many lines. [4/3]
+        ^^^^^ Example has too many lines [4/3].
           line 1
           line 2
           # comment