rubocop-rspec 1.6.0 → 1.7.0

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

@@ -45,19 +45,37 @@ describe RuboCop::Cop::RSpec::ExampleWording, :config do
     end
 
     it 'corrects `it "should only have"` to it "only has"' do
-      corrected = autocorrect_source(cop, 'it "should only have trait" do end')
+      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')
+      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')
+      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

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

@@ -0,0 +1,136 @@
+# 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

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

@@ -1,71 +1,60 @@
 describe RuboCop::Cop::RSpec::FilePath, :config do
   subject(:cop) { described_class.new(config) }
 
-  it 'checks the path' do
-    inspect_source(
-      cop,
-      "describe MyClass, 'foo' do; end",
-      'wrong_path_foo_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Spec path should end with `my_class*foo*_spec.rb`'])
+  shared_examples 'invalid spec path' do |source, expected:, actual:|
+    context "when `#{source}` is defined in #{actual}" do
+      before do
+        inspect_source(cop, source, actual)
+      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 what the path should end with' do
+        expect(cop.messages).to eql(["Spec path should end with `#{expected}`"])
+      end
+    end
   end
 
-  it 'checks the path' do
-    inspect_source(
-      cop,
-      "describe MyClass, '#foo' do; end",
-      'wrong_class_foo_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Spec path should end with `my_class*foo*_spec.rb`'])
-  end
+  include_examples 'invalid spec path',
+                   "describe MyClass, 'foo' do; end",
+                   expected: 'my_class*foo*_spec.rb',
+                   actual:   'wrong_path_foo_spec.rb'
 
-  it 'flags foo_spec.rb.rb' do
-    inspect_source(
-      cop,
-      "describe MyClass, '#foo' do; end",
-      'my_class/foo_spec.rb.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-  end
+  include_examples 'invalid spec path',
+                   "describe MyClass, '#foo' do; end",
+                   expected: 'my_class*foo*_spec.rb',
+                   actual: 'wrong_class_foo_spec.rb'
 
-  it 'flags foo_specorb' do
-    inspect_source(
-      cop,
-      "describe MyClass, '#foo' do; end",
-      'my_class/foo_specorb'
-    )
-    expect(cop.offenses.size).to eq(1)
-  end
+  include_examples 'invalid spec path',
+                   "describe MyClass, '#foo' do; end",
+                   expected: 'my_class*foo*_spec.rb',
+                   actual: 'my_class/foo_spec.rb.rb'
 
-  it 'checks path even when metadata is included' do
-    inspect_source(
-      cop,
-      "describe MyClass, '#foo', blah: :blah do; end",
-      'wrong_class_foo_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Spec path should end with `my_class*foo*_spec.rb`'])
-  end
+  include_examples 'invalid spec path',
+                   "describe MyClass, '#foo' do; end",
+                   expected: 'my_class*foo*_spec.rb',
+                   actual: 'my_class/foo_specorb'
 
-  it 'checks class spec paths' do
-    inspect_source(
-      cop,
-      'describe MyClass do; end',
-      'wrong_class_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Spec path should end with `my_class*_spec.rb`'])
-  end
+  include_examples 'invalid spec path',
+                   "describe MyClass, '#foo', blah: :blah do; end",
+                   expected: 'my_class*foo*_spec.rb',
+                   actual: 'wrong_class_foo_spec.rb'
+
+  include_examples 'invalid spec path',
+                   'describe MyClass do; end',
+                   expected: 'my_class*_spec.rb',
+                   actual: 'wrong_class_spec.rb'
+
+  include_examples 'invalid spec path',
+                   'describe MyClass, :foo do; end',
+                   expected: 'my_class*_spec.rb',
+                   actual: 'wrong_class_spec.rb'
 
   it 'skips specs that do not describe a class / method' do
     inspect_source(
@@ -88,18 +77,6 @@ describe RuboCop::Cop::RSpec::FilePath, :config do
     expect(cop.offenses).to be_empty
   end
 
-  it 'ignores second argument if is not a string' do
-    inspect_source(
-      cop,
-      'describe MyClass, :foo do; end',
-      'wrong_class_spec.rb'
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Spec path should end with `my_class*_spec.rb`'])
-  end
-
   it 'checks class specs' do
     inspect_source(
       cop,

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

@@ -37,7 +37,7 @@ describe RuboCop::Cop::RSpec::Focus do
     RUBY
   end
 
-  it 'flags all repec example blocks that include `:focus`' do
+  it 'flags all rspec example blocks that include `:focus`' do
     expect_violation(<<-RUBY)
       example_group 'test', :focus do; end
                             ^^^^^^ Focused spec found.

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

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+describe RuboCop::Cop::RSpec::HookArgument, :config do
+  subject(:cop) { described_class.new(config) }
+
+  let(:cop_config) do
+    { 'EnforcedStyle' => enforced_style }
+  end
+
+  let(:enforced_style) { :implicit }
+
+  shared_examples 'ignored hooks' do
+    it 'ignores :context and :suite' do
+      expect_no_violations(<<-RUBY)
+        before(:suite) { true }
+        after(:suite) { true }
+        before(:context) { true }
+        after(:context) { true }
+      RUBY
+    end
+
+    it 'ignores hooks with more than one argument' do
+      expect_no_violations(<<-RUBY)
+        before(:each, :something_custom) { true }
+      RUBY
+    end
+
+    it 'ignores non-rspec hooks' do
+      expect_no_violations(<<-RUBY)
+        setup(:each) { true }
+      RUBY
+    end
+  end
+
+  shared_examples 'generated config' do |source, detected_style|
+    it 'generates a todo based on the detected style' do
+      inspect_source(cop, source, 'foo_spec.rb')
+
+      expect(cop.config_to_allow_offenses)
+        .to eq('EnforcedStyle' => detected_style)
+    end
+  end
+
+  shared_examples 'hook autocorrect' do |output|
+    it 'autocorrects :each to EnforcedStyle' do
+      corrected =
+        autocorrect_source(cop, 'before(:each) { }', 'spec/foo_spec.rb')
+
+      expect(corrected).to eql(output)
+    end
+
+    it 'autocorrects :example to EnforcedStyle' do
+      corrected =
+        autocorrect_source(cop, 'before(:example) { }', 'spec/foo_spec.rb')
+
+      expect(corrected).to eql(output)
+    end
+
+    it 'autocorrects :implicit to EnforcedStyle' do
+      corrected =
+        autocorrect_source(cop, 'before { }', 'spec/foo_spec.rb')
+
+      expect(corrected).to eql(output)
+    end
+  end
+
+  shared_examples 'an example hook' do
+    include_examples 'ignored hooks'
+    include_examples 'generated config', 'before(:each) { foo }', 'each'
+    include_examples 'generated config', 'before(:example) { foo }', 'example'
+    include_examples 'generated config', 'before { foo }', 'implicit'
+  end
+
+  context 'when EnforcedStyle is :implicit' do
+    let(:enforced_style) { :implicit }
+
+    it 'detects :each for hooks' do
+      expect_violation(<<-RUBY)
+        before(:each) { true }
+        ^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
+        after(:each)  { true }
+        ^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
+        around(:each) { true }
+        ^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
+      RUBY
+    end
+
+    it 'detects :example for hooks' do
+      expect_violation(<<-RUBY)
+        before(:example) { true }
+        ^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
+        after(:example)  { true }
+        ^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
+        around(:example) { true }
+        ^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
+      RUBY
+    end
+
+    it 'does not flag hooks without default scopes' do
+      expect_no_violations(<<-RUBY)
+        before { true }
+        after { true }
+        before { true }
+        after { true }
+      RUBY
+    end
+
+    include_examples 'an example hook'
+    include_examples 'hook autocorrect', 'before { }'
+  end
+
+  context 'when EnforcedStyle is :each' do
+    let(:enforced_style) { :each }
+
+    it 'detects :each for hooks' do
+      expect_no_violations(<<-RUBY)
+        before(:each) { true }
+        after(:each)  { true }
+        around(:each) { true }
+      RUBY
+    end
+
+    it 'detects :example for hooks' do
+      expect_violation(<<-RUBY)
+        before(:example) { true }
+        ^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
+        after(:example)  { true }
+        ^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
+        around(:example) { true }
+        ^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
+      RUBY
+    end
+
+    it 'does not flag hooks without default scopes' do
+      expect_violation(<<-RUBY)
+        before { true }
+        ^^^^^^ Use `:each` for RSpec hooks.
+        after { true }
+        ^^^^^ Use `:each` for RSpec hooks.
+        before { true }
+        ^^^^^^ Use `:each` for RSpec hooks.
+        after { true }
+        ^^^^^ Use `:each` for RSpec hooks.
+      RUBY
+    end
+
+    include_examples 'an example hook'
+    include_examples 'hook autocorrect', 'before(:each) { }'
+  end
+
+  context 'when EnforcedStyle is :example' do
+    let(:enforced_style) { :example }
+
+    it 'detects :example for hooks' do
+      expect_no_violations(<<-RUBY)
+        before(:example) { true }
+        after(:example)  { true }
+        around(:example) { true }
+      RUBY
+    end
+
+    it 'detects :each for hooks' do
+      expect_violation(<<-RUBY)
+        before(:each) { true }
+        ^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
+        after(:each)  { true }
+        ^^^^^^^^^^^^ Use `:example` for RSpec hooks.
+        around(:each) { true }
+        ^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
+      RUBY
+    end
+
+    it 'does not flag hooks without default scopes' do
+      expect_violation(<<-RUBY)
+        before { true }
+        ^^^^^^ Use `:example` for RSpec hooks.
+        after { true }
+        ^^^^^ Use `:example` for RSpec hooks.
+        before { true }
+        ^^^^^^ Use `:example` for RSpec hooks.
+        after { true }
+        ^^^^^ Use `:example` for RSpec hooks.
+      RUBY
+    end
+
+    include_examples 'an example hook'
+    include_examples 'hook autocorrect', 'before(:example) { }'
+  end
+end