rubocop-rspec 1.35.0 → 1.36.0

data/spec/rubocop/cop/rspec/rails/http_status_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Rails::HttpStatus, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is `symbolic`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'symbolic' } }
-
-    it 'registers an offense when using numeric value' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to have_http_status 200 }
-                                             ^^^ Prefer `:ok` over `200` to describe HTTP status code.
-      RUBY
-    end
-
-    it 'does not register an offense when using symbolic value' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status :ok }
-      RUBY
-    end
-
-    it 'does not register an offense when using custom HTTP code' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status 550 }
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status 200 }',
-                     'it { is_expected.to have_http_status :ok }'
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status 404 }',
-                     'it { is_expected.to have_http_status :not_found }'
-
-    context 'with parenthesis' do
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(200) }',
-                       'it { is_expected.to have_http_status(:ok) }'
-
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(404) }',
-                       'it { is_expected.to have_http_status(:not_found) }'
-    end
-  end
-
-  context 'when EnforcedStyle is `numeric`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'numeric' } }
-
-    it 'registers an offense when using symbolic value' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to have_http_status :ok }
-                                             ^^^ Prefer `200` over `:ok` to describe HTTP status code.
-      RUBY
-    end
-
-    it 'does not register an offense when using numeric value' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status 200 }
-      RUBY
-    end
-
-    it 'does not register an offense when using whitelisted symbols' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status :error }
-        it { is_expected.to have_http_status :success }
-        it { is_expected.to have_http_status :missing }
-        it { is_expected.to have_http_status :redirect }
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status :ok }',
-                     'it { is_expected.to have_http_status 200 }'
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status :not_found }',
-                     'it { is_expected.to have_http_status 404 }'
-
-    context 'with parenthesis' do
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(:ok) }',
-                       'it { is_expected.to have_http_status(200) }'
-
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(:not_found) }',
-                       'it { is_expected.to have_http_status(404) }'
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ReceiveCounts do
-  subject(:cop) { described_class.new }
-
-  it 'flags usage of `exactly(1).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(1).times
-                                  ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).once
-    RUBY
-  end
-
-  it 'flags usage of `exactly(2).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(2).times
-                                  ^^^^^^^^^^^^^^^^^ Use `.twice` instead of `.exactly(2).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).twice
-    RUBY
-  end
-
-  it 'allows `exactly(3).times`' do
-    expect_no_offenses(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(3).times
-    RUBY
-  end
-
-  it 'allows `exactly(n).times`' do
-    expect_no_offenses(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(n).times
-    RUBY
-  end
-
-  it 'flags usage of `exactly(1).times` after `with`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).with(baz).exactly(1).times
-                                            ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).with(baz).once
-    RUBY
-  end
-
-  it 'flags usage of `exactly(1).times` with return value' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(1).times.and_return(true)
-                                  ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).once.and_return(true)
-    RUBY
-  end
-
-  it 'flags usage of `exactly(1).times` with a block' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).exactly(1).times { true }
-                                  ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).once { true }
-    RUBY
-  end
-
-  it 'flags usage of `at_least(1).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(1).times
-                                  ^^^^^^^^^^^^^^^^^^ Use `.at_least(:once)` instead of `.at_least(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(:once)
-    RUBY
-  end
-
-  it 'flags usage of `at_least(2).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(2).times
-                                  ^^^^^^^^^^^^^^^^^^ Use `.at_least(:twice)` instead of `.at_least(2).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(:twice)
-    RUBY
-  end
-
-  it 'flags usage of `at_least(2).times` with a block' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(2).times { true }
-                                  ^^^^^^^^^^^^^^^^^^ Use `.at_least(:twice)` instead of `.at_least(2).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).at_least(:twice) { true }
-    RUBY
-  end
-
-  it 'flags usage of `at_most(1).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).at_most(1).times
-                                  ^^^^^^^^^^^^^^^^^ Use `.at_most(:once)` instead of `.at_most(1).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).at_most(:once)
-    RUBY
-  end
-
-  it 'flags usage of `at_most(2).times`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).at_most(2).times
-                                  ^^^^^^^^^^^^^^^^^ Use `.at_most(:twice)` instead of `.at_most(2).times`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).to receive(:bar).at_most(:twice)
-    RUBY
-  end
-
-  it 'allows exactly(1).times when not called on `receive`' do
-    expect_no_offenses(<<-RUBY)
-      expect(action).to have_published_event.exactly(1).times
-    RUBY
-  end
-
-  # Does not auto-correct if not part of the RSpec API
-  include_examples 'autocorrect',
-                   'expect(foo).to have_published_event(:bar).exactly(2).times',
-                   'expect(foo).to have_published_event(:bar).exactly(2).times'
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ReceiveNever do
-  subject(:cop) { described_class.new }
-
-  it 'flags usage of `never`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).never
-                                   ^^^^^ Use `not_to receive` instead of `never`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).not_to receive(:bar)
-    RUBY
-  end
-
-  it 'flags usage of `never` after `with`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to receive(:bar).with(baz).never
-                                             ^^^^^ Use `not_to receive` instead of `never`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect(foo).not_to receive(:bar).with(baz)
-    RUBY
-  end
-
-  it 'flags usage of `never` with `is_expected`' do
-    expect_offense(<<-RUBY)
-      is_expected.to receive(:bar).with(baz).never
-                                             ^^^^^ Use `not_to receive` instead of `never`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      is_expected.not_to receive(:bar).with(baz)
-    RUBY
-  end
-
-  it 'flags usage of `never` with `expect_any_instance_of`' do
-    expect_offense(<<-RUBY)
-      expect_any_instance_of(Foo).to receive(:bar).with(baz).never
-                                                             ^^^^^ Use `not_to receive` instead of `never`.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      expect_any_instance_of(Foo).not_to receive(:bar).with(baz)
-    RUBY
-  end
-
-  it 'allows method called `never`' do
-    expect_no_offenses(<<-RUBY)
-      expect(foo).to receive(:bar).with(Value.never)
-      expect(foo.never).to eq(bar.never)
-      is_expected.to be never
-    RUBY
-  end
-end

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::RepeatedDescription do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for repeated descriptions' do
-    expect_offense(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-        ^^^^^^^^^^^ Don't repeat descriptions within an example group.
-        end
-
-        it "does x" do
-        ^^^^^^^^^^^ Don't repeat descriptions within an example group.
-        end
-      end
-    RUBY
-  end
-
-  it 'registers offense for repeated descriptions separated by a context' do
-    expect_offense(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-        ^^^^^^^^^^^ Don't repeat descriptions within an example group.
-        end
-
-        context 'during some use case' do
-          it "does x" do
-            # this should be fine
-          end
-        end
-
-        it "does x" do
-        ^^^^^^^^^^^ Don't repeat descriptions within an example group.
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores descriptions repeated in a shared context' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-        end
-
-        shared_context 'shared behavior' do
-          it "does x" do
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'ignores repeated descriptions in a nested context' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-        end
-
-        context 'in a certain use case' do
-          it "does x" do
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag tests which do not contain description strings' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it { foo }
-        it { bar }
-      end
-    RUBY
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::RepeatedExample do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for repeated example' do
-    expect_offense(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-        ^^^^^^^^^^^^^^ Don't repeat examples within an example group.
-          expect(foo).to be(bar)
-        end
-
-        it "does y" do
-        ^^^^^^^^^^^^^^ Don't repeat examples within an example group.
-          expect(foo).to be(bar)
-        end
-      end
-    RUBY
-  end
-
-  it 'does not register a violation if rspec tag magic is involved' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-          expect(foo).to be(bar)
-        end
-
-        it "does y", :focus do
-          expect(foo).to be(bar)
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag examples with different implementations' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-          expect(foo).to have_attribute(foo: 1)
-        end
-
-        it "does y" do
-          expect(foo).to have_attribute(bar: 2)
-        end
-      end
-    RUBY
-  end
-
-  it 'does not flag examples when different its arguments are used' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        its(:x) { is_expected.to be_present }
-        its(:y) { is_expected.to be_present }
-      end
-    RUBY
-  end
-
-  it 'does not flag repeated examples in different scopes' do
-    expect_no_offenses(<<-RUBY)
-      describe 'doing x' do
-        it "does x" do
-          expect(foo).to be(bar)
-        end
-
-        context 'when the scope changes' do
-          it 'does not flag anything' do
-            expect(foo).to be(bar)
-          end
-        end
-      end
-    RUBY
-  end
-end

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

@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::ReturnFromStub, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) do
-    { 'EnforcedStyle' => enforced_style }
-  end
-
-  context 'with EnforcedStyle `and_return`' do
-    let(:enforced_style) { 'and_return' }
-
-    it 'finds static values returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { 42 }
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(42)
-        end
-      RUBY
-    end
-
-    it 'finds empty values returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) {}
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(nil)
-        end
-      RUBY
-    end
-
-    it 'finds array with only static values returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { [42, 43] }
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return([42, 43])
-        end
-      RUBY
-    end
-
-    it 'finds hash with only static values returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { {a: 42, b: 43} }
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return({a: 42, b: 43})
-        end
-      RUBY
-    end
-
-    it 'finds static values in a block when there are chained methods' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Question).to receive(:meaning).with(:universe) { 42 }
-                                                               ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Question).to receive(:meaning).with(:universe).and_return(42)
-        end
-      RUBY
-    end
-
-    it 'finds constants returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { Life::MEANING }
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(Life::MEANING)
-        end
-      RUBY
-    end
-
-    it 'finds nested constants returned from block' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { {Life::MEANING => 42} }
-                                      ^ Use `and_return` for static values.
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return({Life::MEANING => 42})
-        end
-      RUBY
-    end
-
-    it 'ignores dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { baz }
-        end
-      RUBY
-    end
-
-    it 'ignores variables return from block' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          $bar = 42
-          baz = 123
-          allow(Foo).to receive(:bar) { $bar }
-          allow(Foo).to receive(:baz) { baz }
-        end
-      RUBY
-    end
-
-    it 'ignores array with dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { [42, baz] }
-        end
-      RUBY
-    end
-
-    it 'ignores hash with dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) { {a: 42, b: baz} }
-        end
-      RUBY
-    end
-
-    it 'ignores block returning string with interpolation' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          bar = 42
-          allow(Foo).to receive(:bar) { "You called \#{bar}" }
-        end
-      RUBY
-    end
-
-    it 'finds concatenated strings with no variables' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar) do
-                                      ^^ Use `and_return` for static values.
-            "You called" \
-            "me"
-          end
-        end
-      RUBY
-
-      expect_correction(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return("You called" \
-            "me")
-        end
-      RUBY
-    end
-
-    it 'ignores stubs without return value' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar)
-        end
-      RUBY
-    end
-
-    it 'handles stubs in a method' do
-      expect_no_offenses(<<-RUBY)
-        def stub_foo
-          allow(Foo).to receive(:bar)
-        end
-      RUBY
-    end
-  end
-
-  context 'with EnforcedStyle `block`' do
-    let(:enforced_style) { 'block' }
-
-    it 'finds static values returned from method' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(42)
-                                      ^^^^^^^^^^ Use block for static values.
-        end
-      RUBY
-    end
-
-    it 'finds static values returned from chained method' do
-      expect_offense(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).with(1).and_return(42)
-                                              ^^^^^^^^^^ Use block for static values.
-        end
-      RUBY
-    end
-
-    it 'ignores dynamic values returned from method' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(baz)
-        end
-      RUBY
-    end
-
-    it 'ignores string with interpolation returned from method' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          bar = 42
-          allow(Foo).to receive(:bar).and_return("You called \#{bar}")
-        end
-      RUBY
-    end
-
-    it 'ignores multiple values being returned from method' do
-      expect_no_offenses(<<-RUBY)
-        it do
-          allow(Foo).to receive(:bar).and_return(42, 43, 44)
-        end
-      RUBY
-    end
-
-    it 'finds hash with only static values returned from method' do
-      expect_offense(<<-RUBY)
-        allow(Foo).to receive(:bar).and_return({ foo: 42 })
-                                    ^^^^^^^^^^ Use block for static values.
-        allow(Foo).to receive(:bar).and_return(foo: 42)
-                                    ^^^^^^^^^^ Use block for static values.
-        allow(Foo).to receive(:bar).and_return(
-                                    ^^^^^^^^^^ Use block for static values.
-          a: 42,
-          b: 43
-        )
-      RUBY
-
-      expect_correction(<<-RUBY) # Not perfect, but good enough.
-        allow(Foo).to receive(:bar) { { foo: 42 } }
-        allow(Foo).to receive(:bar) { { foo: 42 } }
-        allow(Foo).to receive(:bar) { { a: 42,
-          b: 43 } }
-      RUBY
-    end
-
-    it 'finds nil returned from method' do
-      expect_offense(<<-RUBY)
-        allow(Foo).to receive(:bar).and_return(nil)
-                                    ^^^^^^^^^^ Use block for static values.
-      RUBY
-
-      expect_correction(<<-RUBY)
-        allow(Foo).to receive(:bar) { nil }
-      RUBY
-    end
-
-    it 'finds concatenated strings with no variables' do
-      expect_offense(<<-RUBY)
-        allow(Foo).to receive(:bar).and_return('You called ' \\
-                                    ^^^^^^^^^^ Use block for static values.
-          'me')
-      RUBY
-
-      expect_correction(<<-RUBY)
-        allow(Foo).to receive(:bar) { 'You called ' \\
-          'me' }
-      RUBY
-    end
-  end
-end