puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/file_serving/metadata_spec.rb

@@ -1,22 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-
 require 'puppet/file_serving/metadata'
-
-# the json-schema gem doesn't support windows
-if not Puppet.features.microsoft_windows?
-  FILE_METADATA_SCHEMA = JSON.parse(File.read(File.join(File.dirname(__FILE__), '../../../api/schemas/file_metadata.json')))
-
-  describe "catalog schema" do
-    it "should validate against the json meta-schema" do
-      JSON::Validator.validate!(JSON_META_SCHEMA, FILE_METADATA_SCHEMA)
-    end
-  end
-
-  def validate_json_for_file_metadata(file_metadata)
-    JSON::Validator.validate!(FILE_METADATA_SCHEMA, file_metadata.to_pson)
-  end
-end
+require 'matchers/json'
 
 describe Puppet::FileServing::Metadata do
   let(:foobar) { File.expand_path('/foo/bar') }
@@ -41,8 +26,8 @@ describe Puppet::FileServing::Metadata do
     Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson_data_hash)
   end
 
-  it "should support pson deserialization" do
-    Puppet::FileServing::Metadata.should respond_to(:from_pson)
+  it "should support deserialization" do
+    Puppet::FileServing::Metadata.should respond_to(:from_data_hash)
   end
 
   describe "when serializing" do
@@ -103,6 +88,7 @@ describe Puppet::FileServing::Metadata do
 end
 
 describe Puppet::FileServing::Metadata do
+  include JSONMatchers
   include PuppetSpec::Files
 
   shared_examples_for "metadata collector" do
@@ -154,8 +140,8 @@ describe Puppet::FileServing::Metadata do
           end
         end
 
-        it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
-          validate_json_for_file_metadata(metadata)
+        it "should validate against the schema" do
+          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
         end
       end
 
@@ -179,14 +165,54 @@ describe Puppet::FileServing::Metadata do
           metadata.checksum.should == "{ctime}#{time}"
         end
 
-        it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
+        it "should validate against the schema" do
           metadata.collect
-          validate_json_for_file_metadata(metadata)
+          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
         end
       end
     end
   end
 
+  describe "WindowsStat", :if => Puppet.features.microsoft_windows? do
+    include PuppetSpec::Files
+
+    it "should return default owner, group and mode when the given path has an invalid DACL (such as a non-NTFS volume)" do
+      invalid_error = Puppet::Util::Windows::Error.new('Invalid DACL', 1336)
+      path = tmpfile('foo')
+      FileUtils.touch(path)
+
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path).raises(invalid_error)
+
+      stat = Puppet::FileSystem.stat(path)
+
+      win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path)
+
+      win_stat.owner.should == 'S-1-5-32-544'
+      win_stat.group.should == 'S-1-0-0'
+      win_stat.mode.should == 0644
+    end
+
+    it "should still raise errors that are not the result of an 'Invalid DACL'" do
+      invalid_error = ArgumentError.new('bar')
+      path = tmpfile('bar')
+      FileUtils.touch(path)
+
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path).raises(invalid_error)
+
+      stat = Puppet::FileSystem.stat(path)
+
+      win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path)
+
+      expect { win_stat.owner }.to raise_error(ArgumentError)
+      expect { win_stat.group }.to raise_error(ArgumentError)
+      expect { win_stat.mode }.to raise_error(ArgumentError)
+    end
+  end
+
   shared_examples_for "metadata collector symlinks" do
 
     let(:metadata) do
@@ -201,21 +227,21 @@ describe Puppet::FileServing::Metadata do
         let(:path) { tmpfile('file_serving_metadata_link') }
         let(:target) { tmpfile('file_serving_metadata_target') }
         let(:checksum) { Digest::MD5.hexdigest("some content\n") }
-        let(:fmode) { Puppet::FileSystem::File.new(path).lstat.mode & 0777 }
+        let(:fmode) { Puppet::FileSystem.lstat(path).mode & 0777 }
 
         before :each do
           File.open(target, "wb") {|f| f.print("some content\n")}
           set_mode(0644, target)
 
-          Puppet::FileSystem::File.new(target).symlink(path)
+          Puppet::FileSystem.symlink(target, path)
         end
 
         it "should read links instead of returning their checksums" do
           metadata.destination.should == target
         end
 
-        it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
-          validate_json_for_file_metadata(metadata)
+        it "should validate against the schema" do
+          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
         end
       end
     end
@@ -248,8 +274,8 @@ describe Puppet::FileServing::Metadata do
         proc { metadata.collect}.should raise_error(Errno::ENOENT)
       end
 
-      it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
-        validate_json_for_file_metadata(metadata)
+      it "should validate against the schema" do
+        expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
       end
     end
   end
@@ -291,6 +317,9 @@ describe Puppet::FileServing::Metadata do
         data.collect
         data
       end
+      let (:invalid_dacl_error) do
+        Puppet::Util::Windows::Error.new('Invalid DACL', 1336)
+      end
 
       it "should default owner" do
         Puppet::Util::Windows::Security.stubs(:get_owner).returns nil
@@ -309,6 +338,28 @@ describe Puppet::FileServing::Metadata do
 
         metadata.mode.should == 0644
       end
+
+      describe "when the path raises an Invalid ACL error" do
+        # these simulate the behavior of a symlink file whose target does not support ACLs
+        it "should default owner" do
+          Puppet::Util::Windows::Security.stubs(:get_owner).raises(invalid_dacl_error)
+
+          metadata.owner.should == 'S-1-5-32-544'
+        end
+
+        it "should default group" do
+          Puppet::Util::Windows::Security.stubs(:get_group).raises(invalid_dacl_error)
+
+          metadata.group.should == 'S-1-0-0'
+        end
+
+        it "should default mode" do
+          Puppet::Util::Windows::Security.stubs(:get_mode).raises(invalid_dacl_error)
+
+          metadata.mode.should == 0644
+        end
+      end
+
     end
 
     def set_mode(mode, path)
@@ -325,7 +376,8 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
       @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
       stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
       stub_file = stub(:readlink => "/some/other/path", :lstat => stat)
-      Puppet::FileSystem::File.expects(:new).with(path).at_least_once.returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
+      Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
 
@@ -356,9 +408,8 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
       path = "/base/path/my/file"
       @file = Puppet::FileServing::Metadata.new(path, :links => :follow)
       stat = stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
-      mocked_file = mock(path, :stat => stat)
-      Puppet::FileSystem::File.expects(:new).with(path).at_least_once.returns mocked_file
-      mocked_file.expects(:readlink).never
+      Puppet::FileSystem.expects(:stat).with(path).at_least_once.returns stat
+      Puppet::FileSystem.expects(:readlink).never
 
       if Puppet.features.microsoft_windows?
         win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',

data/spec/unit/file_serving/mount/file_spec.rb

@@ -85,7 +85,7 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
@@ -95,12 +95,12 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return nil if the file is absent" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.complete_path("/my/path", nil).should be_nil
     end
 
     it "should write a log message if the file is absent" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
 
       Puppet.expects(:info).with("File does not exist or is not accessible: /mount/my/path")
 
@@ -108,12 +108,12 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return the file path if the file is present" do
-      Puppet::FileSystem::File.stubs(:exist?).with("/my/path").returns(true)
+      Puppet::FileSystem.stubs(:exist?).with("/my/path").returns(true)
       @mount.complete_path("/my/path", nil).should == "/mount/my/path"
     end
 
     it "should treat a nil file name as the path to the mount itself" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       @mount.complete_path(nil, nil).should == "/mount"
     end
 
@@ -141,7 +141,7 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
@@ -153,7 +153,7 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return the results of the complete file path" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       @mount.find("/my/path", @request).should == "eh"
     end
@@ -163,7 +163,7 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
@@ -175,13 +175,13 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return the results of the complete file path as an array" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       @mount.search("/my/path", @request).should == ["eh"]
     end
 
     it "should return nil if the complete path is nil" do
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns nil
       @mount.search("/my/path", @request).should be_nil
     end

data/spec/unit/file_system/tempfile_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::FileSystem::Tempfile do
       file.write("stuff")
       file.flush
 
-      expect(Puppet::FileSystem::File.new(file.path).read).to eq("stuff")
+      expect(Puppet::FileSystem.read(file.path)).to eq("stuff")
     end
   end
 
@@ -29,7 +29,7 @@ describe Puppet::FileSystem::Tempfile do
       file.path
     end
 
-    expect(Puppet::FileSystem::File.new(filename).exist?).to be_false
+    expect(Puppet::FileSystem.exist?(filename)).to be_false
   end
 
   it "unlinks the temporary file even if the block raises an error" do
@@ -43,6 +43,6 @@ describe Puppet::FileSystem::Tempfile do
     rescue
     end
 
-    expect(Puppet::FileSystem::File.new(filename).exist?).to be_false
+    expect(Puppet::FileSystem.exist?(filename)).to be_false
   end
 end

data/spec/unit/file_system_spec.rb

@@ -0,0 +1,508 @@
+require 'spec_helper'
+require 'puppet/file_system'
+require 'puppet/util/platform'
+
+describe "Puppet::FileSystem" do
+  include PuppetSpec::Files
+
+  context "#exclusive_open" do
+    it "opens ands allows updating of an existing file" do
+      file = file_containing("file_to_update", "the contents")
+
+      Puppet::FileSystem.exclusive_open(file, 0660, 'r+') do |fh|
+        old = fh.read
+        fh.truncate(0)
+        fh.rewind
+        fh.write("updated #{old}")
+      end
+
+      expect(Puppet::FileSystem.read(file)).to eq("updated the contents")
+    end
+
+    it "opens, creates ands allows updating of a new file" do
+      file = tmpfile("file_to_update")
+
+      Puppet::FileSystem.exclusive_open(file, 0660, 'w') do |fh|
+        fh.write("updated new file")
+      end
+
+      expect(Puppet::FileSystem.read(file)).to eq("updated new file")
+    end
+
+    it "excludes other processes from updating at the same time", :unless => Puppet::Util::Platform.windows? do
+      file = file_containing("file_to_update", "0")
+
+      increment_counter_in_multiple_processes(file, 5, 'r+')
+
+      expect(Puppet::FileSystem.read(file)).to eq("5")
+    end
+
+    it "excludes other processes from updating at the same time even when creating the file", :unless => Puppet::Util::Platform.windows? do
+      file = tmpfile("file_to_update")
+
+      increment_counter_in_multiple_processes(file, 5, 'a+')
+
+      expect(Puppet::FileSystem.read(file)).to eq("5")
+    end
+
+    it "times out if the lock cannot be aquired in a specified amount of time", :unless => Puppet::Util::Platform.windows? do
+      file = tmpfile("file_to_update")
+
+      child = spawn_process_that_locks(file)
+
+      expect do
+        Puppet::FileSystem.exclusive_open(file, 0666, 'a', 0.1) do |f|
+        end
+      end.to raise_error(Timeout::Error)
+
+      Process.kill(9, child)
+    end
+
+    def spawn_process_that_locks(file)
+      read, write = IO.pipe
+
+      child = Kernel.fork do
+        read.close
+        Puppet::FileSystem.exclusive_open(file, 0666, 'a') do |fh|
+          write.write(true)
+          write.close
+          sleep 10
+        end
+      end
+
+      write.close
+      read.read
+      read.close
+
+      child
+    end
+
+    def increment_counter_in_multiple_processes(file, num_procs, options)
+      children = []
+      num_procs.times do
+        children << Kernel.fork do
+          Puppet::FileSystem.exclusive_open(file, 0660, options) do |fh|
+            fh.rewind
+            contents = (fh.read || 0).to_i
+            fh.truncate(0)
+            fh.rewind
+            fh.write((contents + 1).to_s)
+          end
+          exit(0)
+        end
+      end
+
+      children.each { |pid| Process.wait(pid) }
+    end
+  end
+
+  describe "symlink",
+    :if => ! Puppet.features.manages_symlinks? &&
+    Puppet.features.microsoft_windows? do
+
+    let(:file)         { tmpfile("somefile") }
+    let(:missing_file) { tmpfile("missingfile") }
+    let(:expected_msg) { "This version of Windows does not support symlinks.  Windows Vista / 2008 or higher is required." }
+
+    before :each do
+      FileUtils.touch(file)
+    end
+
+    it "should raise an error when trying to create a symlink" do
+      expect { Puppet::FileSystem.symlink(file, 'foo') }.to raise_error(Puppet::Util::Windows::Error)
+    end
+
+    it "should return false when trying to check if a path is a symlink" do
+      Puppet::FileSystem.symlink?(file).should be_false
+    end
+
+    it "should raise an error when trying to read a symlink" do
+      expect { Puppet::FileSystem.readlink(file) }.to raise_error(Puppet::Util::Windows::Error)
+    end
+
+    it "should return a File::Stat instance when calling stat on an existing file" do
+      Puppet::FileSystem.stat(file).should be_instance_of(File::Stat)
+    end
+
+    it "should raise Errno::ENOENT when calling stat on a missing file" do
+      expect { Puppet::FileSystem.stat(missing_file) }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should fall back to stat when trying to lstat a file" do
+      Puppet::Util::Windows::File.expects(:stat).with(Puppet::FileSystem.assert_path(file))
+
+      Puppet::FileSystem.lstat(file)
+    end
+  end
+
+  describe "symlink", :if => Puppet.features.manages_symlinks? do
+
+    let(:file)          { tmpfile("somefile") }
+    let(:missing_file)  { tmpfile("missingfile") }
+    let(:dir)           { tmpdir("somedir") }
+
+    before :each do
+      FileUtils.touch(file)
+    end
+
+    it "should return true for exist? on a present file" do
+      Puppet::FileSystem.exist?(file).should be_true
+    end
+
+    it "should return true for file? on a present file" do
+      Puppet::FileSystem.file?(file).should be_true
+    end
+
+    it "should return false for exist? on a non-existant file" do
+      Puppet::FileSystem.exist?(missing_file).should be_false
+    end
+
+    it "should return true for exist? on a present directory" do
+      Puppet::FileSystem.exist?(dir).should be_true
+    end
+
+    it "should return false for exist? on a dangling symlink" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(missing_file, symlink)
+
+      Puppet::FileSystem.exist?(missing_file).should be_false
+      Puppet::FileSystem.exist?(symlink).should be_false
+    end
+
+    it "should return true for exist? on valid symlinks" do
+      [file, dir].each do |target|
+        symlink = tmpfile("#{Puppet::FileSystem.basename(target).to_s}_link")
+        Puppet::FileSystem.symlink(target, symlink)
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.exist?(symlink).should be_true
+      end
+    end
+
+    it "should not create a symlink when the :noop option is specified" do
+      [file, dir].each do |target|
+        symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
+        Puppet::FileSystem.symlink(target, symlink, { :noop => true })
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.exist?(symlink).should be_false
+      end
+    end
+
+    it "should raise Errno::EEXIST if trying to create a file / directory symlink when the symlink path already exists as a file" do
+      existing_file = tmpfile("#{Puppet::FileSystem.basename(file)}_link")
+      FileUtils.touch(existing_file)
+
+      [file, dir].each do |target|
+        expect { Puppet::FileSystem.symlink(target, existing_file) }.to raise_error(Errno::EEXIST)
+
+        Puppet::FileSystem.exist?(existing_file).should be_true
+        Puppet::FileSystem.symlink?(existing_file).should be_false
+      end
+    end
+
+    it "should silently fail if trying to create a file / directory symlink when the symlink path already exists as a directory" do
+      existing_dir = tmpdir("#{Puppet::FileSystem.basename(file)}_dir")
+
+      [file, dir].each do |target|
+        Puppet::FileSystem.symlink(target, existing_dir).should == 0
+
+        Puppet::FileSystem.exist?(existing_dir).should be_true
+        File.directory?(existing_dir).should be_true
+        Puppet::FileSystem.symlink?(existing_dir).should be_false
+      end
+    end
+
+    it "should silently fail to modify an existing directory symlink to reference a new file or directory" do
+      [file, dir].each do |target|
+        existing_dir = tmpdir("#{Puppet::FileSystem.basename(target)}_dir")
+        symlink = tmpfile("#{Puppet::FileSystem.basename(existing_dir)}_link")
+        Puppet::FileSystem.symlink(existing_dir, symlink)
+
+        Puppet::FileSystem.readlink(symlink).should == Puppet::FileSystem.path_string(existing_dir)
+
+        # now try to point it at the new target, no error raised, but file system unchanged
+        Puppet::FileSystem.symlink(target, symlink).should == 0
+        Puppet::FileSystem.readlink(symlink).should == existing_dir.to_s
+      end
+    end
+
+    it "should raise Errno::EEXIST if trying to modify a file symlink to reference a new file or directory" do
+      symlink = tmpfile("#{Puppet::FileSystem.basename(file)}_link")
+      file_2 = tmpfile("#{Puppet::FileSystem.basename(file)}_2")
+      FileUtils.touch(file_2)
+      # symlink -> file_2
+      Puppet::FileSystem.symlink(file_2, symlink)
+
+      [file, dir].each do |target|
+        expect { Puppet::FileSystem.symlink(target, symlink) }.to raise_error(Errno::EEXIST)
+        Puppet::FileSystem.readlink(symlink).should == file_2.to_s
+      end
+    end
+
+    it "should delete the existing file when creating a file / directory symlink with :force when the symlink path exists as a file" do
+      [file, dir].each do |target|
+        existing_file = tmpfile("#{Puppet::FileSystem.basename(target)}_existing")
+        FileUtils.touch(existing_file)
+        Puppet::FileSystem.symlink?(existing_file).should be_false
+
+        Puppet::FileSystem.symlink(target, existing_file, { :force => true })
+
+        Puppet::FileSystem.symlink?(existing_file).should be_true
+        Puppet::FileSystem.readlink(existing_file).should == target.to_s
+      end
+    end
+
+    it "should modify an existing file symlink when using :force to reference a new file or directory" do
+      [file, dir].each do |target|
+        existing_file = tmpfile("#{Puppet::FileSystem.basename(target)}_existing")
+        FileUtils.touch(existing_file)
+        existing_symlink = tmpfile("#{Puppet::FileSystem.basename(existing_file)}_link")
+        Puppet::FileSystem.symlink(existing_file, existing_symlink)
+
+        Puppet::FileSystem.readlink(existing_symlink).should == existing_file.to_s
+
+        Puppet::FileSystem.symlink(target, existing_symlink, { :force => true })
+
+        Puppet::FileSystem.readlink(existing_symlink).should == target.to_s
+      end
+    end
+
+    it "should silently fail if trying to overwrite an existing directory with a new symlink when using :force to reference a file or directory" do
+      [file, dir].each do |target|
+        existing_dir = tmpdir("#{Puppet::FileSystem.basename(target)}_existing")
+
+        Puppet::FileSystem.symlink(target, existing_dir, { :force => true }).should == 0
+
+        Puppet::FileSystem.symlink?(existing_dir).should be_false
+      end
+    end
+
+    it "should silently fail if trying to modify an existing directory symlink when using :force to reference a new file or directory" do
+      [file, dir].each do |target|
+        existing_dir = tmpdir("#{Puppet::FileSystem.basename(target)}_existing")
+        existing_symlink = tmpfile("#{Puppet::FileSystem.basename(existing_dir)}_link")
+        Puppet::FileSystem.symlink(existing_dir, existing_symlink)
+
+        Puppet::FileSystem.readlink(existing_symlink).should == existing_dir.to_s
+
+        Puppet::FileSystem.symlink(target, existing_symlink, { :force => true }).should == 0
+
+        Puppet::FileSystem.readlink(existing_symlink).should == existing_dir.to_s
+      end
+    end
+
+    it "should accept a string, Pathname or object with to_str (Puppet::Util::WatchedFile) for exist?" do
+      [ tmpfile('bogus1'),
+        Pathname.new(tmpfile('bogus2')),
+        Puppet::Util::WatchedFile.new(tmpfile('bogus3'))
+        ].each { |f| Puppet::FileSystem.exist?(f).should be_false  }
+    end
+
+    it "should return a File::Stat instance when calling stat on an existing file" do
+      Puppet::FileSystem.stat(file).should be_instance_of(File::Stat)
+    end
+
+    it "should raise Errno::ENOENT when calling stat on a missing file" do
+      expect { Puppet::FileSystem.stat(missing_file) }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should be able to create a symlink, and verify it with symlink?" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      Puppet::FileSystem.symlink?(symlink).should be_true
+    end
+
+    it "should report symlink? as false on file, directory and missing files" do
+      [file, dir, missing_file].each do |f|
+      Puppet::FileSystem.symlink?(f).should be_false
+      end
+    end
+
+    it "should return a File::Stat with ftype 'link' when calling lstat on a symlink pointing to existing file" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      stat = Puppet::FileSystem.lstat(symlink)
+      stat.should be_instance_of(File::Stat)
+      stat.ftype.should == 'link'
+    end
+
+    it "should return a File::Stat of ftype 'link' when calling lstat on a symlink pointing to missing file" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(missing_file, symlink)
+
+      stat = Puppet::FileSystem.lstat(symlink)
+      stat.should be_instance_of(File::Stat)
+      stat.ftype.should == 'link'
+    end
+
+    it "should return a File::Stat of ftype 'file' when calling stat on a symlink pointing to existing file" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      stat = Puppet::FileSystem.stat(symlink)
+      stat.should be_instance_of(File::Stat)
+      stat.ftype.should == 'file'
+    end
+
+    it "should return a File::Stat of ftype 'directory' when calling stat on a symlink pointing to existing directory" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(dir, symlink)
+
+      stat = Puppet::FileSystem.stat(symlink)
+      stat.should be_instance_of(File::Stat)
+      stat.ftype.should == 'directory'
+
+      # on Windows, this won't get cleaned up if still linked
+      Puppet::FileSystem.unlink(symlink)
+    end
+
+    it "should return a File::Stat of ftype 'file' when calling stat on a symlink pointing to another symlink" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      Puppet::FileSystem.stat(symlink2).ftype.should == 'file'
+    end
+
+
+    it "should raise Errno::ENOENT when calling stat on a dangling symlink" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(missing_file, symlink)
+
+      expect { Puppet::FileSystem.stat(symlink) }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should be able to readlink to resolve the physical path to a symlink" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      Puppet::FileSystem.exist?(file).should be_true
+      Puppet::FileSystem.readlink(symlink).should == file.to_s
+    end
+
+    it "should not resolve entire symlink chain with readlink on a symlink'd symlink" do
+      # point symlink -> file
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(file, symlink)
+
+      # point symlink2 -> symlink
+      symlink2 = tmpfile("somefile_link2")
+      Puppet::FileSystem.symlink(symlink, symlink2)
+
+      Puppet::FileSystem.exist?(file).should be_true
+      Puppet::FileSystem.readlink(symlink2).should == symlink.to_s
+    end
+
+    it "should be able to readlink to resolve the physical path to a dangling symlink" do
+      symlink = tmpfile("somefile_link")
+      Puppet::FileSystem.symlink(missing_file, symlink)
+
+      Puppet::FileSystem.exist?(missing_file).should be_false
+      Puppet::FileSystem.readlink(symlink).should == missing_file.to_s
+    end
+
+    it "should delete only the symlink and not the target when calling unlink instance method" do
+      [file, dir].each do |target|
+        symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
+        Puppet::FileSystem.symlink(target, symlink)
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.readlink(symlink).should == target.to_s
+
+        Puppet::FileSystem.unlink(symlink).should == 1 # count of files
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.exist?(symlink).should be_false
+      end
+    end
+
+    it "should delete only the symlink and not the target when calling unlink class method" do
+      [file, dir].each do |target|
+        symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
+        Puppet::FileSystem.symlink(target, symlink)
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.readlink(symlink).should == target.to_s
+
+        Puppet::FileSystem.unlink(symlink).should == 1  # count of files
+
+        Puppet::FileSystem.exist?(target).should be_true
+        Puppet::FileSystem.exist?(symlink).should be_false
+      end
+    end
+
+    describe "unlink" do
+      it "should delete files with unlink" do
+        Puppet::FileSystem.exist?(file).should be_true
+
+        Puppet::FileSystem.unlink(file).should == 1  # count of files
+
+        Puppet::FileSystem.exist?(file).should be_false
+      end
+
+      it "should delete files with unlink class method" do
+        Puppet::FileSystem.exist?(file).should be_true
+
+        Puppet::FileSystem.unlink(file).should == 1  # count of files
+
+        Puppet::FileSystem.exist?(file).should be_false
+      end
+
+      it "should delete multiple files with unlink class method" do
+        paths = (1..3).collect do |i|
+          f = tmpfile("somefile_#{i}")
+          FileUtils.touch(f)
+          Puppet::FileSystem.exist?(f).should be_true
+          f.to_s
+        end
+
+        Puppet::FileSystem.unlink(*paths).should == 3  # count of files
+
+        paths.each { |p| Puppet::FileSystem.exist?(p).should be_false  }
+      end
+
+      it "should raise Errno::EPERM or Errno::EISDIR when trying to delete a directory with the unlink class method" do
+        Puppet::FileSystem.exist?(dir).should be_true
+
+        ex = nil
+        begin
+          Puppet::FileSystem.unlink(dir)
+        rescue Exception => e
+          ex = e
+        end
+
+        [
+          Errno::EPERM, # Windows and OSX
+          Errno::EISDIR # Linux
+        ].should include(ex.class)
+
+        Puppet::FileSystem.exist?(dir).should be_true
+      end
+    end
+
+    describe "exclusive_create" do
+      it "should create a file that doesn't exist" do
+        Puppet::FileSystem.exist?(missing_file).should be_false
+
+        Puppet::FileSystem.exclusive_create(missing_file, nil) {}
+
+        Puppet::FileSystem.exist?(missing_file).should be_true
+      end
+
+      it "should raise Errno::EEXIST creating a file that does exist" do
+        Puppet::FileSystem.exist?(file).should be_true
+
+        expect do
+          Puppet::FileSystem.exclusive_create(file, nil) {}
+        end.to raise_error(Errno::EEXIST)
+      end
+    end
+  end
+end