rubocop-rspec 1.35.0 → 1.36.0

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::VerifiedDoubles, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'finds a `double` instead of an `instance_double`' do
-    expect_offense(<<-RUBY)
-      it do
-        foo = double("Widget")
-              ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-      end
-    RUBY
-  end
-
-  context 'when configuration does not specify IgnoreSymbolicNames' do
-    let(:cop_config) { {} }
-
-    it 'find doubles whose name is a symbol' do
-      expect_offense(<<-RUBY)
-        it do
-          foo = double(:widget)
-                ^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-
-    it 'finds a `spy` instead of an `instance_spy`' do
-      expect_offense(<<-RUBY)
-        it do
-          foo = spy("Widget")
-                ^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-  end
-
-  context 'when configured to ignore symbolic names' do
-    let(:cop_config) { { 'IgnoreSymbolicNames' => true } }
-
-    it 'ignores doubles whose name is a symbol' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          foo = double(:widget)
-        end
-      RUBY
-    end
-
-    it 'still flags doubles whose name is a string' do
-      expect_offense(<<-RUBY)
-        it do
-          foo = double("widget")
-                ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
-        end
-      RUBY
-    end
-  end
-
-  it 'doubles that have no name specified' do
-    expect_offense(<<-RUBY)
-      it do
-        foo = double
-              ^^^^^^ Prefer using verifying doubles over normal doubles.
-      end
-    RUBY
-  end
-
-  context 'when configured to ignore nameless doubles' do
-    let(:cop_config) { { 'IgnoreNameless' => true } }
-
-    it 'ignores doubles that have no name specified' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          foo = double
-        end
-      RUBY
-    end
-  end
-
-  it 'ignores instance_doubles' do
-    expect_no_offenses(<<-RUBY)
-      it do
-        foo = instance_double("Foo")
-      end
-    RUBY
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::VoidExpect do
-  subject(:cop) { described_class.new }
-
-  it 'registers offenses to void `expect`' do
-    expect_offense(<<-RUBY)
-      it 'something' do
-        something = 1
-        expect(something)
-        ^^^^^^^^^^^^^^^^^ Do not use `expect()` without `.to` or `.not_to`. Chain the methods or remove it.
-      end
-    RUBY
-  end
-
-  it 'registers offenses to void `expect` when block has one expression' do
-    expect_offense(<<-RUBY)
-      it 'something' do
-        expect(something)
-        ^^^^^^^^^^^^^^^^^ Do not use `expect()` without `.to` or `.not_to`. Chain the methods or remove it.
-      end
-    RUBY
-  end
-
-  it 'registers offenses to void `expect` with block' do
-    expect_offense(<<-RUBY)
-      it 'something' do
-        expect{something}
-        ^^^^^^^^^^^^^^^^^ Do not use `expect()` without `.to` or `.not_to`. Chain the methods or remove it.
-      end
-    RUBY
-  end
-
-  it 'accepts non-void `expect`' do
-    expect_no_offenses(<<-RUBY)
-      it 'something' do
-        expect(something).to be 1
-      end
-    RUBY
-  end
-
-  it 'accepts non-void `expect` with block' do
-    expect_no_offenses(<<-RUBY)
-      it 'something' do
-        expect{something}.to raise_error(StandardError)
-      end
-    RUBY
-  end
-end

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Yield do
-  subject(:cop) { described_class.new }
-
-  it 'flags `block.call`' do
-    expect_offense(<<-RUBY)
-      allow(foo).to receive(:bar) { |&block| block.call }
-                                  ^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      allow(foo).to receive(:bar).and_yield
-    RUBY
-  end
-
-  it 'flags multiple `block.call`' do
-    expect_offense(<<-RUBY)
-      allow(foo).to receive(:bar) do |&block|
-                                  ^^^^^^^^^^^ Use `.and_yield`.
-        block.call
-        block.call
-      end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      allow(foo).to receive(:bar).and_yield.and_yield
-    RUBY
-  end
-
-  it 'flags `block.call` with arguments' do
-    expect_offense(<<-RUBY)
-      allow(foo).to receive(:bar) { |&block| block.call(1, 2) }
-                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      allow(foo).to receive(:bar).and_yield(1, 2)
-    RUBY
-  end
-
-  it 'flags multiple `block.call` with arguments' do
-    expect_offense(<<-RUBY)
-      allow(foo).to receive(:bar) do |&block|
-                                  ^^^^^^^^^^^ Use `.and_yield`.
-         block.call(1)
-         block.call(2)
-       end
-    RUBY
-
-    expect_correction(<<-RUBY)
-      allow(foo).to receive(:bar).and_yield(1).and_yield(2)
-    RUBY
-  end
-
-  it 'flags `block.call` when `receive` is chained' do
-    expect_offense(<<-RUBY)
-      allow(foo).to receive(:bar).with(anything) { |&block| block.call }
-                                                 ^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      allow(foo).to receive(:bar).with(anything).and_yield
-    RUBY
-  end
-
-  it 'ignores `receive` with no block arguments' do
-    expect_no_offenses(<<-RUBY)
-      allow(foo).to receive(:bar) { |block| block.call }
-    RUBY
-  end
-
-  it 'ignores stub when `block.call` is not the only statement' do
-    expect_no_offenses(<<-RUBY)
-      allow(foo).to receive(:bar) do |&block|
-        result = block.call
-        transform(result)
-      end
-    RUBY
-  end
-end

data/spec/rubocop/rspec/config_formatter_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop/rspec/config_formatter'
-
-RSpec.describe RuboCop::RSpec::ConfigFormatter do
-  let(:config) do
-    {
-      'AllCops' => {
-        'Setting' => 'fourty two'
-      },
-      'RSpec/Foo' => {
-        'Config'      => 2,
-        'Enabled'     => true
-      },
-      'RSpec/Bar' => {
-        'Enabled'     => true
-      }
-    }
-  end
-
-  let(:descriptions) do
-    {
-      'RSpec/Foo' => {
-        'Description' => 'Blah'
-      },
-      'RSpec/Bar' => {
-        'Description' => 'Wow'
-      }
-    }
-  end
-
-  it 'builds a YAML dump with spacing between cops' do
-    formatter = described_class.new(config, descriptions)
-
-    expect(formatter.dump).to eql(<<-YAML.gsub(/^\s+\|/, ''))
-      |---
-      |AllCops:
-      |  Setting: fourty two
-      |
-      |RSpec/Foo:
-      |  Config: 2
-      |  Enabled: true
-      |  Description: Blah
-      |  StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Foo
-      |
-      |RSpec/Bar:
-      |  Enabled: true
-      |  Description: Wow
-      |  StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Bar
-    YAML
-  end
-end

data/spec/rubocop/rspec/description_extractor_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'yard'
-
-require 'rubocop/rspec/description_extractor'
-
-RSpec.describe RuboCop::RSpec::DescriptionExtractor do
-  let(:yardocs) do
-    YARD.parse_string(<<-RUBY)
-      # This is not a cop
-      class RuboCop::Cop::Mixin::Sneaky
-      end
-
-      # This is not a concrete cop
-      #
-      # @abstract
-      class RuboCop::Cop::RSpec::Cop
-      end
-
-      # Checks foo
-      #
-      # Some description
-      #
-      # @note only works with foo
-      class RuboCop::Cop::RSpec::Foo < RuboCop::Cop::RSpec::Cop
-        # Hello
-        def bar
-        end
-
-        # :nodoc:
-        class HelperClassForFoo
-        end
-      end
-
-      class RuboCop::Cop::RSpec::Undocumented < RuboCop::Cop::RSpec::Cop
-        # Hello
-        def bar
-        end
-      end
-    RUBY
-
-    YARD::Registry.all
-  end
-
-  def stub_cop_const(name)
-    stub_const(
-      "RuboCop::Cop::RSpec::#{name}",
-      Class.new(RuboCop::Cop.const_get(:WorkaroundCop))
-    )
-  end
-
-  before do
-    stub_cop_const('Foo')
-    stub_cop_const('Undocumented')
-  end
-
-  it 'builds a hash of descriptions' do
-    expect(described_class.new(yardocs).to_h).to eql(
-      'RSpec/Foo'          => { 'Description' => 'Checks foo' },
-      'RSpec/Undocumented' => { 'Description' => ''           }
-    )
-  end
-end

data/spec/rubocop/rspec/example_group_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::ExampleGroup do
-  include RuboCop::AST::Sexp
-
-  subject(:group) { described_class.new(parse_source(source).ast) }
-
-  let(:source) do
-    <<-RUBY
-      RSpec.describe Foo do
-        it 'does x' do
-          x
-        end
-
-        it 'does y' do
-          y
-        end
-
-        context 'nested' do
-          it 'does z' do
-            z
-          end
-        end
-      end
-    RUBY
-  end
-
-  let(:example_nodes) do
-    [
-      s(:block,
-        s(:send, nil, :it,
-          s(:str, 'does x')),
-        s(:args), s(:send, nil, :x)),
-      s(:block,
-        s(:send, nil, :it,
-          s(:str, 'does y')),
-        s(:args), s(:send, nil, :y))
-    ].map { |node| RuboCop::RSpec::Example.new(node) }
-  end
-
-  it 'exposes examples in scope' do
-    expect(group.examples).to eql(example_nodes)
-  end
-end

data/spec/rubocop/rspec/example_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Example do
-  include RuboCop::AST::Sexp
-
-  def example(source)
-    described_class.new(parse_source(source).ast)
-  end
-
-  it 'extracts doc string' do
-    expect(example("it('does x') { foo }").doc_string)
-      .to eq(s(:str, 'does x'))
-  end
-
-  it 'extracts doc string for unimplemented examples' do
-    expect(example("it('does x')").doc_string)
-      .to eq(s(:str, 'does x'))
-  end
-
-  it 'returns nil for examples without doc strings' do
-    expect(example('it { foo }').doc_string).to be(nil)
-  end
-
-  it 'extracts keywords' do
-    expect(example("it('foo', :bar, baz: :qux) { a }").metadata)
-      .to eq([s(:sym, :bar), s(:hash, s(:pair, s(:sym, :baz), s(:sym, :qux)))])
-  end
-
-  it 'extracts implementation' do
-    expect(example('it("foo") { bar; baz }').implementation)
-      .to eq(s(:begin, s(:send, nil, :bar), s(:send, nil, :baz)))
-  end
-
-  it 'returns node' do
-    node = s(:sym, :node)
-    expect(described_class.new(node).to_node).to be(node)
-  end
-
-  describe 'value object semantics' do
-    it 'compares by value' do
-      aggregate_failures 'equality semantics' do
-        expect(example('it("foo")')).to eq(example('it("foo")'))
-        expect(example('it("foo")')).not_to eq(example('it("bar")'))
-      end
-    end
-
-    it 'can be used as a key in a hash' do
-      hash = {}
-
-      hash[example('it("foo")')] = 123
-
-      expect(hash[example('it("foo")')]).to be(123)
-    end
-
-    it 'computes #hash based on class and node' do
-      node = s(:node)
-
-      expect(described_class.new(node).hash)
-        .to eql([described_class, node].hash)
-    end
-  end
-end

data/spec/rubocop/rspec/hook_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Hook do
-  include RuboCop::AST::Sexp
-
-  def hook(source)
-    described_class.new(parse_source(source).ast)
-  end
-
-  it 'extracts name' do
-    expect(hook('around(:each) { }').name).to be(:around)
-  end
-
-  it 'does not break if a hook is not given a symbol literal' do
-    expect(hook('before(scope) { example_setup }').knowable_scope?).to be(false)
-  end
-
-  it 'knows the scope of a hook with a symbol literal' do
-    expect(hook('before { example_setup }').knowable_scope?).to be(true)
-  end
-
-  it 'ignores other arguments to hooks' do
-    expect(hook('before(:each, :metadata) { example_setup }').scope)
-      .to be(:each)
-  end
-
-  it 'classifies nonstandard hook arguments as invalid' do
-    expect(hook('before(:nothing) { example_setup }').valid_scope?).to be(false)
-  end
-
-  it 'classifies :each as a valid hook argument' do
-    expect(hook('before(:each) { example_setup }').valid_scope?).to be(true)
-  end
-
-  it 'classifies :each as an example hook' do
-    expect(hook('before(:each) { }').example?).to be(true)
-  end
-
-  shared_examples 'standardizes scope' do |source, scope|
-    it "interprets #{source} as having scope #{scope}" do
-      expect(hook(source).scope).to equal(scope)
-    end
-  end
-
-  include_examples 'standardizes scope', 'before(:each) { }',    :each
-  include_examples 'standardizes scope', 'around(:example) { }', :each
-  include_examples 'standardizes scope', 'after { }',            :each
-
-  include_examples 'standardizes scope', 'before(:all) { }',     :context
-  include_examples 'standardizes scope', 'around(:context) { }', :context
-
-  include_examples 'standardizes scope', 'after(:suite) { }', :suite
-end