puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/file_serving/metadata_spec.rb

@@ -3,6 +3,21 @@ 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
+
 describe Puppet::FileServing::Metadata do
   let(:foobar) { File.expand_path('/foo/bar') }
 
@@ -84,7 +99,6 @@ describe Puppet::FileServing::Metadata do
     it "should pass the checksum in the hash verbatim as the checksum's value" do
       metadata.to_pson_data_hash['data']['checksum']['value'].should == metadata.checksum
     end
-
   end
 end
 
@@ -139,6 +153,10 @@ describe Puppet::FileServing::Metadata do
             metadata.checksum.should == "{mtime}#{@time}"
           end
         end
+
+        it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
+          validate_json_for_file_metadata(metadata)
+        end
       end
 
       describe "when managing directories" do
@@ -160,25 +178,45 @@ describe Puppet::FileServing::Metadata do
           metadata.collect
           metadata.checksum.should == "{ctime}#{time}"
         end
+
+        it "should validate against the schema", :unless => Puppet.features.microsoft_windows? do
+          metadata.collect
+          validate_json_for_file_metadata(metadata)
+        end
       end
+    end
+  end
 
-      describe "when managing links", :unless => Puppet.features.microsoft_windows? do
+  shared_examples_for "metadata collector symlinks" do
+
+    let(:metadata) do
+      data = described_class.new(path)
+      data.collect
+      data
+    end
+
+    describe "when collecting attributes" do
+      describe "when managing links" do
         # 'path' is a link that points to 'target'
         let(:path) { tmpfile('file_serving_metadata_link') }
         let(:target) { tmpfile('file_serving_metadata_target') }
         let(:checksum) { Digest::MD5.hexdigest("some content\n") }
-        let(:fmode) { File.lstat(path).mode & 0777 }
+        let(:fmode) { Puppet::FileSystem::File.new(path).lstat.mode & 0777 }
 
         before :each do
           File.open(target, "wb") {|f| f.print("some content\n")}
           set_mode(0644, target)
 
-          FileUtils.symlink(target, path)
+          Puppet::FileSystem::File.new(target).symlink(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)
+        end
       end
     end
 
@@ -209,6 +247,10 @@ 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)
+      end
     end
   end
 
@@ -222,6 +264,7 @@ describe Puppet::FileServing::Metadata do
     end
 
     it_should_behave_like "metadata collector"
+    it_should_behave_like "metadata collector symlinks"
 
     def set_mode(mode, path)
       File.chmod(mode, path)
@@ -239,6 +282,7 @@ describe Puppet::FileServing::Metadata do
     end
 
     it_should_behave_like "metadata collector"
+    it_should_behave_like "metadata collector symlinks" if Puppet.features.manages_symlinks?
 
     describe "if ACL metadata cannot be collected" do
       let(:path) { tmpdir('file_serving_metadata_acl') }
@@ -274,16 +318,24 @@ describe Puppet::FileServing::Metadata do
 end
 
 
-describe Puppet::FileServing::Metadata, " when pointing to a link", :unless => Puppet.features.microsoft_windows? do
+describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppet.features.manages_symlinks? do
   describe "when links are managed" do
     before do
-      @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
-      File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-      File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
-
+      path = "/base/path/my/file"
+      @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
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
+
+      if Puppet.features.microsoft_windows?
+        win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
+          :ftype => 'link', :mode => 0755)
+        Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
+      end
     end
+
     it "should store the destination of the link in :destination if links are :manage" do
       @file.collect
       @file.destination.should == "/some/other/path"
@@ -301,9 +353,19 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :unless => P
 
   describe "when links are followed" do
     before do
-      @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
-      File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
-      File.expects(:readlink).with("/base/path/my/file").never
+      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
+
+      if Puppet.features.microsoft_windows?
+        win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
+          :ftype => 'file', :mode => 0755)
+        Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
+      end
+
       @checksum = Digest::MD5.hexdigest("some content\n")
       @file.stubs(:md5_file).returns(@checksum)
     end

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

@@ -85,7 +85,7 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      FileTest.stubs(:exist?).returns(true)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).with("/my/path").returns(true)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(true)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(true)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(true)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.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
-      FileTest.stubs(:exist?).returns(false)
+      Puppet::FileSystem::File.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_serving/mount/pluginfacts_spec.rb

@@ -0,0 +1,73 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/file_serving/mount/pluginfacts'
+
+describe Puppet::FileServing::Mount::PluginFacts do
+  before do
+    @mount = Puppet::FileServing::Mount::PluginFacts.new("pluginfacts")
+
+    @environment = stub 'environment', :module => nil
+    @options = { :recurse => true }
+    @request = stub 'request', :environment => @environment, :options => @options
+  end
+
+  describe  "when finding files" do
+    it "should use the provided environment to find the modules" do
+      @environment.expects(:modules).returns []
+
+      @mount.find("foo", @request)
+    end
+
+    it "should return nil if no module can be found with a matching plugin" do
+      mod = mock 'module'
+      mod.stubs(:pluginfact).with("foo/bar").returns nil
+
+      @environment.stubs(:modules).returns [mod]
+      @mount.find("foo/bar", @request).should be_nil
+    end
+
+    it "should return the file path from the module" do
+      mod = mock 'module'
+      mod.stubs(:pluginfact).with("foo/bar").returns "eh"
+
+      @environment.stubs(:modules).returns [mod]
+      @mount.find("foo/bar", @request).should == "eh"
+    end
+  end
+
+  describe "when searching for files" do
+    it "should use the node's environment to find the modules" do
+      @environment.expects(:modules).at_least_once.returns []
+      @environment.stubs(:modulepath).returns ["/tmp/modules"]
+
+      @mount.search("foo", @request)
+    end
+
+    it "should return modulepath if no modules can be found that have plugins" do
+      mod = mock 'module'
+      mod.stubs(:pluginfacts?).returns false
+
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns ["/"]
+      @options.expects(:[]=).with(:recurse, false)
+      @mount.search("foo/bar", @request).should == ["/"]
+    end
+
+    it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
+      mod = mock 'module'
+      mod.stubs(:pluginfacts?).returns false
+
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns []
+      @mount.search("foo/bar", @request).should be_nil
+    end
+
+    it "should return the plugin paths for each module that has plugins" do
+      one = stub 'module', :pluginfacts? => true, :plugin_fact_directory => "/one"
+      two = stub 'module', :pluginfacts? => true, :plugin_fact_directory => "/two"
+
+      @environment.stubs(:modules).returns [one, two]
+      @mount.search("foo/bar", @request).should == %w{/one /two}
+    end
+  end
+end

data/spec/unit/file_system/file_spec.rb

@@ -0,0 +1,486 @@
+require 'spec_helper'
+require 'puppet/file_system'
+require 'puppet/util/platform'
+
+describe Puppet::FileSystem::File do
+  include PuppetSpec::Files
+
+  context "#exclusive_open" do
+    it "opens ands allows updating of an existing file" do
+      file = Puppet::FileSystem::File.new(file_containing("file_to_update", "the contents"))
+
+      file.exclusive_open(0660, 'r+') do |fh|
+        old = fh.read
+        fh.truncate(0)
+        fh.rewind
+        fh.write("updated #{old}")
+      end
+
+      expect(file.read).to eq("updated the contents")
+    end
+
+    it "opens, creates ands allows updating of a new file" do
+      file = Puppet::FileSystem::File.new(tmpfile("file_to_update"))
+
+      file.exclusive_open(0660, 'w') do |fh|
+        fh.write("updated new file")
+      end
+
+      expect(file.read).to eq("updated new file")
+    end
+
+    it "excludes other processes from updating at the same time", :unless => Puppet::Util::Platform.windows? do
+      file = Puppet::FileSystem::File.new(file_containing("file_to_update", "0"))
+
+      increment_counter_in_multiple_processes(file, 5, 'r+')
+
+      expect(file.read).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 = Puppet::FileSystem::File.new(tmpfile("file_to_update"))
+
+      increment_counter_in_multiple_processes(file, 5, 'a+')
+
+      expect(file.read).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::File.new(file).exclusive_open(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::File.new(file).exclusive_open(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 = []
+      5.times do |number|
+        children << Kernel.fork do
+          file.exclusive_open(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) { Puppet::FileSystem::File.new(tmpfile("somefile")) }
+    let (:missing_file) { Puppet::FileSystem::File.new(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.path)
+    end
+
+    it "should raise an error when trying to create a symlink" do
+      expect { file.symlink('foo') }.to raise_error(Puppet::Util::Windows::Error)
+    end
+
+    it "should return false when trying to check if a path is a symlink" do
+      file.symlink?.should be_false
+    end
+
+    it "should raise an error when trying to read a symlink" do
+      expect { file.readlink }.to raise_error(Puppet::Util::Windows::Error)
+    end
+
+    it "should return a File::Stat instance when calling stat on an existing file" do
+      file.stat.should be_instance_of(File::Stat)
+    end
+
+    it "should raise Errno::ENOENT when calling stat on a missing file" do
+      expect { missing_file.stat }.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(file.path)
+
+      file.lstat
+    end
+  end
+
+  describe "symlink", :if => Puppet.features.manages_symlinks? do
+
+    let (:file) { Puppet::FileSystem::File.new(tmpfile("somefile")) }
+    let (:missing_file) { Puppet::FileSystem::File.new(tmpfile("missingfile")) }
+    let (:dir) { Puppet::FileSystem::File.new(tmpdir("somedir")) }
+
+    before :each do
+      FileUtils.touch(file.path)
+    end
+
+    it "should return true for exist? on a present file" do
+      file.exist?.should be_true
+      Puppet::FileSystem::File.exist?(file.path).should be_true
+    end
+
+    it "should return false for exist? on a non-existant file" do
+      missing_file.exist?.should be_false
+      Puppet::FileSystem::File.exist?(missing_file.path).should be_false
+    end
+
+    it "should return true for exist? on a present directory" do
+      dir.exist?.should be_true
+      Puppet::FileSystem::File.exist?(dir.path).should be_true
+    end
+
+    it "should return false for exist? on a dangling symlink" do
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      missing_file.symlink(symlink.path)
+
+      missing_file.exist?.should be_false
+      symlink.exist?.should be_false
+    end
+
+    it "should return true for exist? on valid symlinks" do
+      [file, dir].each do |target|
+        symlink = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_link"))
+        target.symlink(symlink.path)
+
+        target.exist?.should be_true
+        symlink.exist?.should be_true
+      end
+    end
+
+    it "should not create a symlink when the :noop option is specified" do
+      [file, dir].each do |target|
+        symlink = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_link"))
+        target.symlink(symlink.path, { :noop => true })
+
+        target.exist?.should be_true
+        symlink.exist?.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 = Puppet::FileSystem::File.new(tmpfile("#{file.path.basename.to_s}_link"))
+      FileUtils.touch(existing_file.path)
+
+      [file, dir].each do |target|
+        expect { target.symlink(existing_file.path) }.to raise_error(Errno::EEXIST)
+
+        existing_file.exist?.should be_true
+        existing_file.symlink?.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 = Puppet::FileSystem::File.new(tmpdir("#{file.path.basename.to_s}_dir"))
+
+      [file, dir].each do |target|
+        target.symlink(existing_dir.path).should == 0
+
+        existing_dir.exist?.should be_true
+        File.directory?(existing_dir.path).should be_true
+        existing_dir.symlink?.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 = Puppet::FileSystem::File.new(tmpdir("#{target.path.basename.to_s}_dir"))
+        symlink = Puppet::FileSystem::File.new(tmpfile("#{existing_dir.path.basename.to_s}_link"))
+        existing_dir.symlink(symlink.path)
+
+        symlink.readlink.should == existing_dir.path.to_s
+
+        # now try to point it at the new target, no error raised, but file system unchanged
+        target.symlink(symlink.path).should == 0
+        symlink.readlink.should == existing_dir.path.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 = Puppet::FileSystem::File.new(tmpfile("#{file.path.basename.to_s}_link"))
+      file_2 = Puppet::FileSystem::File.new(tmpfile("#{file.path.basename.to_s}_2"))
+      FileUtils.touch(file_2.path)
+      # symlink -> file_2
+      file_2.symlink(symlink.path)
+
+      [file, dir].each do |target|
+        expect { target.symlink(symlink.path) }.to raise_error(Errno::EEXIST)
+        symlink.readlink.should == file_2.path.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 = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_existing"))
+        FileUtils.touch(existing_file.path)
+        existing_file.symlink?.should be_false
+
+        target.symlink(existing_file.path, { :force => true })
+
+        existing_file.symlink?.should be_true
+        existing_file.readlink.should == target.path.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 = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_existing"))
+        FileUtils.touch(existing_file.path)
+        existing_symlink = Puppet::FileSystem::File.new(tmpfile("#{existing_file.path.basename.to_s}_link"))
+        existing_file.symlink(existing_symlink.path)
+
+        existing_symlink.readlink.should == existing_file.path.to_s
+
+        target.symlink(existing_symlink.path, { :force => true })
+
+        existing_symlink.readlink.should == target.path.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 = Puppet::FileSystem::File.new(tmpdir("#{target.path.basename.to_s}_existing"))
+
+        target.symlink(existing_dir.path, { :force => true }).should == 0
+
+        existing_dir.symlink?.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 = Puppet::FileSystem::File.new(tmpdir("#{target.path.basename.to_s}_existing"))
+        existing_symlink = Puppet::FileSystem::File.new(tmpfile("#{existing_dir.path.basename.to_s}_link"))
+        existing_dir.symlink(existing_symlink.path)
+
+        existing_symlink.readlink.should == existing_dir.path.to_s
+
+        target.symlink(existing_symlink.path, { :force => true }).should == 0
+
+        existing_symlink.readlink.should == existing_dir.path.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::File.exist?(f).should be_false  }
+    end
+
+    it "should return a File::Stat instance when calling stat on an existing file" do
+      file.stat.should be_instance_of(File::Stat)
+    end
+
+    it "should raise Errno::ENOENT when calling stat on a missing file" do
+      expect { missing_file.stat }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should be able to create a symlink, and verify it with symlink?" do
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      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|
+        f.symlink?.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 = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      stat = symlink.lstat
+      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 = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      missing_file.symlink(symlink.path)
+
+      stat = symlink.lstat
+      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 = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      stat = symlink.stat
+      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 = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      dir.symlink(symlink.path)
+
+      stat = symlink.stat
+      stat.should be_instance_of(File::Stat)
+      stat.ftype.should == 'directory'
+    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 = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      # point symlink2 -> symlink
+      symlink2 = Puppet::FileSystem::File.new(tmpfile("somefile_link2"))
+      symlink.symlink(symlink2.path)
+
+      symlink2.stat.ftype.should == 'file'
+    end
+
+
+    it "should raise Errno::ENOENT when calling stat on a dangling symlink" do
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      missing_file.symlink(symlink.path)
+
+      expect { symlink.stat }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should be able to readlink to resolve the physical path to a symlink" do
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      file.exist?.should be_true
+      symlink.readlink.should == file.path.to_s
+    end
+
+    it "should not resolve entire symlink chain with readlink on a symlink'd symlink" do
+      # point symlink -> file
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      file.symlink(symlink.path)
+
+      # point symlink2 -> symlink
+      symlink2 = Puppet::FileSystem::File.new(tmpfile("somefile_link2"))
+      symlink.symlink(symlink2.path)
+
+      file.exist?.should be_true
+      symlink2.readlink.should == symlink.path.to_s
+    end
+
+    it "should be able to readlink to resolve the physical path to a dangling symlink" do
+      symlink = Puppet::FileSystem::File.new(tmpfile("somefile_link"))
+      missing_file.symlink(symlink.path)
+
+      missing_file.exist?.should be_false
+      symlink.readlink.should == missing_file.path.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 = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_link"))
+        target.symlink(symlink.path)
+
+        target.exist?.should be_true
+        symlink.readlink.should == target.path.to_s
+
+        symlink.unlink.should == 1 # count of files
+
+        target.exist?.should be_true
+        symlink.exist?.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 = Puppet::FileSystem::File.new(tmpfile("#{target.path.basename.to_s}_link"))
+        target.symlink(symlink.path)
+
+        target.exist?.should be_true
+        symlink.readlink.should == target.path.to_s
+
+        Puppet::FileSystem::File.unlink(symlink.path).should == 1  # count of files
+
+        target.exist?.should be_true
+        symlink.exist?.should be_false
+      end
+    end
+
+    describe "unlink" do
+      it "should delete files with unlink" do
+        file.exist?.should be_true
+
+        file.unlink.should == 1  # count of files
+
+        file.exist?.should be_false
+      end
+
+      it "should delete files with unlink class method" do
+        file.exist?.should be_true
+
+        Puppet::FileSystem::File.unlink(file.path).should == 1  # count of files
+
+        file.exist?.should be_false
+      end
+
+      it "should delete multiple files with unlink class method" do
+        paths = (1..3).collect do |i|
+          f = Puppet::FileSystem::File.new(tmpfile("somefile_#{i}"))
+          FileUtils.touch(f.path)
+          f.exist?.should be_true
+          f.path.to_s
+        end
+
+        Puppet::FileSystem::File.unlink(*paths).should == 3  # count of files
+
+        paths.each { |p| Puppet::FileSystem::File.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
+        dir.exist?.should be_true
+
+        ex = nil
+        begin
+          Puppet::FileSystem::File.unlink(dir.path)
+        rescue Exception => e
+          ex = e
+        end
+
+        [
+          Errno::EPERM, # Windows and OSX
+          Errno::EISDIR # Linux
+        ].should include ex.class
+
+        dir.exist?.should be_true
+      end
+    end
+  end
+end