(maint) Switch to rspec-mocks

Author: GabrielNagy

.rubocop.yml

@@ -77,6 +77,8 @@ Style/SymbolArray:
   EnforcedStyle: brackets
 RSpec/NamedSubject:
   Enabled: false
+RSpec/SubjectStub:
+  Enabled: false
 RSpec/MessageSpies:
   EnforcedStyle: receive
 Style/Documentation:

spec/integration/provider/cron/crontab_spec.rb

@@ -7,17 +7,17 @@
   include PuppetSpec::Compiler
 
   before :each do
-    Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
-    described_class.stubs(:suitable?).returns true
-    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # rubocop:disable RSpec/AnyInstance
+    allow(Puppet::Type.type(:cron)).to receive(:defaultprovider).and_return described_class
+    allow(described_class).to receive(:suitable?).and_return true
+    allow_any_instance_of(Puppet::FileBucket::Dipper).to receive(:backup) # rubocop:disable RSpec/AnyInstance
 
     # I don't want to execute anything
-    described_class.stubs(:filetype).returns Puppet::Util::FileType::FileTypeFlat
-    described_class.stubs(:default_target).returns crontab_user1
+    allow(described_class).to receive(:filetype).and_return Puppet::Util::FileType::FileTypeFlat
+    allow(described_class).to receive(:default_target).and_return crontab_user1
 
     # I don't want to stub Time.now to get a static header because I don't know
     # where Time.now is used elsewhere, so just go with a very simple header
-    described_class.stubs(:header).returns "# HEADER: some simple\n# HEADER: header\n"
+    allow(described_class).to receive(:header).and_return "# HEADER: some simple\n# HEADER: header\n"
     FileUtils.cp(my_fixture('crontab_user1'), crontab_user1)
     FileUtils.cp(my_fixture('crontab_user2'), crontab_user2)
   end
@@ -113,9 +113,9 @@ def expect_output(fixture_name)
           MANIFEST
           apply_compiled_manifest(manifest) do |res|
             if res.ref == 'Cron[Entirely new resource]'
-              res.expects(:err).with(regexp_matches(%r{no command}))
+              expect(res).to receive(:err).with(%r{no command})
             else
-              res.expects(:err).never
+              expect(res).not_to receive(:err)
             end
           end
         end

spec/lib/puppet_spec/compiler.rb

@@ -33,7 +33,7 @@ def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPri
     if Puppet.version.to_f < 5.0
       args << 'apply'
       # rubocop:disable RSpec/AnyInstance
-      Puppet::Transaction::Persistence.any_instance.stubs(:save)
+      allow_any_instance_of(Puppet::Transaction::Persistence).to receive(:save)
       # rubocop:enable RSpec/AnyInstance
     end
     catalog = compile_to_ral(manifest)
@@ -51,7 +51,7 @@ def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPri
 
   def apply_with_error_check(manifest)
     apply_compiled_manifest(manifest) do |res|
-      res.expects(:err).never
+      expect(res).not_to receive(:err)
     end
   end
 

spec/lib/puppet_spec/files.rb

@@ -10,7 +10,7 @@ def self.cleanup
     $global_tempfiles ||= []
     $global_tempfiles.each do |path|
       begin
-        Dir.unstub(:entries)
+        allow(Dir).to receive(:entries).and_call_original
         FileUtils.rm_rf path, secure: true
       rescue Errno::ENOENT # rubocop:disable Lint/HandleExceptions
         # nothing to do

spec/spec_helper.rb

@@ -31,6 +31,7 @@
 end
 
 RSpec.configure do |c|
+  c.mock_with :rspec
   c.default_facts = default_facts
   c.before :each do
     # set to strictest setting for testing

spec/unit/provider/cron/crontab_spec.rb

@@ -125,7 +125,7 @@ def compare_crontab_record(have, want)
     let(:resources) { { 'test' => resource } }
 
     before :each do
-      subject.stubs(:prefetch_all_targets).returns([record])
+      allow(subject).to receive(:prefetch_all_targets).and_return([record])
     end
 
     # this would be a more fitting test, but I haven't yet
@@ -141,34 +141,34 @@ def compare_crontab_record(have, want)
     #    end
 
     it "does not base the new resource's provider on the existing record" do
-      subject.expects(:new).with(record).never
-      subject.stubs(:new)
+      expect(subject).not_to receive(:new).with(record)
+      allow(subject).to receive(:new)
       subject.prefetch(resources)
     end
   end
 
   context 'when prefetching an entry now managed for another user' do
     let(:resource) do
-      s = stub(:resource)
-      s.stubs(:[]).with(:user).returns 'root'
-      s.stubs(:[]).with(:target).returns 'root'
+      s = instance_double('Puppet::Type::Crontab')
+      allow(s).to receive(:[]).with(:user).and_return 'root'
+      allow(s).to receive(:[]).with(:target).and_return 'root'
       s
     end
 
     let(:record) { { name: 'test', user: 'nobody', command: '/bin/true', record_type: :crontab } }
     let(:resources) { { 'test' => resource } }
 
     before :each do
-      subject.stubs(:prefetch_all_targets).returns([record])
+      allow(subject).to receive(:prefetch_all_targets).and_return([record])
     end
 
     it 'tries and use the match method to find a more fitting record' do
-      subject.expects(:match).with(record, resources)
+      expect(subject).to receive(:match).with(record, resources)
       subject.prefetch(resources)
     end
 
     it 'does not match a provider to the resource' do
-      resource.expects(:provider=).never
+      expect(resource).not_to receive(:provider=)
       subject.prefetch(resources)
     end
 
@@ -205,19 +205,17 @@ def compare_crontab_record(have, want)
 
   context '#enumerate_crontabs' do
     before(:each) do
-      File.expects(:readable?).with(subject.crontab_dir).returns(true)
-      Dir.expects(:foreach).with(subject.crontab_dir).multiple_yields(*files)
+      allow(File).to receive(:readable?).with(subject.crontab_dir).and_return(true)
     end
 
     context 'only a hidden file' do
-      let(:files) { ['.keep_cronbase-0'] }
+      let(:file) { '.keep_cronbase-0' }
 
       before(:each) do
-        files.each do |filename|
-          path = File.join(subject.crontab_dir, filename)
-          File.expects(:file?).with(path).returns(true)
-          File.expects(:writable?).with(path).returns(true)
-        end
+        path = File.join(subject.crontab_dir, file)
+        allow(Dir).to receive(:foreach).with(subject.crontab_dir).and_yield(file)
+        allow(File).to receive(:file?).with(path).and_return(true)
+        allow(File).to receive(:writable?).with(path).and_return(true)
       end
 
       it 'ignores .keep_* files' do
@@ -229,10 +227,12 @@ def compare_crontab_record(have, want)
       let(:files) { ['myuser', '.keep_cronbase-0'] }
 
       before(:each) do
+        allow(Dir).to receive(:foreach).with(subject.crontab_dir).and_yield(files[0]).and_yield(files[1])
+
         files.each do |filename|
           path = File.join(subject.crontab_dir, filename)
-          File.expects(:file?).with(path).returns(true)
-          File.expects(:writable?).with(path).returns(true)
+          allow(File).to receive(:file?).with(path).and_return(true)
+          allow(File).to receive(:writable?).with(path).and_return(true)
         end
       end
 

spec/unit/provider/cron/filetype_spec.rb

@@ -17,59 +17,53 @@
     # make Puppet::Util::SUIDManager return something deterministic, not the
     # uid of the user running the tests, except where overridden below.
     before :each do
-      Puppet::Util::SUIDManager.stubs(:uid).returns 1234
+      allow(Puppet::Util::SUIDManager).to receive(:uid).and_return 1234
     end
 
     describe '#read' do
       before(:each) do
-        Puppet::Util.stubs(:uid).with(uid).returns 9000
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return 9000
       end
 
       it 'runs crontab -l as the target user' do
-        Puppet::Util::Execution
-          .expects(:execute)
-          .with(['crontab', '-l'], user_options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
-
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it 'does not switch user if current user is the target user' do
-        Puppet::Util.expects(:uid).with(uid).twice.returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution
-          .expects(:execute).with(['crontab', '-l'], options)
-          .returns(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
+        expect(Puppet::Util).to receive(:uid).with(uid).twice.and_return 9000
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return 9000
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], options).and_return(Puppet::Util::Execution::ProcessOutput.new(crontab, 0))
         expect(cron.read).to eq(crontab)
       end
 
       it 'treats an absent crontab as empty' do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, absent_crontab)
         expect(cron.read).to eq('')
       end
 
       it "treats a nonexistent user's crontab as empty" do
-        Puppet::Util.expects(:uid).with(uid).returns nil
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return nil
 
         expect(cron.read).to eq('')
       end
 
       it 'returns empty if the user is not authorized to use cron' do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-l'], user_options).and_raise(Puppet::ExecutionFailure, unauthorized_crontab)
         expect(cron.read).to eq('')
       end
     end
 
     describe '#remove' do
       it 'runs crontab -r as the target user' do
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], user_options)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], user_options)
         cron.remove
       end
 
       it 'does not switch user if current user is the target user' do
-        Puppet::Util.expects(:uid).with(uid).returns 9000
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        Puppet::Util::Execution.expects(:execute).with(['crontab', '-r'], options)
+        expect(Puppet::Util).to receive(:uid).with(uid).and_return 9000
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return 9000
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', '-r'], options)
         cron.remove
       end
     end
@@ -79,30 +73,30 @@
       let!(:tmp_cron_path) { tmp_cron.path }
 
       before :each do
-        Puppet::Util.stubs(:uid).with(uid).returns 9000
-        Tempfile.expects(:new).with("puppet_#{name}", encoding: Encoding.default_external).returns tmp_cron
+        allow(Puppet::Util).to receive(:uid).with(uid).and_return 9000
+        allow(Tempfile).to receive(:new).with("puppet_#{name}", encoding: Encoding.default_external).and_return tmp_cron
       end
 
       after :each do
-        File.unstub(:chown)
+        allow(File).to receive(:chown).and_call_original
       end
 
       it 'runs crontab as the target user on a temporary file' do
-        File.expects(:chown).with(9000, nil, tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(['crontab', tmp_cron_path], user_options)
+        expect(File).to receive(:chown).with(9000, nil, tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', tmp_cron_path], user_options)
 
-        tmp_cron.expects(:print).with("foo\n")
+        expect(tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
 
         expect(Puppet::FileSystem).not_to exist(tmp_cron_path)
       end
 
       it 'does not switch user if current user is the target user' do
-        Puppet::Util::SUIDManager.expects(:uid).returns 9000
-        File.expects(:chown).with(9000, nil, tmp_cron_path)
-        Puppet::Util::Execution.expects(:execute).with(['crontab', tmp_cron_path], options)
+        expect(Puppet::Util::SUIDManager).to receive(:uid).and_return 9000
+        expect(File).to receive(:chown).with(9000, nil, tmp_cron_path)
+        expect(Puppet::Util::Execution).to receive(:execute).with(['crontab', tmp_cron_path], options)
 
-        tmp_cron.expects(:print).with("foo\n")
+        expect(tmp_cron).to receive(:print).with("foo\n")
         cron.write "foo\n"
 
         expect(Puppet::FileSystem).not_to exist(tmp_cron_path)

spec/unit/provider/cron/parsed_spec.rb

@@ -63,22 +63,22 @@
 
   describe 'when determining the correct filetype' do
     it 'uses the suntab filetype on Solaris' do
-      Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      allow(Facter).to receive(:value).with(:osfamily).and_return 'Solaris'
       expect(described_class.filetype).to eq(Puppet::Provider::Cron::FileType::FileTypeSuntab)
     end
 
     it 'uses the aixtab filetype on AIX' do
-      Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      allow(Facter).to receive(:value).with(:osfamily).and_return 'AIX'
       expect(described_class.filetype).to eq(Puppet::Provider::Cron::FileType::FileTypeAixtab)
     end
 
     it 'uses the crontab filetype on other platforms' do
-      Facter.stubs(:value).with(:osfamily).returns 'Not a real operating system family'
+      allow(Facter).to receive(:value).with(:osfamily).and_return 'Not a real operating system family'
       expect(described_class.filetype).to eq(Puppet::Provider::Cron::FileType::FileTypeCrontab)
     end
   end
 
-  # I'd use ENV.expects(:[]).with('USER') but this does not work because
+  # I'd use expect(ENV).to receive(:[]).with('USER') but this does not work because
   # ENV["USER"] is evaluated at load time.
   describe 'when determining the default target' do
     it "should use the current user #{ENV['USER']}", if: ENV['USER'] do
@@ -94,16 +94,13 @@
     let(:tabs) { [described_class.default_target] + ['foo', 'bar'] }
 
     before(:each) do
-      File.expects(:readable?).returns true
-      File.stubs(:file?).returns true
-      File.stubs(:writable?).returns true
-    end
-    after(:each) do
-      File.unstub :readable?, :file?, :writable?
-      Dir.unstub :foreach
+      allow(File).to receive(:readable?).and_return true
+      allow(File).to receive(:file?).and_return true
+      allow(File).to receive(:writable?).and_return true
     end
+
     it 'adds all crontabs as targets' do
-      Dir.expects(:foreach).multiple_yields(*tabs)
+      expect(Dir).to receive(:foreach).and_yield(tabs[0]).and_yield(tabs[1]).and_yield(tabs[2])
       expect(described_class.targets).to eq(tabs)
     end
   end
@@ -185,36 +182,30 @@
 
   describe '.instances' do
     before :each do
-      described_class.stubs(:default_target).returns 'foobar'
+      allow(described_class).to receive(:targets).and_return ['foobar']
     end
 
     describe 'on linux' do
       before(:each) do
-        Facter.stubs(:value).with(:osfamily).returns 'Linux'
-        Facter.stubs(:value).with(:operatingsystem)
+        allow(Facter).to receive(:value).with(:osfamily).and_return 'Linux'
+        allow(Facter).to receive(:value).with(:operatingsystem)
       end
 
       it 'contains no resources for a user who has no crontab' do
-        Puppet::Util.stubs(:uid).returns(10)
+        allow(Puppet::Util).to receive(:uid).and_return(10)
 
-        Puppet::Util::Execution
-          .expects(:execute)
-          .with('crontab -u foobar -l', failonfail: true, combine: true)
-          .returns('')
-
-        expect(described_class.instances.select do |resource|
-          resource.get('target') == 'foobar'
-        end).to be_empty
+        expect(Puppet::Util::Execution).to receive(:execute).with('crontab -u foobar -l', failonfail: true, combine: true).and_return('')
+        expect(described_class.instances).to be_empty
       end
 
       it 'contains no resources for a user who is absent' do
-        Puppet::Util.stubs(:uid).returns(nil)
+        allow(Puppet::Util).to receive(:uid).and_return(nil)
 
         expect(described_class.instances).to be_empty
       end
 
       it 'is able to create records from not-managed records' do
-        described_class.stubs(:target_object).returns File.new(my_fixture('simple'))
+        allow(described_class).to receive(:target_object).and_return File.new(my_fixture('simple'))
         parameters = described_class.instances.map do |p|
           h = { name: p.get(:name) }
           Puppet::Type.type(:cron).validproperties.each do |property|
@@ -250,7 +241,7 @@
       end
 
       it 'is able to parse puppet managed cronjobs' do
-        described_class.stubs(:target_object).returns File.new(my_fixture('managed'))
+        allow(described_class).to receive(:target_object).and_return File.new(my_fixture('managed'))
         expect(described_class.instances.map do |p|
           h = { name: p.get(:name) }
           Puppet::Type.type(:cron).validproperties.each do |property|