puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/util/at_fork_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe 'Puppet::Util::AtFork' do
@@ -18,7 +19,7 @@ describe 'Puppet::Util::AtFork' do
   describe '.get_handler' do
     context 'when on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        Facter.expects(:value).with(:operatingsystem).returns('Solaris')
       end
 
       after :each do
@@ -28,7 +29,7 @@ describe 'Puppet::Util::AtFork' do
       end
 
       def stub_solaris_handler(stub_noop_too = false)
-        allow(Puppet::Util::AtFork).to receive(:require).with(anything) do |lib|
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
           if lib == 'puppet/util/at_fork/solaris'
             load lib + '.rb'
             true
@@ -40,7 +41,7 @@ describe 'Puppet::Util::AtFork' do
           else
             false
           end
-        end.and_return(true)
+        end.returns(true)
 
         unless stub_noop_too
           Object.class_exec do
@@ -55,18 +56,18 @@ describe 'Puppet::Util::AtFork' do
           end
         end
 
-        allow(TOPLEVEL_BINDING.eval('self')).to receive(:require).with(anything) do |lib|
+        TOPLEVEL_BINDING.eval('self').stubs(:require).with() do |lib|
           if lib == 'fiddle'
             raise LoadError, 'no fiddle' if stub_noop_too
           else
             Kernel.require lib
           end
           true
-        end.and_return(true)
+        end.returns(true)
       end
 
       it %q(should return the Solaris specific AtFork handler) do
-        allow(Puppet::Util::AtFork).to receive(:require).with(anything) do |lib|
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
           if lib == 'puppet/util/at_fork/solaris'
             Puppet::Util::AtFork.class_exec do
               const_set(:Solaris, Class.new)
@@ -75,7 +76,7 @@ describe 'Puppet::Util::AtFork' do
           else
             false
           end
-        end.and_return(true)
+        end.returns(true)
         load 'puppet/util/at_fork.rb'
         expect(Puppet::Util::AtFork.get_handler.class).to eq(Puppet::Util::AtFork::Solaris)
       end
@@ -88,24 +89,24 @@ describe 'Puppet::Util::AtFork' do
 
       it %q(should fail when libcontract cannot be loaded) do
         stub_solaris_handler
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_raise(Fiddle::DLError, 'no such library')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).raises(Fiddle::DLError, 'no such library')
         expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such library')
       end
 
       it %q(should fail when libcontract doesn't define all the necessary functions) do
         stub_solaris_handler
-        handle = double('Fiddle::Handle')
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_return(handle)
-        expect(handle).to receive(:[]).and_raise(Fiddle::DLError, 'no such method')
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.expects(:[]).raises(Fiddle::DLError, 'no such method')
         expect { load 'puppet/util/at_fork.rb' }.to raise_error(Fiddle::DLError, 'no such method')
       end
 
       it %q(the returned Solaris specific handler should respond to the expected methods) do
         stub_solaris_handler
-        handle = double('Fiddle::Handle')
-        expect(Fiddle::Handle).to receive(:new).with(/^libcontract.so.*/).and_return(handle)
-        allow(handle).to receive(:[]).and_return(nil)
-        allow(Fiddle::Function).to receive(:new).and_return(Proc.new {})
+        handle = stub('Fiddle::Handle')
+        Fiddle::Handle.expects(:new).with(regexp_matches(/^libcontract.so.*/)).returns(handle)
+        handle.stubs(:[]).returns(nil)
+        Fiddle::Function.stubs(:new).returns(Proc.new {})
         load 'puppet/util/at_fork.rb'
         expect(Puppet::Util::AtFork.get_handler.public_methods).to include(*EXPECTED_HANDLER_METHODS)
       end
@@ -113,11 +114,11 @@ describe 'Puppet::Util::AtFork' do
 
     context 'when NOT on Solaris' do
       before :each do
-        expect(Facter).to receive(:value).with(:operatingsystem).and_return(nil)
+        Facter.expects(:value).with(:operatingsystem).returns(nil)
       end
 
       def stub_noop_handler(namespace_only = false)
-        allow(Puppet::Util::AtFork).to receive(:require).with(anything) do |lib|
+        Puppet::Util::AtFork.stubs(:require).with() do |lib|
           if lib == 'puppet/util/at_fork/noop'
             if namespace_only
               Puppet::Util::AtFork.class_exec do
@@ -130,7 +131,7 @@ describe 'Puppet::Util::AtFork' do
           else
             false
           end
-        end.and_return(true)
+        end.returns(true)
       end
 
       it %q(should return the Noop AtFork handler) do

data/spec/unit/util/autoload_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'fileutils'
 
@@ -12,13 +13,13 @@ describe Puppet::Util::Autoload do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
     @loaded = {}
-    allow(@autoload.class).to receive(:loaded).and_return(@loaded)
+    @autoload.class.stubs(:loaded).returns(@loaded)
   end
 
   describe "when building the search path" do
     before :each do
       ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
-      allow(Puppet.settings).to receive(:app_defaults_initialized?).and_return(true)
+      Puppet.settings.stubs(:app_defaults_initialized?).returns(true)
     end
 
     def with_libdir(libdir)
@@ -85,8 +86,8 @@ describe Puppet::Util::Autoload do
       Puppet[:vendormoduledir] = vendor_dir
 
       with_libdir(libdir) do
-        expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})
-        expect(@autoload.class).to receive(:module_directories).and_return(%w{/three /four})
+        @autoload.class.expects(:gem_directories).returns %w{/one /two}
+        @autoload.class.expects(:module_directories).returns %w{/three /four}
         dirs = @autoload.class.search_directories(nil)
         expect(dirs[0..4]).to eq(%w{/one /two /three /four} + [libdir])
         expect(dirs.last).to eq(module_libdir)
@@ -96,8 +97,8 @@ describe Puppet::Util::Autoload do
     it "does not split the Puppet[:libdir]" do
       dir = File.expand_path("/libdir1#{File::PATH_SEPARATOR}/libdir2")
       with_libdir(dir) do
-        expect(@autoload.class).to receive(:gem_directories).and_return(%w{/one /two})
-        expect(@autoload.class).to receive(:module_directories).and_return(%w{/three /four})
+        @autoload.class.expects(:gem_directories).returns %w{/one /two}
+        @autoload.class.expects(:module_directories).returns %w{/three /four}
         dirs = @autoload.class.search_directories(nil)
         expect(dirs).to include(dir)
       end
@@ -106,10 +107,10 @@ describe Puppet::Util::Autoload do
 
   describe "when loading a file" do
     before do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-      allow(FileTest).to receive(:directory?).and_return(true)
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
       @time_a = Time.utc(2010, 'jan', 1, 6, 30)
-      allow(File).to receive(:mtime).and_return(@time_a)
+      File.stubs(:mtime).returns @time_a
     end
 
     after(:each) do
@@ -118,9 +119,9 @@ describe Puppet::Util::Autoload do
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
-        allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).returns true
 
-        expect(Kernel).to receive(:load).and_raise(error)
+        Kernel.expects(:load).raises error
 
         expect { @autoload.load("foo", env) }.to raise_error(Puppet::Error)
       end
@@ -131,24 +132,24 @@ describe Puppet::Util::Autoload do
     end
 
     it "should register loaded files with the autoloader" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.stubs(:load)
       @autoload.load("myfile", env)
 
       expect(@autoload.class.loaded?("tmp/myfile.rb")).to be
     end
 
     it "should be seen by loaded? on the instance using the short name" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.stubs(:load)
       @autoload.load("myfile", env)
 
       expect(@autoload.loaded?("myfile.rb")).to be
     end
 
     it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.stubs(:load)
 
       @autoload.load("myfile", env)
 
@@ -156,17 +157,17 @@ describe Puppet::Util::Autoload do
     end
 
     it "should load the first file in the searchpath" do
-      allow(@autoload).to receive(:search_directories).and_return([make_absolute("/a"), make_absolute("/b")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      expect(Kernel).to receive(:load).with(make_absolute("/a/tmp/myfile.rb"), any_args)
+      @autoload.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
+      FileTest.stubs(:directory?).returns true
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.expects(:load).with(make_absolute("/a/tmp/myfile.rb"), optionally(anything))
 
       @autoload.load("myfile", env)
     end
 
     it "should treat equivalent paths to a loaded file as loaded" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.stubs(:load)
       @autoload.load("myfile", env)
 
       expect(@autoload.class.loaded?("tmp/myfile")).to be
@@ -178,26 +179,26 @@ describe Puppet::Util::Autoload do
 
   describe "when loading all files" do
     before do
-      allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(Dir).to receive(:glob).and_return([make_absolute("/a/foo/file.rb")])
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
+      Dir.stubs(:glob).returns [make_absolute("/a/foo/file.rb")]
+      Puppet::FileSystem.stubs(:exist?).returns true
       @time_a = Time.utc(2010, 'jan', 1, 6, 30)
-      allow(File).to receive(:mtime).and_return(@time_a)
+      File.stubs(:mtime).returns @time_a
 
-      allow(@autoload.class).to receive(:loaded?).and_return(false)
+      @autoload.class.stubs(:loaded?).returns(false)
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die an if a #{error.to_s} exception is thrown" do
-        expect(Kernel).to receive(:load).and_raise(error)
+        Kernel.expects(:load).raises error
 
         expect { @autoload.loadall(env) }.to raise_error(Puppet::Error)
       end
     end
 
     it "should require the full path to the file" do
-      expect(Kernel).to receive(:load).with(make_absolute("/a/foo/file.rb"), any_args)
+      Kernel.expects(:load).with(make_absolute("/a/foo/file.rb"), optionally(anything))
 
       @autoload.loadall(env)
     end
@@ -221,14 +222,14 @@ describe Puppet::Util::Autoload do
     end
 
     it "changes should be seen by changed? on the instance using the short name" do
-      allow(File).to receive(:mtime).and_return(@first_time)
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(Kernel).to receive(:load)
+      File.stubs(:mtime).returns(@first_time)
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Kernel.stubs(:load)
       @autoload.load("myfile", env)
       expect(@autoload.loaded?("myfile")).to be
       expect(@autoload.changed?("myfile", env)).not_to be
 
-      allow(File).to receive(:mtime).and_return(@second_time)
+      File.stubs(:mtime).returns(@second_time)
       expect(@autoload.changed?("myfile", env)).to be
 
       $LOADED_FEATURES.delete("tmp/myfile.rb")
@@ -236,51 +237,51 @@ describe Puppet::Util::Autoload do
 
     describe "in one directory" do
       before :each do
-        allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a")])
-        expect(File).to receive(:mtime).with(@file_a).and_return(@first_time)
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+        File.expects(:mtime).with(@file_a).returns(@first_time)
         @autoload.class.mark_loaded("file", @file_a)
       end
 
       it "should reload if mtime changes" do
-        allow(File).to receive(:mtime).with(@file_a).and_return(@first_time + 60)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(true)
-        expect(Kernel).to receive(:load).with(@file_a, any_args)
+        File.stubs(:mtime).with(@file_a).returns(@first_time + 60)
+        Puppet::FileSystem.stubs(:exist?).with(@file_a).returns true
+        Kernel.expects(:load).with(@file_a, optionally(anything))
         @autoload.class.reload_changed(env)
       end
 
       it "should do nothing if the file is deleted" do
-        allow(File).to receive(:mtime).with(@file_a).and_raise(Errno::ENOENT)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(false)
-        expect(Kernel).not_to receive(:load)
+        File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
+        Puppet::FileSystem.stubs(:exist?).with(@file_a).returns false
+        Kernel.expects(:load).never
         @autoload.class.reload_changed(env)
       end
     end
 
     describe "in two directories" do
       before :each do
-        allow(@autoload.class).to receive(:search_directories).and_return([make_absolute("/a"), make_absolute("/b")])
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
       end
 
       it "should load b/file when a/file is deleted" do
-        expect(File).to receive(:mtime).with(@file_a).and_return(@first_time)
+        File.expects(:mtime).with(@file_a).returns(@first_time)
         @autoload.class.mark_loaded("file", @file_a)
-        allow(File).to receive(:mtime).with(@file_a).and_raise(Errno::ENOENT)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_b).and_return(true)
-        allow(File).to receive(:mtime).with(@file_b).and_return(@first_time)
-        expect(Kernel).to receive(:load).with(@file_b, any_args)
+        File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
+        Puppet::FileSystem.stubs(:exist?).with(@file_a).returns false
+        Puppet::FileSystem.stubs(:exist?).with(@file_b).returns true
+        File.stubs(:mtime).with(@file_b).returns @first_time
+        Kernel.expects(:load).with(@file_b, optionally(anything))
         @autoload.class.reload_changed(env)
         expect(@autoload.class.send(:loaded)["file"]).to eq([@file_b, @first_time])
       end
 
       it "should load a/file when b/file is loaded and a/file is created" do
-        allow(File).to receive(:mtime).with(@file_b).and_return(@first_time)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_b).and_return(true)
+        File.stubs(:mtime).with(@file_b).returns @first_time
+        Puppet::FileSystem.stubs(:exist?).with(@file_b).returns true
         @autoload.class.mark_loaded("file", @file_b)
 
-        allow(File).to receive(:mtime).with(@file_a).and_return(@first_time)
-        allow(Puppet::FileSystem).to receive(:exist?).with(@file_a).and_return(true)
-        expect(Kernel).to receive(:load).with(@file_a, any_args)
+        File.stubs(:mtime).with(@file_a).returns @first_time
+        Puppet::FileSystem.stubs(:exist?).with(@file_a).returns true
+        Kernel.expects(:load).with(@file_a, optionally(anything))
         @autoload.class.reload_changed(env)
         expect(@autoload.class.send(:loaded)["file"]).to eq([@file_a, @first_time])
       end

data/spec/unit/util/backups_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/backups'
@@ -5,10 +6,10 @@ require 'puppet/util/backups'
 describe Puppet::Util::Backups do
   include PuppetSpec::Files
 
-  let(:bucket) { double('bucket', :name => "foo") }
+  let(:bucket) { stub('bucket', :name => "foo") }
   let!(:file) do
     f = Puppet::Type.type(:file).new(:name => path, :backup => 'foo')
-    allow(f).to receive(:bucket).and_return(bucket)
+    f.stubs(:bucket).returns(bucket)
     f
   end
 
@@ -18,8 +19,8 @@ describe Puppet::Util::Backups do
     it "should noop if the file does not exist" do
       file = Puppet::Type.type(:file).new(:name => path)
 
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).with(path).returns false
 
       file.perform_backup
     end
@@ -27,24 +28,24 @@ describe Puppet::Util::Backups do
     it "should succeed silently if self[:backup] is false" do
       file = Puppet::Type.type(:file).new(:name => path, :backup => false)
 
-      expect(file).not_to receive(:bucket)
-      expect(Puppet::FileSystem).not_to receive(:exist?)
+      file.expects(:bucket).never
+      Puppet::FileSystem.expects(:exist?).never
 
       file.perform_backup
     end
 
     it "a bucket should be used when provided" do
       lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).with(path).and_return("mysum")
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      bucket.expects(:backup).with(path).returns("mysum")
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
       file.perform_backup
     end
 
     it "should propagate any exceptions encountered when backing up to a filebucket" do
       lstat_path_as(path, 'file')
-      expect(bucket).to receive(:backup).and_raise(ArgumentError)
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      bucket.expects(:backup).raises ArgumentError
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
       expect { file.perform_backup }.to raise_error(ArgumentError)
     end
@@ -56,42 +57,42 @@ describe Puppet::Util::Backups do
 
       it "should remove any local backup if one exists" do
         lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:unlink).with(backup)
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         file.perform_backup
       end
 
       it "should fail when the old backup can't be removed" do
         lstat_path_as(backup, 'file')
-        expect(Puppet::FileSystem).to receive(:unlink).with(backup).and_raise(ArgumentError)
-        expect(FileUtils).not_to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:unlink).with(backup).raises ArgumentError
+        FileUtils.expects(:cp_r).never
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         expect { file.perform_backup }.to raise_error(Puppet::Error)
       end
 
       it "should not try to remove backups that don't exist" do
-        expect(Puppet::FileSystem).to receive(:lstat).with(backup).and_raise(Errno::ENOENT)
-        expect(Puppet::FileSystem).not_to receive(:unlink).with(backup)
-        allow(FileUtils).to receive(:cp_r)
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.expects(:lstat).with(backup).raises(Errno::ENOENT)
+        Puppet::FileSystem.expects(:unlink).with(backup).never
+        FileUtils.stubs(:cp_r)
+        Puppet::FileSystem.expects(:exist?).with(path).returns(true)
 
         file.perform_backup
       end
 
       it "a copy should be created in the local directory" do
-        expect(FileUtils).to receive(:cp_r).with(path, backup, :preserve => true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        FileUtils.expects(:cp_r).with(path, backup, :preserve => true)
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
 
         expect(file.perform_backup).to be_truthy
       end
 
       it "should propagate exceptions if no backup can be created" do
-        expect(FileUtils).to receive(:cp_r).and_raise(ArgumentError)
+        FileUtils.expects(:cp_r).raises ArgumentError
 
-        allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
         expect { file.perform_backup }.to raise_error(Puppet::Error)
       end
     end
@@ -102,15 +103,15 @@ describe Puppet::Util::Backups do
     let(:filename) { File.join(path, 'file') }
 
     it "a bucket should work when provided" do
-      allow(File).to receive(:file?).with(filename).and_return(true)
-      expect(Find).to receive(:find).with(path).and_yield(filename)
+      File.stubs(:file?).with(filename).returns true
+      Find.expects(:find).with(path).yields(filename)
 
-      expect(bucket).to receive(:backup).with(filename).and_return(true)
+      bucket.expects(:backup).with(filename).returns true
 
       lstat_path_as(path, 'directory')
 
-      allow(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with(filename).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(filename).returns(true)
 
       file.perform_backup
     end
@@ -118,16 +119,16 @@ describe Puppet::Util::Backups do
     it "should do nothing when recursing" do
       file = Puppet::Type.type(:file).new(:name => path, :backup => 'foo', :recurse => true)
 
-      expect(bucket).not_to receive(:backup)
-      stub_file = double('file', :stat => double('stat', :ftype => 'directory'))
-      allow(Puppet::FileSystem).to receive(:new).with(path).and_return(stub_file)
-      expect(Find).not_to receive(:find)
+      bucket.expects(:backup).never
+      stub_file = stub('file', :stat => stub('stat', :ftype => 'directory'))
+      Puppet::FileSystem.stubs(:new).with(path).returns stub_file
+      Find.expects(:find).never
 
       file.perform_backup
     end
   end
 
   def lstat_path_as(path, ftype)
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('File::Stat', :ftype => ftype))
+    Puppet::FileSystem.expects(:lstat).with(path).returns(stub('File::Stat', :ftype => ftype))
   end
 end