rubocop-rspec 1.35.0 → 1.36.0

data/spec/rubocop/rspec/language/selector_set_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Language::SelectorSet do
-  subject(:selector_set) { described_class.new(%i[foo bar]) }
-
-  it 'composes sets' do
-    combined = selector_set + described_class.new(%i[baz])
-
-    expect(combined).to eq(described_class.new(%i[foo bar baz]))
-  end
-
-  it 'compares by value' do
-    expect(selector_set).not_to eq(described_class.new(%i[foo bar baz]))
-  end
-
-  describe '#include?' do
-    it 'returns false for selectors not in the set' do
-      expect(selector_set.include?(:baz)).to be(false)
-    end
-
-    it 'returns true for selectors in the set' do
-      expect(selector_set.include?(:foo)).to be(true)
-    end
-  end
-
-  describe '#node_pattern' do
-    it 'builds a node pattern' do
-      expect(selector_set.node_pattern).to eql(':foo :bar')
-    end
-  end
-
-  describe '#node_pattern_union' do
-    it 'builds a node pattern union' do
-      expect(selector_set.node_pattern_union).to eql('{:foo :bar}')
-    end
-  end
-
-  describe '#send_pattern' do
-    it 'builds a send matching pattern' do
-      expect(selector_set.send_pattern).to eql(
-        '(send {(const {nil? cbase} :RSpec) nil?} {:foo :bar} ...)'
-      )
-    end
-  end
-
-  describe '#block_pattern' do
-    it 'builds a block matching pattern' do
-      expect(selector_set.block_pattern).to eql(
-        '(block (send {(const {nil? cbase} :RSpec) nil?} {:foo :bar} ...) ...)'
-      )
-    end
-  end
-end

data/spec/rubocop/rspec/util/one_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Util, '.one' do
-  let(:first)  { instance_double(Object)                          }
-  let(:array)  { instance_double(Array, one?: true, first: first) }
-  let(:client) { Class.new.extend(described_class)                }
-
-  it 'returns first element' do
-    expect(client.one(array)).to be(first)
-  end
-
-  it 'fails if the list is empty' do
-    expect { client.one([]) }
-      .to raise_error(described_class::SizeError)
-      .with_message('expected size to be exactly 1 but size was 0')
-  end
-
-  it 'fails if the list has more than one element' do
-    expect { client.one([1, 2]) }
-      .to raise_error(described_class::SizeError)
-      .with_message('expected size to be exactly 1 but size was 2')
-  end
-end

data/spec/rubocop/rspec/wording_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Wording do
-  let(:replacements) { { 'have' => 'has' } }
-  let(:ignores)      { %w[only really]     }
-
-  expected_rewrites =
-    {
-      'should return something'            => 'returns something',
-      'should not return something'        => 'does not return something',
-      'should do nothing'                  => 'does nothing',
-      'should have sweets'                 => 'has sweets',
-      'should worry about the future'      => 'worries about the future',
-      'should pay for pizza'               => 'pays for pizza',
-      'should obey my orders'              => 'obeys my orders',
-      'should deploy the app'              => 'deploys the app',
-      'should buy the product'             => 'buys the product',
-      'should miss me'                     => 'misses me',
-      'should fax the document'            => 'faxes the document',
-      'should amass debt'                  => 'amasses debt',
-      'should echo the input'              => 'echoes the input',
-      'should alias the method'            => 'aliases the method',
-      'should search the internet'         => 'searches the internet',
-      'should wish me luck'                => 'wishes me luck',
-      'should really only return one item' => 'really only returns one item',
-      "shouldn't return something"         => 'does not return something',
-      'SHOULD RETAIN UPPERCASE'            => 'RETAINS UPPERCASE',
-      "shouldn't be true"                  => 'is not true',
-      "SHOULDN'T BE true"                  => 'IS NOT true',
-      "SHOULDN'T NOT RETAIN UPPERCASE"     => 'DOES NOT NOT RETAIN UPPERCASE',
-      'should WORRY'                       => 'WORRIES',
-      'should WISH me luck'                => 'WISHES me luck',
-      ''                                   => '',
-      'should'                             => '',
-      "shouldn't"                          => 'does not',
-      'should not'                         => 'does not',
-      'should fizz'                        => 'fizzes'
-    }
-
-  expected_rewrites.each do |old, new|
-    it %(rewrites "#{old}" as "#{new}") do
-      rewrite =
-        described_class.new(
-          old,
-          replace: replacements,
-          ignore:  ignores
-        ).rewrite
-
-      expect(rewrite).to eql(new)
-    end
-  end
-end

data/spec/shared/autocorrect_behavior.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'autocorrect' do |original, corrected|
-  it "autocorrects `#{original}` to `#{corrected}`" do
-    autocorrected = autocorrect_source(original, 'spec/foo_spec.rb')
-
-    expect(autocorrected).to eql(corrected)
-  end
-end

data/spec/shared/detects_style_behavior.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'detects style' do |source, style, filename: 'x_spec.rb'|
-  it 'generates a todo based on the detected style' do
-    inspect_source(source, filename)
-
-    expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => style)
-  end
-end

data/spec/shared/smoke_test_examples.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'smoke test', type: :cop_spec do
-  context 'with default configuration' do
-    # This is overridden to avoid a number of specs that define `cop_config`
-    # (so it is referenced in the 'config' shared context) but do not define
-    # all of the dependent configuration options until inside of a context
-    # that is out of scope, causing a NameError.
-    let(:cop_config) { {} }
-
-    stress_tests = Pathname.glob('spec/smoke_tests/*.rb')
-
-    raise 'No smoke tests could be found!' if stress_tests.empty?
-
-    stress_tests.each do |path|
-      it "does not crash on smoke test: #{path}" do
-        source    = path.read
-        file_name = path.to_s
-
-        aggregate_failures do
-          expect { inspect_source(source, file_name) }.not_to raise_error
-          expect { autocorrect_source(source, file_name) }.not_to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/smoke_tests/factory_bot_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-# Since FactoryBot is not a dependency, none of this should be executed. We just
-# need the AST to exist.
-if false
-  FactoryBot.define do
-    factory :foo do
-      bar {}
-    end
-  end
-end

data/spec/smoke_tests/no_tests_spec.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal:
-
-# This is sort of a test, but there's no rspec to see here.
-raise 'Uh oh, the Party seems to have gotten into ruby.' if 2 + 2 == 5

data/spec/smoke_tests/weird_rspec_spec.rb

@@ -1,233 +0,0 @@
-RSpec.describe 'Weirdness' do
-  subject! { nil }
-  subject { nil }
-  subject(:foo) { nil }
-  subject!(:foo) { nil }
-
-  subject! (:foo) { |something| nil }
-  subject  :foo  do end
-
-  let(:foo) { |something| something }
-  let (:foo) { 1 }
-  let!   (:bar){}
-
-  let :a do end
-
-  let(:bar) { <<-HEREDOC }
-    What a pain.
-  HEREDOC
-
-  let(:bar) { <<-'HEREDOC' }
-    Even odder.
-  HEREDOC
-
-  let(:baz) do
-    <<-INSIDE
-      Hi. I'm in your lets.
-    INSIDE
-  end
-
-  let(:hi)      {}
-  let(:bye) do
-  end
-
-  let(:doop) { foo; 1 }
-
-  it {}
-  specify {}
-
-  it 'works', metadata: true do
-  end
-
-  describe {}
-  context {}
-
-  describe '#nothing' do
-  end
-
-  it 'is empty' do
-  end
-
-  it '' do end
-  describe do end
-  context do end
-  shared_examples 'a' do end
-
-  describe 'things' do
-    context 'with context' do
-    end
-  end
-
-  shared_examples 'weird rspec' do
-  end
-
-  shared_examples :something do
-  end
-
-  context 'test' do
-    include_examples 'weird rspec'
-    include_examples('weird rspec', serious: true) do
-      it_behaves_like :something
-    end
-  end
-
-  it_behaves_like :something
-  it_should_behave_like :something
-
-  it_behaves_like :something do
-    let(:foo) { 'bar' }
-  end
-
-  it_behaves_like(:something) do |arg, *args, &block|
-  end
-
-  before {}
-  context 'never run' do
-    around {}
-  end
-  after {}
-
-  before { <<-DOC }
-   Eh, what's up?
-  DOC
-
-  around { |test| test.run; <<-DOC }
-   Eh, what's up?
-  DOC
-
-  after { <<-DOC }
-   Eh, what's up?
-  DOC
-
-  around do |test|
-    test.run
-  end
-
-  it 'is expecting you' do
-    expect('you').to eql('you')
-  end
-
-  it 'is expecting you not to raise an error' do
-    expect { 'you' }.not_to raise_error
-  end
-
-  it 'has chained expectations' do
-    expect('you').to eql('you').and(match(/y/))
-  end
-
-  %w[who likes dynamic examples].each do |word|
-    let(word) { word }
-
-    describe "#{word}" do
-      context "#{word}" do
-        it "lets the word '#{word}' be '#{word}'" do
-          expect(send(word)).to eql(word)
-        end
-      end
-    end
-  end
-
-  it { foo; 1 && 2}
-  it('has a description too') { foo; 1 && 2}
-
-  it %{quotes a string weird} do
-  end
-
-  it((' '.strip! ; 1 && 'isnt a simple string')) do
-    expect(nil).to be(nil)
-  end
-
-  it((' '.strip! ; 1 && 'isnt a simple string')) do
-    double = double(:foo)
-
-    allow(double).to receive(:oogabooga).with(nil).and_return(nil)
-
-    expect(double.oogabooga(nil)).to be(nil)
-
-    expect(double).to have_received(:oogabooga).once
-  end
-
-  it 'uses a matcher' do
-    expect([].empty?).to be(true)
-    expect([]).to be_empty
-  end
-
-  let(:klass) do
-    Class.new do
-      def initialize(thing)
-        @thing = thing
-      end
-
-      def announce
-        'wooo, so dynamic!'
-      end
-    end
-  end
-
-  it 'it does a thing' do
-  end
-
-  it 'It does a thing' do
-  end
-
-  it 'should not do the thing' do
-  end
-
-  specify do
-    foo = double(:bar)
-    allow(foo).to receive_message_chain(bar: 42, baz: 42)
-    allow(foo).to receive(:bar)
-    allow(foo).to receive_messages(bar: 42, baz: 42)
-  end
-end
-
-RSpec.describe {}
-RSpec.shared_examples('pointless') {}
-RSpec.shared_context('even pointless-er') {}
-RSpec.describe do end
-RSpec.shared_examples('pointless2') do end
-RSpec.shared_context('even pointless-er2') do end
-
-class Broken
-end
-
-RSpec.describe Broken do
-end
-
-RSpec.describe 'RubocopBug' do
-  subject { true }
-
-  before do
-    each_row = allow(double(:exporter)).to receive(:each_row)
-
-    [1, 2].each do |sig|
-      each_row = each_row.and_yield(sig)
-    end
-  end
-
-  it 'has a single example' do
-    expect(subject).to be_truthy
-  end
-
-  it 'has an expectation' do
-    stats = double(event: nil)
-
-    stats.event('tada!')
-
-    expect(stats)
-      .to have_received(:event)
-      .with('tada!')
-  end
-end
-
-RSpec.describe do
-  let(:uh_oh) { <<-HERE.strip + ", #{<<-THERE.strip}" }
-      Seriously
-  HERE
-      who designed these things?
-  THERE
-
-  it 'is insane' do
-    expect(uh_oh).to eql('Seriously, who designed these things?')
-  end
-end

data/spec/spec_helper.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop'
-
-require 'rubocop/rspec/support'
-
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  SimpleCov.start
-end
-
-module SpecHelper
-  ROOT = Pathname.new(__dir__).parent.freeze
-end
-
-spec_helper_glob = File.expand_path('{support,shared}/*.rb', __dir__)
-Dir.glob(spec_helper_glob).map(&method(:require))
-
-RSpec.configure do |config|
-  config.define_derived_metadata(file_path: %r{/spec/rubocop/cop/}) do |meta|
-    meta[:type] = :cop_spec
-  end
-
-  config.order = :random
-
-  # Forbid RSpec from monkey patching any of our objects
-  config.disable_monkey_patching!
-
-  # We should address configuration warnings when we upgrade
-  config.raise_errors_for_deprecations!
-
-  # RSpec gives helpful warnings when you are doing something wrong.
-  # We should take their advice!
-  config.raise_on_warning = true
-
-  config.include(ExpectOffense)
-end
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'rubocop-rspec'