puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/{provider/confine_spec.rb → confine_spec.rb}

@@ -1,40 +1,40 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confine'
+require 'puppet/confine'
 
-describe Puppet::Provider::Confine do
+describe Puppet::Confine do
   it "should require a value" do
-    lambda { Puppet::Provider::Confine.new }.should raise_error(ArgumentError)
+    lambda { Puppet::Confine.new }.should raise_error(ArgumentError)
   end
 
   it "should always convert values to an array" do
-    Puppet::Provider::Confine.new("/some/file").values.should be_instance_of(Array)
+    Puppet::Confine.new("/some/file").values.should be_instance_of(Array)
   end
 
   it "should have a 'true' test" do
-    Puppet::Provider::Confine.test(:true).should be_instance_of(Class)
+    Puppet::Confine.test(:true).should be_instance_of(Class)
   end
 
   it "should have a 'false' test" do
-    Puppet::Provider::Confine.test(:false).should be_instance_of(Class)
+    Puppet::Confine.test(:false).should be_instance_of(Class)
   end
 
   it "should have a 'feature' test" do
-    Puppet::Provider::Confine.test(:feature).should be_instance_of(Class)
+    Puppet::Confine.test(:feature).should be_instance_of(Class)
   end
 
   it "should have an 'exists' test" do
-    Puppet::Provider::Confine.test(:exists).should be_instance_of(Class)
+    Puppet::Confine.test(:exists).should be_instance_of(Class)
   end
 
   it "should have a 'variable' test" do
-    Puppet::Provider::Confine.test(:variable).should be_instance_of(Class)
+    Puppet::Confine.test(:variable).should be_instance_of(Class)
   end
 
   describe "when testing all values" do
     before do
-      @confine = Puppet::Provider::Confine.new(%w{a b c})
+      @confine = Puppet::Confine.new(%w{a b c})
       @confine.label = "foo"
     end
 
@@ -64,7 +64,7 @@ describe Puppet::Provider::Confine do
   end
 
   describe "when testing the result of the values" do
-    before { @confine = Puppet::Provider::Confine.new(%w{a b c d}) }
+    before { @confine = Puppet::Confine.new(%w{a b c d}) }
 
     it "should return an array with the result of the test for each value" do
       @confine.stubs(:pass?).returns true

data/spec/unit/{provider/confiner_spec.rb → confiner_spec.rb}

@@ -1,12 +1,12 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/provider/confiner'
+require 'puppet/confiner'
 
-describe Puppet::Provider::Confiner do
+describe Puppet::Confiner do
   before do
     @object = Object.new
-    @object.extend(Puppet::Provider::Confiner)
+    @object.extend(Puppet::Confiner)
   end
 
   it "should have a method for defining confines" do
@@ -29,7 +29,7 @@ describe Puppet::Provider::Confiner do
   end
 
   it "should create a new confine collection if one does not exist" do
-    Puppet::Provider::ConfineCollection.expects(:new).with("mylabel").returns "mycoll"
+    Puppet::ConfineCollection.expects(:new).with("mylabel").returns "mycoll"
     @object.expects(:to_s).returns "mylabel"
     @object.confine_collection.should == "mycoll"
   end

data/spec/unit/face/parser_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/face'
+
+describe Puppet::Face[:parser, :current] do
+  include PuppetSpec::Files
+
+  let(:parser) { Puppet::Face[:parser, :current] }
+
+  it "validates the configured site manifest when no files are given" do
+    Puppet[:manifest] = file_containing('site.pp', "{ invalid =>")
+    from_an_interactive_terminal
+
+    expect { parser.validate() }.to exit_with(1)
+  end
+
+  it "validates the given file" do
+    manifest = file_containing('site.pp', "{ invalid =>")
+    from_an_interactive_terminal
+
+    expect { parser.validate(manifest) }.to exit_with(1)
+  end
+
+  it "validates the contents of STDIN when no files given and STDIN is not a tty" do
+    from_a_piped_input_of("{ invalid =>")
+
+    expect { parser.validate() }.to exit_with(1)
+  end
+
+  it "runs error free when there are no validation errors" do
+    manifest = file_containing('site.pp', "notify { valid: }")
+    from_an_interactive_terminal
+
+    parser.validate(manifest)
+  end
+
+  it "reports missing files" do
+    from_an_interactive_terminal
+
+    expect do
+      parser.validate("missing.pp")
+    end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
+  end
+
+  def from_an_interactive_terminal
+    STDIN.stubs(:tty?).returns(true)
+  end
+
+  def from_a_piped_input_of(contents)
+    STDIN.stubs(:tty?).returns(false)
+    STDIN.stubs(:read).returns(contents)
+  end
+end

data/spec/unit/file_bucket/dipper_spec.rb

@@ -45,7 +45,7 @@ describe Puppet::FileBucket::Dipper do
     Digest::MD5.hexdigest("my\r\ncontents").should == checksum
 
     @dipper.backup(file).should == checksum
-    File.exists?("#{file_bucket}/f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea/contents").should == true
+    Puppet::FileSystem::File.exist?("#{file_bucket}/f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea/contents").should == true
   end
 
   it "should not backup a file that is already in the bucket" do
@@ -123,7 +123,7 @@ describe Puppet::FileBucket::Dipper do
         klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(contents))
 
         dipper.restore(dest, md5).should == md5
-        Digest::MD5.hexdigest(IO.binread(dest)).should == md5
+        Digest::MD5.hexdigest(Puppet::FileSystem::File.new(dest).binread).should == md5
 
         request.key.should == "md5/#{md5}"
         request.server.should == server

data/spec/unit/file_serving/base_spec.rb

@@ -42,12 +42,12 @@ describe Puppet::FileServing::Base do
   end
 
   it "should allow specification of a path" do
-    FileTest.stubs(:exists?).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns(true)
     Puppet::FileServing::Base.new(path, :path => file).path.should == file
   end
 
   it "should allow specification of a relative path" do
-    FileTest.stubs(:exists?).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns(true)
     Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path.should == "my/file"
   end
 
@@ -56,19 +56,22 @@ describe Puppet::FileServing::Base do
   end
 
   it "should correctly indicate if the file is present" do
-    File.expects(:lstat).with(file).returns(mock("stat"))
+    mock_file = mock(file, :lstat => stub('stat'))
+    Puppet::FileSystem::File.expects(:new).with(file).returns mock_file
     Puppet::FileServing::Base.new(file).exist?.should be_true
   end
 
   it "should correctly indicate if the file is absent" do
-    File.expects(:lstat).with(file).raises RuntimeError
+    mock_file = mock(file)
+    Puppet::FileSystem::File.expects(:new).with(file).returns mock_file
+    mock_file.expects(:lstat).raises RuntimeError
     Puppet::FileServing::Base.new(file).exist?.should be_false
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
       @file = Puppet::FileServing::Base.new(path)
-      FileTest.stubs(:exists?).returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).returns(true)
       proc { @file.relative_path = File.expand_path("/qualified/file") }.should raise_error(ArgumentError)
     end
   end
@@ -102,27 +105,47 @@ describe Puppet::FileServing::Base do
     end
   end
 
+  describe "when handling a UNC file path on Windows" do
+    let(:path) { '//server/share/filename' }
+    let(:file) { Puppet::FileServing::Base.new(path) }
+
+    it "should preserve double slashes at the beginning of the path" do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      file.full_path.should == path
+    end
+
+    it "should strip double slashes not at the beginning of the path" do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      file = Puppet::FileServing::Base.new('//server//share//filename')
+      file.full_path.should == path
+    end
+  end
+
+
   describe "when stat'ing files" do
     let(:path) { File.expand_path('/this/file') }
     let(:file) { Puppet::FileServing::Base.new(path) }
+    let(:stat) { stub('stat', :ftype => 'file' ) }
+    let(:stubbed_file) { stub(path, :stat => stat, :lstat => stat)}
 
     it "should stat the file's full path" do
-      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
       file.stat
     end
 
     it "should fail if the file does not exist" do
-      File.expects(:lstat).with(path).raises(Errno::ENOENT)
+      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
+      stubbed_file.expects(:lstat).raises(Errno::ENOENT)
       proc { file.stat }.should raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
-      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
       file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
       file.links = :follow
       file.stat
     end

data/spec/unit/file_serving/configuration_spec.rb

@@ -27,12 +27,12 @@ describe Puppet::FileServing::Configuration do
   describe "when initializing" do
 
     it "should work without a configuration file" do
-      FileTest.stubs(:exists?).with(@path).returns(false)
+      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(false)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should parse the configuration file if present" do
-      FileTest.stubs(:exists?).with(@path).returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(true)
       @parser = mock 'parser'
       @parser.expects(:parse).returns({})
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
@@ -47,7 +47,7 @@ describe Puppet::FileServing::Configuration do
   describe "when parsing the configuration file" do
 
     before do
-      FileTest.stubs(:exists?).with(@path).returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(true)
       @parser = mock 'parser'
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
@@ -84,14 +84,14 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should add modules and plugins mounts even if the file does not exist" do
-      FileTest.expects(:exists?).returns false # the file doesn't exist
+      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
 
     it "should allow all access to modules and plugins if no fileserver.conf exists" do
-      FileTest.expects(:exists?).returns false # the file doesn't exist
+      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
       modules = stub 'modules', :empty? => true
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*')
@@ -104,7 +104,7 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should not allow access from all to modules and plugins if the fileserver.conf provided some rules" do
-      FileTest.expects(:exists?).returns false # the file doesn't exist
+      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
 
       modules = stub 'modules', :empty? => false
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
@@ -119,7 +119,7 @@ describe Puppet::FileServing::Configuration do
 
     it "should add modules and plugins mounts even if they are not returned by the parser" do
       @parser.expects(:parse).returns("one" => mock("mount"))
-      FileTest.expects(:exists?).returns true # the file doesn't exist
+      Puppet::FileSystem::File.expects(:exist?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true

data/spec/unit/file_serving/content_spec.rb

@@ -26,7 +26,8 @@ describe Puppet::FileServing::Content do
     content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
-    File.stubs(:lstat).returns(stub("stat", :ftype => "file"))
+    stub_file = stub(path, :lstat => stub('stat', :ftype => "file"))
+    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
     File.expects(:read).with(path).never
     content.collect
 
@@ -37,7 +38,8 @@ describe Puppet::FileServing::Content do
     content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
-    File.stubs(:lstat).returns(stub("stat", :ftype => "directory"))
+    stub_file = stub(path, :lstat => stub('stat', :ftype => "directory"))
+    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
     File.expects(:read).with(path).never
     content.collect
 
@@ -83,7 +85,8 @@ describe Puppet::FileServing::Content, "when returning the contents" do
 
   it "should fail if the file is a symlink and links are set to :manage" do
     content.links = :manage
-    File.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
+    stub_file = stub(path, :lstat => stub("stat", :ftype => "symlink"))
+    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
     proc { content.content }.should raise_error(ArgumentError)
   end
 
@@ -97,14 +100,16 @@ describe Puppet::FileServing::Content, "when returning the contents" do
   end
 
   it "should return the contents of the path if the file exists" do
-    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
-    IO.expects(:binread).with(path).returns(:mycontent)
+    mocked_file = mock(path, :stat => stub('stat', :ftype => 'file'))
+    Puppet::FileSystem::File.expects(:new).with(path).twice.returns(mocked_file)
+    mocked_file.expects(:binread).returns(:mycontent)
     content.content.should == :mycontent
   end
 
   it "should cache the returned contents" do
-    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
-    IO.expects(:binread).with(path).returns(:mycontent)
+    mocked_file = mock(path, :stat => stub('stat', :ftype => 'file'))
+    Puppet::FileSystem::File.expects(:new).with(path).twice.returns(mocked_file)
+    mocked_file.expects(:binread).returns(:mycontent)
     content.content
     # The second run would throw a failure if the content weren't being cached.
     content.content

data/spec/unit/file_serving/fileset_spec.rb

@@ -18,49 +18,58 @@ describe Puppet::FileServing::Fileset do
 
     it "removes a trailing file path separator" do
       path_with_separator = "#{somefile}#{File::SEPARATOR}"
-      File.stubs(:lstat).with(somefile).returns stub('stat')
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       fileset = Puppet::FileServing::Fileset.new(path_with_separator)
       fileset.path.should == somefile
     end
 
     it "can be created from the root directory" do
       path = File.expand_path(File::SEPARATOR)
-      File.stubs(:lstat).with(path).returns stub('stat')
+      stub_file = stub(path, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
       fileset = Puppet::FileServing::Fileset.new(path)
       fileset.path.should == path
     end
 
     it "fails if its path does not exist" do
-      File.expects(:lstat).with(somefile).raises(Errno::ENOENT)
+      mock_file = mock(somefile)
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns mock_file
+      mock_file.expects(:lstat).raises(Errno::ENOENT)
       expect { Puppet::FileServing::Fileset.new(somefile) }.to raise_error(ArgumentError, "Fileset paths must exist")
     end
 
     it "accepts a 'recurse' option" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       set = Puppet::FileServing::Fileset.new(somefile, :recurse => true)
       set.recurse.should be_true
     end
 
     it "accepts a 'recurselimit' option" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3)
       set.recurselimit.should == 3
     end
 
     it "accepts an 'ignore' option" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
       set.ignore.should == [".svn"]
     end
 
     it "accepts a 'links' option" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       set = Puppet::FileServing::Fileset.new(somefile, :links => :manage)
       set.links.should == :manage
     end
 
     it "accepts a 'checksum_type' option" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       set = Puppet::FileServing::Fileset.new(somefile, :checksum_type => :test)
       set.checksum_type.should == :test
     end
@@ -70,30 +79,35 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "defaults to 'false' for recurse" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       Puppet::FileServing::Fileset.new(somefile).recurse.should == false
     end
 
     it "defaults to :infinite for recurselimit" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       Puppet::FileServing::Fileset.new(somefile).recurselimit.should == :infinite
     end
 
     it "defaults to an empty ignore list" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       Puppet::FileServing::Fileset.new(somefile).ignore.should == []
     end
 
     it "defaults to :manage for links" do
-      File.expects(:lstat).with(somefile).returns stub("stat")
+      stub_file = stub(somefile, :lstat => stub('stat'))
+      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       Puppet::FileServing::Fileset.new(somefile).links.should == :manage
     end
 
     describe "using an indirector request" do
       let(:values) { { :links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234 } }
+      let(:stub_file) { stub(somefile, :lstat => stub('stat')) }
 
       before :each do
-        File.stubs(:lstat).returns stub("stat")
+        Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
       end
 
       [:recurse, :recurselimit, :ignore, :links].each do |option|
@@ -130,7 +144,8 @@ describe Puppet::FileServing::Fileset do
   context "when recursing" do
     before do
       @path = make_absolute("/my/path")
-      File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+      @stub_file = stub(@path, :lstat => stub('stat', :directory? => true))
+      Puppet::FileSystem::File.stubs(:new).with(@path).returns @stub_file
       @fileset = Puppet::FileServing::Fileset.new(@path)
 
       @dirstat = stub 'dirstat', :directory? => true
@@ -138,7 +153,7 @@ describe Puppet::FileServing::Fileset do
     end
 
     def mock_dir_structure(path, stat_method = :lstat)
-      File.stubs(stat_method).with(path).returns(@dirstat)
+      @stub_file.stubs(stat_method).returns(@dirstat)
       Dir.stubs(:entries).with(path).returns(%w{one two .svn CVS})
 
       # Keep track of the files we're stubbing.
@@ -147,11 +162,14 @@ describe Puppet::FileServing::Fileset do
       %w{one two .svn CVS}.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
-        File.stubs(stat_method).with(subpath).returns(@dirstat)
+        stub_subpath = stub(subpath, stat_method => @dirstat)
+        Puppet::FileSystem::File.stubs(:new).with(subpath).returns stub_subpath
         Dir.stubs(:entries).with(subpath).returns(%w{.svn CVS file1 file2})
         %w{file1 file2 .svn CVS}.each do |file|
           @files << File.join(subdir, file) # relative path
-          File.stubs(stat_method).with(File.join(subpath, file)).returns(@filestat)
+          subfile_path = File.join(subpath, file)
+          stub_subfile_path = stub(subfile_path, stat_method => @filestat)
+          Puppet::FileSystem::File.stubs(:new).with(subfile_path).returns stub_subfile_path
         end
       end
     end
@@ -165,8 +183,10 @@ describe Puppet::FileServing::Fileset do
 
     MockDirectory = Struct.new(:name, :entries) do
       def mock(base_path)
+        extend Mocha::API
         path = File.join(base_path, name)
-        File.stubs(:lstat).with(path).returns(MockStat.new(path, true))
+        stub_dir = stub(path, :lstat => MockStat.new(path, true))
+        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_dir
         Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
         entries.each do |entry|
           entry.mock(path)
@@ -176,8 +196,10 @@ describe Puppet::FileServing::Fileset do
 
     MockFile = Struct.new(:name) do
       def mock(base_path)
+        extend Mocha::API
         path = File.join(base_path, name)
-        File.stubs(:lstat).with(path).returns(MockStat.new(path, false))
+        stub_file = stub(path, :lstat => MockStat.new(path, false))
+        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_file
       end
     end
 
@@ -239,14 +261,14 @@ describe Puppet::FileServing::Fileset do
       @fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }.should be_nil
     end
 
-    it "uses File.stat if :links is set to :follow" do
+    it "uses Puppet::FileSystem::File#stat if :links is set to :follow" do
       mock_dir_structure(@path, :stat)
       @fileset.recurse = true
       @fileset.links = :follow
       @fileset.files.sort.should == @files.sort
     end
 
-    it "uses File.lstat if :links is set to :manage" do
+    it "uses Puppet::FileSystem::File#lstat if :links is set to :manage" do
       mock_dir_structure(@path, :lstat)
       @fileset.recurse = true
       @fileset.links = :manage
@@ -255,7 +277,9 @@ describe Puppet::FileServing::Fileset do
 
     it "works when paths have regexp significant characters" do
       @path = make_absolute("/my/path/rV1x2DafFr0R6tGG+1bbk++++TM")
-      File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+      stat = stub('dir_stat', :directory? => true)
+      stub_file = stub(@path, :stat => stat, :lstat => stat)
+      Puppet::FileSystem::File.expects(:new).with(@path).twice.returns stub_file
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)
       @fileset.recurse = true
@@ -267,9 +291,13 @@ describe Puppet::FileServing::Fileset do
     path = make_absolute("/my/path")
     stat = stub 'stat', :directory? => true
 
-    File.expects(:lstat).with(path).returns(stat)
-    File.expects(:stat).with(path).returns(stat)
-    File.expects(:stat).with(File.join(path, "mylink")).raises(Errno::ENOENT)
+    mock_file = mock(path, :lstat => stat, :stat => stat)
+    Puppet::FileSystem::File.expects(:new).with(path).twice.returns mock_file
+
+    link_path = File.join(path, "mylink")
+    mock_link = mock(link_path)
+    Puppet::FileSystem::File.expects(:new).with(link_path).returns mock_link
+    mock_link.expects(:stat).raises(Errno::ENOENT)
 
     Dir.stubs(:entries).with(path).returns(["mylink"])
 
@@ -284,10 +312,12 @@ describe Puppet::FileServing::Fileset do
   context "when merging other filesets" do
     before do
       @paths = [make_absolute("/first/path"), make_absolute("/second/path"), make_absolute("/third/path")]
-      File.stubs(:lstat).returns stub("stat", :directory? => false)
+      stub_file = stub(:lstat => stub('stat', :directory? => false))
+      Puppet::FileSystem::File.stubs(:new).returns stub_file
 
       @filesets = @paths.collect do |path|
-        File.stubs(:lstat).with(path).returns stub("stat", :directory? => true)
+        stub_dir = stub(path, :lstat => stub('stat', :directory? => true))
+        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_dir
         Puppet::FileServing::Fileset.new(path, :recurse => true)
       end