(CONT-801) Correct RSpec/ImplicitSubject

Author: LukasAud

.rubocop_todo.yml

@@ -153,13 +153,6 @@ RSpec/FilePath:
     - 'spec/unit/puppet/provider/file_line/ruby_spec_alter.rb'
     - 'spec/unit/puppet/provider/file_line/ruby_spec_use_cases.rb'
 
-# Offense count: 198
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: single_line_only, single_statement_only, disallow, require_implicit
-RSpec/ImplicitSubject:
-  Enabled: false
-
 # Offense count: 2
 RSpec/LeakyConstantDeclaration:
   Exclude:

spec/functions/assert_private_spec.rb

@@ -8,7 +8,7 @@
       expect(scope).to receive(:lookupvar).with('module_name').and_return('foo')
       expect(scope).to receive(:lookupvar).with('caller_module_name').and_return('foo')
 
-      is_expected.to run.with_params
+      expect(subject).to run.with_params
     end
   end
 
@@ -19,11 +19,11 @@
       expect(scope.source).to receive(:name).and_return('foo::baz')
       expect(scope.source).to receive(:type).and_return('hostclass')
 
-      is_expected.to run.with_params.and_raise_error(Puppet::ParseError, %r{Class foo::baz is private})
+      expect(subject).to run.with_params.and_raise_error(Puppet::ParseError, %r{Class foo::baz is private})
     end
 
     it 'fails with an explicit failure message' do
-      is_expected.to run.with_params('failure message!').and_raise_error(Puppet::ParseError, %r{failure message!})
+      expect(subject).to run.with_params('failure message!').and_raise_error(Puppet::ParseError, %r{failure message!})
     end
   end
 
@@ -34,7 +34,7 @@
       expect(scope.source).to receive(:name).and_return('foo::baz')
       expect(scope.source).to receive(:type).and_return('definition')
 
-      is_expected.to run.with_params.and_raise_error(Puppet::ParseError, %r{Definition foo::baz is private})
+      expect(subject).to run.with_params.and_raise_error(Puppet::ParseError, %r{Definition foo::baz is private})
     end
   end
 end

spec/functions/base64_spec.rb

@@ -24,47 +24,47 @@
   it { is_expected.to run.with_params('decode', 'dGhlc3RyaW5n', 'strict').and_return('thestring') }
 
   it {
-    is_expected.to run.with_params('encode', 'a very long string that will cause the base64 encoder to produce output with multiple lines')
-                      .and_return("YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0\nIGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5l\ncw==\n")
+    expect(subject).to run.with_params('encode', 'a very long string that will cause the base64 encoder to produce output with multiple lines')
+                          .and_return("YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0\nIGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5l\ncw==\n")
   }
 
   it {
-    is_expected.to run.with_params('decode', "YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0\nIGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5l\ncw==\n")
-                      .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
+    expect(subject).to run.with_params('decode', "YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0\nIGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5l\ncw==\n")
+                          .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
   }
 
   it {
-    is_expected.to run.with_params('decode', 'YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==')
-                      .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
+    expect(subject).to run.with_params('decode', 'YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==')
+                          .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
   }
 
   it {
-    is_expected.to run.with_params('encode', 'a very long string that will cause the base64 encoder to produce output with multiple lines', 'strict')
-                      .and_return('YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==')
+    expect(subject).to run.with_params('encode', 'a very long string that will cause the base64 encoder to produce output with multiple lines', 'strict')
+                          .and_return('YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==')
   }
 
   it {
-    is_expected.to run.with_params('decode', 'YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==', 'strict')
-                      .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
+    expect(subject).to run.with_params('decode', 'YSB2ZXJ5IGxvbmcgc3RyaW5nIHRoYXQgd2lsbCBjYXVzZSB0aGUgYmFzZTY0IGVuY29kZXIgdG8gcHJvZHVjZSBvdXRwdXQgd2l0aCBtdWx0aXBsZSBsaW5lcw==', 'strict')
+                          .and_return('a very long string that will cause the base64 encoder to produce output with multiple lines')
   }
 
   it {
-    is_expected.to run.with_params('encode', 'https://www.google.com.tw/?gws_rd=ssl#q=hello+world', 'urlsafe')
-                      .and_return('aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS50dy8_Z3dzX3JkPXNzbCNxPWhlbGxvK3dvcmxk')
+    expect(subject).to run.with_params('encode', 'https://www.google.com.tw/?gws_rd=ssl#q=hello+world', 'urlsafe')
+                          .and_return('aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS50dy8_Z3dzX3JkPXNzbCNxPWhlbGxvK3dvcmxk')
   }
 
   it {
-    is_expected.to run.with_params('decode', 'aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS50dy8_Z3dzX3JkPXNzbCNxPWhlbGxvK3dvcmxk', 'urlsafe')
-                      .and_return('https://www.google.com.tw/?gws_rd=ssl#q=hello+world')
+    expect(subject).to run.with_params('decode', 'aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS50dy8_Z3dzX3JkPXNzbCNxPWhlbGxvK3dvcmxk', 'urlsafe')
+                          .and_return('https://www.google.com.tw/?gws_rd=ssl#q=hello+world')
   }
 
   it {
-    is_expected.to run.with_params('encode', 'https://github.com/puppetlabs/puppetlabs-stdlib/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+Add', 'urlsafe')
-                      .and_return('aHR0cHM6Ly9naXRodWIuY29tL3B1cHBldGxhYnMvcHVwcGV0bGFicy1zdGRsaWIvcHVsbHM_dXRmOD0lRTIlOUMlOTMmcT1pcyUzQXByK2lzJTNBb3BlbitBZGQ=')
+    expect(subject).to run.with_params('encode', 'https://github.com/puppetlabs/puppetlabs-stdlib/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+Add', 'urlsafe')
+                          .and_return('aHR0cHM6Ly9naXRodWIuY29tL3B1cHBldGxhYnMvcHVwcGV0bGFicy1zdGRsaWIvcHVsbHM_dXRmOD0lRTIlOUMlOTMmcT1pcyUzQXByK2lzJTNBb3BlbitBZGQ=')
   }
 
   it {
-    is_expected.to run.with_params('decode', 'aHR0cHM6Ly9naXRodWIuY29tL3B1cHBldGxhYnMvcHVwcGV0bGFicy1zdGRsaWIvcHVsbHM_dXRmOD0lRTIlOUMlOTMmcT1pcyUzQXByK2lzJTNBb3BlbitBZGQ=', 'urlsafe')
-                      .and_return('https://github.com/puppetlabs/puppetlabs-stdlib/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+Add')
+    expect(subject).to run.with_params('decode', 'aHR0cHM6Ly9naXRodWIuY29tL3B1cHBldGxhYnMvcHVwcGV0bGFicy1zdGRsaWIvcHVsbHM_dXRmOD0lRTIlOUMlOTMmcT1pcyUzQXByK2lzJTNBb3BlbitBZGQ=', 'urlsafe')
+                          .and_return('https://github.com/puppetlabs/puppetlabs-stdlib/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+Add')
   }
 end

spec/functions/batch_escape_spec.rb

@@ -20,8 +20,8 @@
     it { is_expected.to run.with_params('foo bar').and_return('"foo bar"') }
 
     it {
-      is_expected.to run.with_params('~`!@#$%^&*()_-=[]\{}|;\':",./<>?')
-                        .and_return('"~`!@#\\$%^&*()_-=[]\\\{}|;\':"",./<>?"')
+      expect(subject).to run.with_params('~`!@#$%^&*()_-=[]\{}|;\':",./<>?')
+                            .and_return('"~`!@#\\$%^&*()_-=[]\\\{}|;\':"",./<>?"')
     }
   end
 end

spec/functions/convert_base_spec.rb

@@ -13,11 +13,11 @@
   it { is_expected.to run.with_params('1', 37).and_raise_error(Puppet::ParseError, %r{base must be at least 2 and must not be greater than 36}) }
 
   it 'raises a ParseError if argument 1 is a string that does not correspond to an integer in base 10' do
-    is_expected.to run.with_params('ten', 6).and_raise_error(Puppet::ParseError, %r{argument must be an integer or a string corresponding to an integer in base 10})
+    expect(subject).to run.with_params('ten', 6).and_raise_error(Puppet::ParseError, %r{argument must be an integer or a string corresponding to an integer in base 10})
   end
 
   it 'raises a ParseError if argument 2 is a string and does not correspond to an integer in base 10' do
-    is_expected.to run.with_params(100, 'hex').and_raise_error(Puppet::ParseError, %r{argument must be an integer or a string corresponding to an integer in base 10})
+    expect(subject).to run.with_params(100, 'hex').and_raise_error(Puppet::ParseError, %r{argument must be an integer or a string corresponding to an integer in base 10})
   end
 
   it { is_expected.to run.with_params('11', '16').and_return('b') }

spec/functions/count_spec.rb

@@ -10,7 +10,7 @@
 
   it {
     pending('should actually be like this, and not like above')
-    is_expected.to run.with_params('one', 'two').and_raise_error(ArgumentError)
+    expect(subject).to run.with_params('one', 'two').and_raise_error(ArgumentError)
   }
 
   it { is_expected.to run.with_params('one', 'two', 'three').and_raise_error(ArgumentError) }

spec/functions/deep_merge_spec.rb

@@ -16,33 +16,33 @@
 
   describe 'when arguments have key collisions' do
     it 'prefers values from the last hash' do
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value2' }, 'key2' => 'replacement_value', 'key3' => 'value3') \
         .and_return('key1' => 'value1', 'key2' => 'replacement_value', 'key3' => 'value3')
     end
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1' }, { 'key1' => 'value2' }, 'key1' => 'value3') \
         .and_return('key1' => 'value3')
     }
   end
 
   describe 'when arguments have subhashes' do
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1' }, 'key2' => 'value2', 'key3' => { 'subkey1' => 'value4' }) \
         .and_return('key1' => 'value1', 'key2' => 'value2', 'key3' => { 'subkey1' => 'value4' })
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => { 'subkey1' => 'value1' } }, 'key1' => { 'subkey2' => 'value2' }) \
         .and_return('key1' => { 'subkey1' => 'value1', 'subkey2' => 'value2' })
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => { 'subkey1' => { 'subsubkey1' => 'value1' } } }, 'key1' => { 'subkey1' => { 'subsubkey1' => 'value2' } }) \
         .and_return('key1' => { 'subkey1' => { 'subsubkey1' => 'value2' } })
     }

spec/functions/defined_with_params_spec.rb

@@ -92,7 +92,7 @@
     it { is_expected.to run.with_params(Puppet::Resource.new('Test::Deftype[foo]'), {}).and_return(true) }
 
     it {
-      is_expected.to run.with_params(Puppet::Resource.new('Test::Deftype[bar]'), {}).and_return(false)
+      expect(subject).to run.with_params(Puppet::Resource.new('Test::Deftype[bar]'), {}).and_return(false)
 
       expect(catalogue.resource('Notify[Duplicate found somewhere]')).not_to be_nil
       expect(catalogue.resource('Notify[Should not find me]')).to be_nil

spec/functions/delete_at_spec.rb

@@ -11,7 +11,7 @@
 
   it {
     pending('Current implementation ignores parameters after the first two.')
-    is_expected.to run.with_params(['one'], 0, 1).and_raise_error(Puppet::ParseError)
+    expect(subject).to run.with_params(['one'], 0, 1).and_raise_error(Puppet::ParseError)
   }
 
   describe 'argument validation' do

spec/functions/delete_regex_spec.rb

@@ -32,13 +32,13 @@
     it { is_expected.to run.with_params({ 'key' => 'value' }, 'key').and_return({}) }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }, 'key2') \
         .and_return('key1' => 'value1', 'key3' => 'value3')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }, ['key1', 'key2']) \
         .and_return('key3' => 'value3')
     }

spec/functions/delete_spec.rb

@@ -45,19 +45,19 @@
     it { is_expected.to run.with_params({ 'key' => 'value' }, 'key').and_return({}) }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }, 'key2') \
         .and_return('key1' => 'value1', 'key3' => 'value3')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' }, ['key1', 'key2']) \
         .and_return('key3' => 'value3')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'ĸəұ1' => 'νãŀủĕ1', 'ĸəұ2' => 'νãŀủĕ2', 'ĸəұ3' => 'νãŀủĕ3' }, ['ĸəұ1', 'ĸəұ2']) \
         .and_return('ĸəұ3' => 'νãŀủĕ3')
     }

spec/functions/delete_undef_values_spec.rb

@@ -47,7 +47,7 @@
         it { is_expected.to run.with_params('key' => undef_value).and_return({}) }
 
         it {
-          is_expected.to run \
+          expect(subject).to run \
             .with_params('key1' => 'value1', 'undef_key' => undef_value, 'key2' => 'value2') \
             .and_return('key1' => 'value1', 'key2' => 'value2')
         }

spec/functions/delete_values_spec.rb

@@ -19,25 +19,25 @@
     it { is_expected.to run.with_params({}, 'value').and_return({}) }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1' }, 'non-existing value') \
         .and_return('key1' => 'value1')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'ҝếỵ1 ' => 'νâĺūẹ1', 'ҝếỵ2' => 'value to delete' }, 'value to delete') \
         .and_return('ҝếỵ1 ' => 'νâĺūẹ1')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'νǎŀữ℮ ťớ đêłểťė' }, 'νǎŀữ℮ ťớ đêłểťė') \
         .and_return('key1' => 'value1')
     }
 
     it {
-      is_expected.to run \
+      expect(subject).to run \
         .with_params({ 'key1' => 'value1', 'key2' => 'value to delete', 'key3' => 'value to delete' }, 'value to delete') \
         .and_return('key1' => 'value1')
     }

spec/functions/deprecation_spec.rb

@@ -24,7 +24,7 @@
       else
         expect(Puppet).to receive(:warning).with(include('heelo')).once
       end
-      is_expected.to run.with_params('key', 'heelo')
+      expect(subject).to run.with_params('key', 'heelo')
     end
 
     it 'displays a single warning, despite multiple calls' do
@@ -35,23 +35,23 @@
         expect(Puppet).to receive(:warning).with(include('heelo')).once
       end
       (0..1).each do |_i|
-        is_expected.to run.with_params('key', 'heelo')
+        expect(subject).to run.with_params('key', 'heelo')
       end
     end
 
     it 'fails twice with message, with multiple calls. when strict= :error' do
       Puppet.settings[:strict] = :error
       expect(Puppet).not_to receive(:warning).with(include('heelo'))
       (0..1).each do |_i|
-        is_expected.to run.with_params('key', 'heelo').and_raise_error(RuntimeError, %r{deprecation. key. heelo})
+        expect(subject).to run.with_params('key', 'heelo').and_raise_error(RuntimeError, %r{deprecation. key. heelo})
       end
     end
 
     it 'displays nothing, despite multiple calls. strict= :off' do
       Puppet.settings[:strict] = :off
       expect(Puppet).not_to receive(:warning).with(include('heelo'))
       (0..1).each do |_i|
-        is_expected.to run.with_params('key', 'heelo')
+        expect(subject).to run.with_params('key', 'heelo')
       end
     end
   end
@@ -71,7 +71,7 @@
 
     it 'displays a single warning' do
       expect(scope).to receive(:warning).with(include('heelo'))
-      is_expected.to run.with_params('key', 'heelo')
+      expect(subject).to run.with_params('key', 'heelo')
     end
   end
 end

spec/functions/dos2unix_spec.rb

@@ -7,23 +7,23 @@
     it { is_expected.not_to eq(nil) }
 
     it do
-      is_expected.to run.with_params.and_raise_error(ArgumentError, %r{Wrong number of arguments})
+      expect(subject).to run.with_params.and_raise_error(ArgumentError, %r{Wrong number of arguments})
     end
 
     it do
-      is_expected.to run.with_params('one', 'two').and_raise_error(ArgumentError, %r{Wrong number of arguments})
+      expect(subject).to run.with_params('one', 'two').and_raise_error(ArgumentError, %r{Wrong number of arguments})
     end
 
     it do
-      is_expected.to run.with_params([]).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
+      expect(subject).to run.with_params([]).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
     end
 
     it do
-      is_expected.to run.with_params({}).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
+      expect(subject).to run.with_params({}).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
     end
 
     it do
-      is_expected.to run.with_params(1).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
+      expect(subject).to run.with_params(1).and_raise_error(Puppet::ParseError, %r{Requires string as argument})
     end
   end
 
@@ -32,7 +32,7 @@
     desired_output = "Hello\nWorld\n"
 
     it 'outputs unix format' do
-      is_expected.to run.with_params(sample_text).and_return(desired_output)
+      expect(subject).to run.with_params(sample_text).and_return(desired_output)
     end
   end
 
@@ -44,11 +44,11 @@
     desired_output_doublebyte = "こんにちは\n世界\n"
 
     it 'outputs uft8 string' do
-      is_expected.to run.with_params(sample_text_utf8).and_return(desired_output_utf8)
+      expect(subject).to run.with_params(sample_text_utf8).and_return(desired_output_utf8)
     end
 
     it 'outputs double byte string' do
-      is_expected.to run.with_params(sample_text_doublebyte).and_return(desired_output_doublebyte)
+      expect(subject).to run.with_params(sample_text_doublebyte).and_return(desired_output_doublebyte)
     end
   end
 end

spec/functions/end_with_spec.rb

@@ -9,7 +9,7 @@
   it { is_expected.to run.with_params('foobar', ['foo', 'baz']).and_return(false) }
 
   it do
-    is_expected.to run.with_params('foobar', '').and_raise_error(
+    expect(subject).to run.with_params('foobar', '').and_raise_error(
       ArgumentError, %r{'stdlib::end_with' parameter 'suffixes' expects a value of type String\[1\] or Array\[String\[1\], 1\]}
     )
   end