rubocop-airbnb 4.0.0 → 6.0.0

data/spec/rubocop/cop/airbnb/opt_arg_parameter_spec.rb

@@ -1,103 +1,76 @@
-describe RuboCop::Cop::Airbnb::OptArgParameters do
-  subject(:cop) { described_class.new }
-
+describe RuboCop::Cop::Airbnb::OptArgParameters, :config do
   it 'allows method with no parameters' do
-    source = [
-      'def my_method',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method
+      end
+    RUBY
   end
 
   it 'allows method with one parameter' do
-    source = [
-      'def my_method(params)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method(params)
+      end
+    RUBY
   end
 
   it 'allows method with one parameter with a default hash value' do
-    source = [
-      'def my_method(params = {})',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method(params = {})
+      end
+    RUBY
   end
 
   it 'allows method named default parameters' do
-    source = [
-      'def my_method(a, b, c: 5, d: 6)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method(a, b, c: 5, d: 6)
+      end
+    RUBY
   end
 
   it 'allows method with multiple parameter with a default hash value' do
-    source = [
-      'def my_method(a, b, c, params = {})',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method(a, b, c, params = {})
+      end
+    RUBY
   end
 
   it 'allows method with default parameter before block parameter' do
-    source = [
-      'def my_method(a, b, c, params = {}, &block)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      def my_method(a, b, c, params = {}, &block)
+      end
+    RUBY
   end
 
   it 'rejects method with a default parameter other than the last non-block parameter' do
-    source = [
-      'def my_method(a, b = nil, c, &block)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      def my_method(a, b = nil, c, &block)
+                       ^^^^^^^ Do not use default positional arguments. [...]
+      end
+    RUBY
   end
 
   it 'rejects method with a default parameter other than the last parameter' do
-    source = [
-      'def my_method(a, b = 5, c = nil, params = {})',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(2)
+    expect_offense(<<~RUBY)
+      def my_method(a, b = 5, c = nil, params = {})
+                       ^^^^^ Do not use default positional arguments. [...]
+                              ^^^^^^^ Do not use default positional arguments. [...]
+      end
+    RUBY
   end
 
   it 'rejects method where last parameter has a default value of nil' do
-    source = [
-      'def my_method(a, b, c, params = nil)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      def my_method(a, b, c, params = nil)
+                             ^^^^^^^^^^^^ Do not use default positional arguments. [...]
+      end
+    RUBY
   end
 
   it 'rejects method where last parameter has a default value of a constant' do
-    source = [
-      'def my_method(a, b, c, params = Constants::A_CONSTANT)',
-      'end',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      def my_method(a, b, c, params = Constants::A_CONSTANT)
+                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use default positional arguments. [...]
+      end
+    RUBY
   end
 end

data/spec/rubocop/cop/airbnb/phrase_bundle_keys_spec.rb

@@ -1,8 +1,6 @@
-describe RuboCop::Cop::Airbnb::PhraseBundleKeys do
-  subject(:cop) { described_class.new }
-
+describe RuboCop::Cop::Airbnb::PhraseBundleKeys, :config do
   it 'generates offenses for mismatched keys in PhraseBundle classes' do
-    source = <<EOS
+    expect_offense(<<EOS)
 # encoding: UTF-8
 module PhraseBundles
   class Host < PhraseBundle
@@ -10,6 +8,7 @@ module PhraseBundles
     def phrases
       {
         "shortened_key" => t(
+        ^^^^^^^^^^^^^^^ Phrase bundle keys should match their translation keys.
           "my_real_translation_key",
           default: 'Does not matter',
         ),
@@ -18,17 +17,10 @@ module PhraseBundles
   end
 end
 EOS
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([7])
-    expect(cop.messages).to eq(
-      ['Phrase bundle keys should match their translation keys.']
-    )
   end
 
   it 'does not generate offenses for matching keys in PhraseBundle classes' do
-    source = <<EOS
+    expect_no_offenses(<<EOS)
 # encoding: UTF-8
 module PhraseBundles
   class Host < PhraseBundle
@@ -44,14 +36,10 @@ module PhraseBundles
   end
 end
 EOS
-
-    inspect_source(source)
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
   end
 
   it 'passes on t calls that are not in PhraseBundle classes' do
-    source = <<EOS
+    expect_no_offenses(<<EOS)
 # encoding: UTF-8
 module PhraseBundles
   class Host
@@ -67,8 +55,5 @@ module PhraseBundles
   end
 end
 EOS
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
   end
 end

data/spec/rubocop/cop/airbnb/risky_activerecord_invocation_spec.rb

@@ -1,54 +1,40 @@
-describe RuboCop::Cop::Airbnb::RiskyActiverecordInvocation do
-  subject(:cop) { described_class.new }
-
+describe RuboCop::Cop::Airbnb::RiskyActiverecordInvocation, :config do
   it "allows where statement that's a hash" do
-    source = [
-      'Users.where({:name => "Bob"})',
-    ].join("\n")
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses(<<~RUBY)
+      Users.where({:name => "Bob"})
+    RUBY
   end
 
   it "allows where statement that's a flat string" do
-    source = 'Users.where("age = 24")'
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses('Users.where("age = 24")')
   end
 
   it "allows a multiline where statement" do
-    source = "Users.where(\"age = 24 OR \" \\\n\"age = 25\")"
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses("Users.where(\"age = 24 OR \" \\\n\"age = 25\")")
   end
 
   it "allows interpolation in subsequent arguments to where" do
-    source = 'Users.where("name like ?", "%#{name}%")'
-
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
+    expect_no_offenses('Users.where("name like ?", "%#{name}%")')
   end
 
   it "disallows interpolation in where statements" do
-    source = 'Users.where("name = #{username}")'
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      Users.where("name = \#{username}")
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Passing a string computed by interpolation or addition to an ActiveRecord method is likely to lead to SQL injection. [...]
+    RUBY
   end
 
   it "disallows addition in where statements" do
-    source = 'Users.where("name = " + username)'
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      Users.where("name = " + username)
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Passing a string computed by interpolation or addition to an ActiveRecord method is likely to lead to SQL injection. [...]
+    RUBY
   end
 
   it "disallows interpolation in order statements" do
-    source = 'Users.where("age = 24").order("name #{sortorder}")'
-
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
+    expect_offense(<<~RUBY)
+      Users.where("age = 24").order("name \#{sortorder}")
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Passing a string computed by interpolation or addition to an ActiveRecord method is likely to lead to SQL injection. [...]
+    RUBY
   end
 end

data/spec/rubocop/cop/airbnb/rspec_describe_or_context_under_namespace_spec.rb

@@ -1,6 +1,4 @@
-describe RuboCop::Cop::Airbnb::RspecDescribeOrContextUnderNamespace do
-  subject(:cop) { described_class.new }
-
+describe RuboCop::Cop::Airbnb::RspecDescribeOrContextUnderNamespace, :config do
   let(:tmpdir) { Dir.mktmpdir }
   let(:models_spec_dir) do
     FileUtils.mkdir_p("#{tmpdir}/spec/models").first
@@ -13,125 +11,73 @@ describe RuboCop::Cop::Airbnb::RspecDescribeOrContextUnderNamespace do
   shared_examples 'rspec namespacing rule' do
     context 'under a namespace' do
       it 'rejects without change message when argument is a string' do
-        source = [
-          'module Foo',
-          "  #{method} 'SomeClass' do",
-          '    it "passes" do',
-          '      expect(true).to be_true',
-          '    end',
-          '  end',
-          'end',
-        ].join("\n")
-
         FileUtils.mkdir_p "#{models_spec_dir}/foo"
         File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-          inspect_source(source, file)
+          expect_offense(<<~RUBY, file)
+            module Foo
+            ^^^^^^^^^^ Declaring a `module` in a spec can break autoloading because subsequent references to it will not cause it to be loaded from the app. This could cause flaky tests. Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls accordingly.
+              #{method} 'SomeClass' do
+                it "passes" do
+                  expect(true).to be_true
+                end
+              end
+            end
+          RUBY
         end
-
-        expect(cop.offenses.size).to eql(1)
-        expect(cop.offenses.first.message).
-          to include('Declaring a `module` in a spec can break autoloading because ')
-
-        expect(cop.offenses.first.message).
-          not_to include(
-            "Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`"
-          )
-
-        expect(cop.offenses.first.message).
-          to include('Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls')
       end
 
       it 'rejects with change message when argument is a constant' do
-        source = [
-          'module Foo',
-          "  #{method} SomeClass do",
-          '    it "passes" do',
-          '      expect(true).to be_true',
-          '    end',
-          '  end',
-          'end',
-        ].join("\n")
-
         FileUtils.mkdir_p "#{models_spec_dir}/foo"
         File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-          inspect_source(source, file)
+          expect_offense(<<~RUBY, file)
+            module Foo
+            ^^^^^^^^^^ Declaring a `module` in a spec can break autoloading because subsequent references to it will not cause it to be loaded from the app. This could cause flaky tests. Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`. Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls accordingly.
+              #{method} SomeClass do
+                it "passes" do
+                  expect(true).to be_true
+                end
+              end
+            end
+          RUBY
         end
-
-        expect(cop.offenses.size).to eql(1)
-        expect(cop.offenses.first.message).
-          to include('Declaring a `module` in a spec can break autoloading because ')
-
-        expect(cop.offenses.first.message).
-          to include(
-            "Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`"
-          )
-
-        expect(cop.offenses.first.message).
-          to include('Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls')
       end
 
       it 'rejects when within a nested block' do
-        source = [
-          'module Foo',
-          '  1.times do',
-          "    #{method} SomeClass do",
-          '      it "passes" do',
-          '        expect(true).to be_true',
-          '      end',
-          '    end',
-          '  end',
-          'end',
-        ].join("\n")
-
         FileUtils.mkdir_p "#{models_spec_dir}/foo"
         File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-          inspect_source(source, file)
+          expect_offense(<<~RUBY, file)
+            module Foo
+            ^^^^^^^^^^ Declaring a `module` in a spec can break autoloading because subsequent references to it will not cause it to be loaded from the app. This could cause flaky tests. Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`. Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls accordingly.
+              1.times do
+                #{method} SomeClass do
+                  it "passes" do
+                    expect(true).to be_true
+                  end
+                end
+              end
+            end
+          RUBY
         end
-
-        expect(cop.offenses.size).to eql(1)
-        expect(cop.offenses.first.message).
-          to include('Declaring a `module` in a spec can break autoloading because ')
-
-        expect(cop.offenses.first.message).
-          to include(
-            "Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`"
-          )
-
-        expect(cop.offenses.first.message).
-          to include('Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls')
       end
 
       it 'rejects when a block is executed prior' do
-        source = [
-          'module Foo',
-          '  [1,2,3].each do',
-          '    something',
-          '  end',
-          '',
-          "  #{method} SomeClass do",
-          '    it "passes" do',
-          '      expect(true).to be_true',
-          '    end',
-          '  end',
-          'end',
-        ].join("\n")
-
         FileUtils.mkdir_p "#{models_spec_dir}/foo"
         File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-          inspect_source(source, file)
+          expect_offense(<<~RUBY, file)
+            module Foo
+            ^^^^^^^^^^ Declaring a `module` in a spec can break autoloading because subsequent references to it will not cause it to be loaded from the app. This could cause flaky tests. Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`. Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls accordingly.
+              [1,2,3].each do
+                something
+              end
+
+              #{method} SomeClass do
+                it "passes" do
+                  expect(true).to be_true
+                end
+              end
+            end
+          RUBY
         end
-
-        expect(cop.offenses.size).to eql(1)
-        expect(cop.offenses.first.message).
-          to include('Declaring a `module` in a spec can break autoloading because ')
-
-        expect(cop.offenses.first.message).
-          to include(
-            "Change `#{method} SomeClass do` to `#{method} Foo::SomeClass do`"
-          )
-
-        expect(cop.offenses.first.message).
-          to include('Remove `module Foo` and fix `Foo::CONST` and `Foo.method` calls')
       end
     end
   end
@@ -161,124 +107,100 @@ describe RuboCop::Cop::Airbnb::RspecDescribeOrContextUnderNamespace do
   end
 
   it 'accepts if file is not a spec file' do
-    source = [
-      'module Foo',
-      '  RSpec.describe "SomeClass" do',
-      '    it "passes" do',
-      '      expect(true).to be_true',
-      '    end',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class.rb", "w" do |file|
-      inspect_source(source, file)
+      expect_no_offenses(<<~RUBY, file)
+        module Foo
+          RSpec.describe "SomeClass" do
+            it "passes" do
+              expect(true).to be_true
+            end
+          end
+        end
+      RUBY
     end
-
-    expect(cop.offenses).to be_empty
   end
 
   it 'accepts if not under a module' do
-    source = [
-      'RSpec.describe "SomeClass" do',
-      '  it "passes" do',
-      '    expect(true).to be_true',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-      inspect_source(source, file)
+      expect_no_offenses(<<~RUBY, file)
+        RSpec.describe "SomeClass" do
+          it "passes" do
+            expect(true).to be_true
+          end
+        end
+      RUBY
     end
-
-    expect(cop.offenses).to be_empty
   end
 
   it 'accepts if not describe or context' do
-    source = [
-      'module Foo',
-      '  not_describe_or_context "SomeClass" do',
-      '    it "passes" do',
-      '      expect(true).to be_true',
-      '    end',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-      inspect_source(source, file)
+      expect_no_offenses(<<~RUBY, file)
+        module Foo
+          not_describe_or_context "SomeClass" do
+            it "passes" do
+              expect(true).to be_true
+            end
+          end
+        end
+      RUBY
     end
-
-    expect(cop.offenses).to be_empty
   end
 
   it 'accepts an empty module' do
-    source = [
-      'RSpec.describe "SomeClass" do',
-      '  module Bar; end',
-      '',
-      '  it "passes" do',
-      '    expect(true).to be_true',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-      inspect_source(source, file)
-    end
+      expect_no_offenses(<<~RUBY, file)
+        RSpec.describe "SomeClass" do
+          module Bar; end
 
-    expect(cop.offenses).to be_empty
+          it "passes" do
+            expect(true).to be_true
+          end
+        end
+      RUBY
+    end
   end
 
   it 'accepts a module with code' do
-    source = [
-      'RSpec.describe "SomeClass" do',
-      '  module Bar',
-      '    def self.foo',
-      '    end',
-      '    foo',
-      '  end',
-      '',
-      '  it "passes" do',
-      '    expect(true).to be_true',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-      inspect_source(source, file)
+      expect_no_offenses(<<~RUBY, file)
+        RSpec.describe "SomeClass" do
+          module Bar
+            def self.foo
+            end
+            foo
+          end
+
+          it "passes" do
+            expect(true).to be_true
+          end
+        end
+      RUBY
     end
-
-    expect(cop.offenses).to be_empty
   end
 
   it 'accepts when describe or context to be called when class or module is not RSpec' do
-    source = [
-      'module Foo',
-      '  Bar.describe "SomeClass" do',
-      '    it "passes" do',
-      '      expect(true).to be_true',
-      '    end',
-      '  end',
-      '',
-      '  Bar.context "SomeClass" do',
-      '    it "passes" do',
-      '      expect(true).to be_true',
-      '    end',
-      '  end',
-      'end',
-    ].join("\n")
-
     FileUtils.mkdir_p "#{models_spec_dir}/foo"
     File.open "#{models_spec_dir}/foo/some_class_spec.rb", "w" do |file|
-      inspect_source(source, file)
+      expect_no_offenses(<<~RUBY, file)
+        module Foo
+          Bar.describe "SomeClass" do
+            it "passes" do
+              expect(true).to be_true
+            end
+          end
+
+          Bar.context "SomeClass" do
+            it "passes" do
+              expect(true).to be_true
+            end
+          end
+        end
+      RUBY
     end
-
-    expect(cop.offenses).to be_empty
   end
 end