diff --git a/spec/integration/type/file_spec.rb b/spec/integration/type/file_spec.rb
index cb04a652b..0c11a779e 100755
--- a/spec/integration/type/file_spec.rb
+++ b/spec/integration/type/file_spec.rb
@@ -1,695 +1,700 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet_spec/files'
 
 if Puppet.features.microsoft_windows?
   require 'puppet/util/windows'
   class WindowsSecurity
     extend Puppet::Util::Windows::Security
   end
 end
 
 describe Puppet::Type.type(:file) do
   include PuppetSpec::Files
 
   let(:catalog) { Puppet::Resource::Catalog.new }
   let(:path) { tmpfile('file_testing') }
 
   if Puppet.features.posix?
     def get_mode(file)
       File.lstat(file).mode
     end
   else
     class SecurityHelper
       extend Puppet::Util::Windows::Security
     end
 
     def get_mode(file)
       SecurityHelper.get_mode(file)
     end
   end
 
   before do
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should not attempt to manage files that do not exist if no means of creating the file is specified" do
     file = described_class.new :path => path, :mode => 0755
     catalog.add_resource file
 
     file.parameter(:mode).expects(:retrieve).never
 
     report = catalog.apply.report
     report.resource_statuses["File[#{path}]"].should_not be_failed
     File.should_not be_exist(path)
   end
 
   describe "when writing files" do
     it "should backup files to a filebucket when one is configured" do
       filebucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = described_class.new :path => path, :backup => "mybucket", :content => "foo"
       catalog.add_resource file
       catalog.add_resource filebucket
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       filebucket.bucket.getfile(md5).should == "bar\n"
     end
 
     it "should backup files in the local directory when a backup string is provided" do
       file = described_class.new :path => path, :backup => ".bak", :content => "foo"
       catalog.add_resource file
 
       File.open(file[:path], "w") { |f| f.puts "bar" }
 
       catalog.apply
 
       backup = file[:path] + ".bak"
       FileTest.should be_exist(backup)
       File.read(backup).should == "bar\n"
     end
 
     it "should fail if no backup can be performed" do
-      file = described_class.new :path => path, :backup => ".bak", :content => "foo"
+      dir = tmpfile("backups")
+      Dir.mkdir(dir)
+
+      file = described_class.new :path => File.join(dir, "testfile"), :backup => ".bak", :content => "foo"
       catalog.add_resource file
 
-      File.open(path, 'w') { |f| f.puts "bar" }
+      File.open(file[:path], 'w') { |f| f.puts "bar" }
 
       # Create a directory where the backup should be so that writing to it fails
-      Dir.mkdir("#{path}.bak")
+      Dir.mkdir(File.join(dir, "testfile.bak"))
+
+      Puppet::Util::Log.stubs(:newmessage)
 
       catalog.apply
 
-      File.read(path).should == "bar\n"
+      File.read(file[:path]).should == "bar\n"
     end
 
     it "should not backup symlinks", :unless => Puppet.features.microsoft_windows? do
       link = tmpfile("link")
       dest1 = tmpfile("dest1")
       dest2 = tmpfile("dest2")
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = described_class.new :path => link, :target => dest2, :ensure => :link, :backup => "mybucket"
       catalog.add_resource file
       catalog.add_resource bucket
 
       File.open(dest1, "w") { |f| f.puts "whatever" }
       File.symlink(dest1, link)
 
       md5 = Digest::MD5.hexdigest(File.read(file[:path]))
 
       catalog.apply
 
       File.readlink(link).should == dest2
       Find.find(bucket[:path]) { |f| File.file?(f) }.should be_nil
     end
 
     it "should backup directories to the local filesystem by copying the whole directory" do
       file = described_class.new :path => path, :backup => ".bak", :content => "foo", :force => true
       catalog.add_resource file
 
       Dir.mkdir(path)
 
       otherfile = File.join(path, "foo")
       File.open(otherfile, "w") { |f| f.print "yay" }
 
       catalog.apply
 
       backup = "#{path}.bak"
       FileTest.should be_directory(backup)
 
       File.read(File.join(backup, "foo")).should == "yay"
     end
 
     it "should backup directories to filebuckets by backing up each file separately" do
       bucket = Puppet::Type.type(:filebucket).new :path => tmpfile("filebucket"), :name => "mybucket"
       file = described_class.new :path => tmpfile("bucket_backs"), :backup => "mybucket", :content => "foo", :force => true
       catalog.add_resource file
       catalog.add_resource bucket
 
       Dir.mkdir(file[:path])
       foofile = File.join(file[:path], "foo")
       barfile = File.join(file[:path], "bar")
       File.open(foofile, "w") { |f| f.print "fooyay" }
       File.open(barfile, "w") { |f| f.print "baryay" }
 
 
       foomd5 = Digest::MD5.hexdigest(File.read(foofile))
       barmd5 = Digest::MD5.hexdigest(File.read(barfile))
 
       catalog.apply
 
       bucket.bucket.getfile(foomd5).should == "fooyay"
       bucket.bucket.getfile(barmd5).should == "baryay"
     end
 
     it "should propagate failures encountered when renaming the temporary file" do
       file = described_class.new :path => path, :content => "foo"
       file.stubs(:perform_backup).returns(true)
 
       catalog.add_resource file
 
       File.open(path, "w") { |f| f.print "bar" }
 
       File.expects(:rename).raises ArgumentError
 
       expect { file.write(:content) }.to raise_error(Puppet::Error, /Could not rename temporary file/)
       File.read(path).should == "bar"
     end
   end
 
   describe "when recursing" do
     def build_path(dir)
       Dir.mkdir(dir)
       File.chmod(0750, dir)
 
       @dirs = [dir]
       @files = []
 
       %w{one two}.each do |subdir|
         fdir = File.join(dir, subdir)
         Dir.mkdir(fdir)
         File.chmod(0750, fdir)
         @dirs << fdir
 
         %w{three}.each do |file|
           ffile = File.join(fdir, file)
           @files << ffile
           File.open(ffile, "w") { |f| f.puts "test #{file}" }
           File.chmod(0640, ffile)
         end
       end
     end
 
     it "should be able to recurse over a nonexistent file" do
       @file = described_class.new(
         :name    => path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       catalog.add_resource @file
 
       lambda { @file.eval_generate }.should_not raise_error
     end
 
     it "should be able to recursively set properties on existing files" do
       path = tmpfile("file_integration_tests")
 
       build_path(path)
 
       file = described_class.new(
         :name    => path,
         :mode    => 0644,
         :recurse => true,
         :backup  => false
       )
 
       catalog.add_resource file
 
       catalog.apply
 
       @dirs.should_not be_empty
       @dirs.each do |path|
         (get_mode(path) & 007777).should == 0755
       end
 
       @files.should_not be_empty
       @files.each do |path|
         (get_mode(path) & 007777).should == 0644
       end
     end
 
     it "should be able to recursively make links to other files", :unless => Puppet.features.microsoft_windows? do
       source = tmpfile("file_link_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_link_integration_dest")
 
       @file = described_class.new(:name => dest, :target => source, :recurse => true, :ensure => :link, :backup => false)
 
       catalog.add_resource @file
 
       catalog.apply
 
       @dirs.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).should be_directory
       end
 
       @files.each do |path|
         link_path = path.sub(source, dest)
 
         File.lstat(link_path).ftype.should == "link"
       end
     end
 
     it "should be able to recursively copy files" do
       source = tmpfile("file_source_integration_source")
 
       build_path(source)
 
       dest = tmpfile("file_source_integration_dest")
 
       @file = described_class.new(:name => dest, :source => source, :recurse => true, :backup => false)
 
       catalog.add_resource @file
 
       catalog.apply
 
       @dirs.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).should be_directory
       end
 
       @files.each do |path|
         newpath = path.sub(source, dest)
 
         File.lstat(newpath).ftype.should == "file"
       end
     end
 
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 
       subdir = File.join(dir, "subdir")
       file = File.join(subdir, "file")
 
       FileUtils.mkdir_p(subdir)
       File.open(file, "w") { |f| f.puts "" }
 
       base = described_class.new(:name => dir, :recurse => true, :backup => false, :mode => "755")
       sub = described_class.new(:name => subdir, :recurse => true, :backup => false, :mode => "644")
 
       catalog.add_resource base
       catalog.add_resource sub
 
       catalog.apply
 
       (get_mode(file) & 007777).should == 0644
     end
 
     it "should recursively manage files even if there is an explicit file whose name is a prefix of the managed file" do
       managed      = File.join(path, "file")
       generated    = File.join(path, "file_with_a_name_starting_with_the_word_file")
       managed_mode = 0700
 
       FileUtils.mkdir_p(path)
       FileUtils.touch(managed)
       FileUtils.touch(generated)
 
       catalog.add_resource described_class.new(:name => path,    :recurse => true, :backup => false, :mode => managed_mode)
       catalog.add_resource described_class.new(:name => managed, :recurse => true, :backup => false, :mode => "644")
 
       catalog.apply
 
       (get_mode(generated) & 007777).should == managed_mode
     end
 
     describe "when recursing remote directories" do
       describe "when sourceselect first" do
         describe "for a directory" do
           it "should recursively copy the first directory that exists" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpdir('two')
 
             FileUtils.mkdir_p(File.join(two, 'three'))
             FileUtils.touch(File.join(two, 'three', 'four'))
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :first,
                                :source => [one, two]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.should be_directory(path)
             File.should_not be_exist(File.join(path, 'one'))
             File.should be_exist(File.join(path, 'three', 'four'))
           end
 
           it "should recursively copy an empty directory" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpdir('two')
             three = tmpdir('three')
 
             FileUtils.mkdir_p(two)
             FileUtils.mkdir_p(three)
             FileUtils.touch(File.join(three, 'a'))
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.should be_directory(path)
             File.should_not be_exist(File.join(path, 'a'))
           end
 
           it "should only recurse one level" do
             one = tmpdir('one')
             FileUtils.mkdir_p(File.join(one, 'a', 'b'))
             FileUtils.touch(File.join(one, 'a', 'b', 'c'))
 
             two = tmpdir('two')
             FileUtils.mkdir_p(File.join(two, 'z'))
             FileUtils.touch(File.join(two, 'z', 'y'))
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :recurselimit => 1,
                                :sourceselect => :first,
                                :source => [one, two]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.should be_exist(File.join(path, 'a'))
             File.should_not be_exist(File.join(path, 'a', 'b'))
             File.should_not be_exist(File.join(path, 'z'))
           end
         end
 
         describe "for a file" do
           it "should copy the first file that exists" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpfile('two')
             File.open(two, "w") { |f| f.print 'yay' }
             three = tmpfile('three')
             File.open(three, "w") { |f| f.print 'no' }
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :file,
                                :backup  => false,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.read(path).should == 'yay'
           end
 
           it "should copy an empty file" do
             one = File.expand_path('thisdoesnotexist')
             two = tmpfile('two')
             FileUtils.touch(two)
             three = tmpfile('three')
             File.open(three, "w") { |f| f.print 'no' }
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :file,
                                :backup  => false,
                                :sourceselect => :first,
                                :source => [one, two, three]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.read(path).should == ''
           end
         end
       end
 
       describe "when sourceselect all" do
         describe "for a directory" do
           it "should recursively copy all sources from the first valid source" do
             one = tmpdir('one')
             two = tmpdir('two')
             three = tmpdir('three')
             four = tmpdir('four')
 
             [one, two, three, four].each {|dir| FileUtils.mkdir_p(dir)}
 
             File.open(File.join(one, 'a'), "w") { |f| f.print one }
             File.open(File.join(two, 'a'), "w") { |f| f.print two }
             File.open(File.join(two, 'b'), "w") { |f| f.print two }
             File.open(File.join(three, 'a'), "w") { |f| f.print three }
             File.open(File.join(three, 'c'), "w") { |f| f.print three }
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :sourceselect => :all,
                                :source => [one, two, three, four]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.read(File.join(path, 'a')).should == one
             File.read(File.join(path, 'b')).should == two
             File.read(File.join(path, 'c')).should == three
           end
 
           it "should only recurse one level from each valid source" do
             one = tmpdir('one')
             FileUtils.mkdir_p(File.join(one, 'a', 'b'))
             FileUtils.touch(File.join(one, 'a', 'b', 'c'))
 
             two = tmpdir('two')
             FileUtils.mkdir_p(File.join(two, 'z'))
             FileUtils.touch(File.join(two, 'z', 'y'))
 
             obj = Puppet::Type.newfile(
                                :path    => path,
                                :ensure  => :directory,
                                :backup  => false,
                                :recurse => true,
                                :recurselimit => 1,
                                :sourceselect => :all,
                                :source => [one, two]
                                )
 
             catalog.add_resource obj
             catalog.apply
 
             File.should be_exist(File.join(path, 'a'))
             File.should_not be_exist(File.join(path, 'a', 'b'))
             File.should be_exist(File.join(path, 'z'))
             File.should_not be_exist(File.join(path, 'z', 'y'))
           end
         end
       end
     end
   end
 
   describe "when generating resources" do
     before do
       source = tmpfile("generating_in_catalog_source")
 
       Dir.mkdir(source)
 
       s1 = File.join(source, "one")
       s2 = File.join(source, "two")
 
       File.open(s1, "w") { |f| f.puts "uno" }
       File.open(s2, "w") { |f| f.puts "dos" }
 
       @file = described_class.new(
         :name => path,
         :source => source,
         :recurse => true,
         :backup => false
       )
 
       catalog.add_resource @file
     end
 
     it "should add each generated resource to the catalog" do
       catalog.apply do |trans|
         catalog.resource(:file, File.join(path, "one")).should be_a(described_class)
         catalog.resource(:file, File.join(path, "two")).should be_a(described_class)
       end
     end
 
     it "should have an edge to each resource in the relationship graph" do
       catalog.apply do |trans|
         one = catalog.resource(:file, File.join(path, "one"))
         catalog.relationship_graph.should be_edge(@file, one)
 
         two = catalog.resource(:file, File.join(path, "two"))
         catalog.relationship_graph.should be_edge(@file, two)
       end
     end
   end
 
   describe "when copying files" do
     # Ticket #285.
     it "should be able to copy files with pound signs in their names" do
       source = tmpfile("filewith#signs")
 
       dest = tmpfile("destwith#signs")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = described_class.new(:name => dest, :source => source)
 
       catalog.add_resource file
 
       catalog.apply
 
       File.read(dest).should == "foo"
     end
 
     it "should be able to copy files with spaces in their names" do
       source = tmpfile("filewith spaces")
 
       dest = tmpfile("destwith spaces")
 
       File.open(source, "w") { |f| f.print "foo" }
       File.chmod(0755, source)
 
       file = described_class.new(:path => dest, :source => source)
 
       catalog.add_resource file
 
       catalog.apply
 
       expected_mode = Puppet.features.microsoft_windows? ? 0644 : 0755
       File.read(dest).should == "foo"
       (File.stat(dest).mode & 007777).should == expected_mode
     end
 
     it "should be able to copy individual files even if recurse has been specified" do
       source = tmpfile("source")
       dest = tmpfile("dest")
 
       File.open(source, "w") { |f| f.print "foo" }
 
       file = described_class.new(:name => dest, :source => source, :recurse => true)
 
       catalog.add_resource file
       catalog.apply
 
       File.read(dest).should == "foo"
     end
   end
 
   it "should create a file with content if ensure is omitted" do
     file = described_class.new(
       :path => path,
       :content => "this is some content, yo"
     )
 
     catalog.add_resource file
     catalog.apply
 
     File.read(path).should == "this is some content, yo"
   end
 
   it "should create files with content if both content and ensure are set" do
     file = described_class.new(
       :path    => path,
       :ensure  => "file",
       :content => "this is some content, yo"
     )
 
     catalog.add_resource file
     catalog.apply
 
     File.read(path).should == "this is some content, yo"
   end
 
   it "should delete files with sources but that are set for deletion" do
     source = tmpfile("source_source_with_ensure")
 
     File.open(source, "w") { |f| f.puts "yay" }
     File.open(path, "w") { |f| f.puts "boo" }
 
 
     file = described_class.new(
       :path   => path,
       :ensure => :absent,
       :source => source,
       :backup => false
     )
 
     catalog.add_resource file
     catalog.apply
 
     File.should_not be_exist(path)
   end
 
   describe "when purging files" do
     before do
       sourcedir = tmpfile("purge_source")
       destdir = tmpfile("purge_dest")
       Dir.mkdir(sourcedir)
       Dir.mkdir(destdir)
       sourcefile = File.join(sourcedir, "sourcefile")
 
       @copiedfile = File.join(destdir, "sourcefile")
       @localfile  = File.join(destdir, "localfile")
       @purgee     = File.join(destdir, "to_be_purged")
 
       File.open(@localfile, "w") { |f| f.print "oldtest" }
       File.open(sourcefile, "w") { |f| f.print "funtest" }
       # this file should get removed
       File.open(@purgee, "w") { |f| f.print "footest" }
 
       lfobj = Puppet::Type.newfile(
         :title   => "localfile",
         :path    => @localfile,
         :content => "rahtest",
         :ensure  => :file,
         :backup  => false
       )
 
       destobj = Puppet::Type.newfile(
         :title   => "destdir",
         :path    => destdir,
         :source  => sourcedir,
         :backup  => false,
         :purge   => true,
         :recurse => true
       )
 
       catalog.add_resource lfobj, destobj
       catalog.apply
     end
 
     it "should still copy remote files" do
       File.read(@copiedfile).should == 'funtest'
     end
 
     it "should not purge managed, local files" do
       File.read(@localfile).should == 'rahtest'
     end
 
     it "should purge files that are neither remote nor otherwise managed" do
       FileTest.should_not be_exist(@purgee)
     end
   end
 end
diff --git a/spec/unit/file_serving/metadata_spec.rb b/spec/unit/file_serving/metadata_spec.rb
index 7462fed5d..077c34251 100755
--- a/spec/unit/file_serving/metadata_spec.rb
+++ b/spec/unit/file_serving/metadata_spec.rb
@@ -1,329 +1,329 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/file_serving/metadata'
 
 describe Puppet::FileServing::Metadata do
   it "should should be a subclass of Base" do
     Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_metadata" do
     Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
   end
 
   it "should should include the IndirectionHooks module in its indirection" do
     Puppet::FileServing::Metadata.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
   end
 
   it "should have a method that triggers attribute collection" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
   end
 
   it "should support pson serialization" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson)
   end
 
   it "should support to_pson_data_hash" do
     Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash)
   end
 
   it "should support pson deserialization" do
     Puppet::FileServing::Metadata.should respond_to(:from_pson)
   end
 
   describe "when serializing" do
     before do
       @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
     end
     it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
       pdh = mock "data hash"
       pdh_as_pson = mock "data as pson"
       @metadata.expects(:to_pson_data_hash).returns pdh
       pdh.expects(:to_pson).returns pdh_as_pson
       @metadata.to_pson.should == pdh_as_pson
     end
 
     it "should serialize as FileMetadata" do
       @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
     end
 
     it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
       @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
     end
 
     it "should pass the path in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['path'] == @metadata.path
     end
 
     it "should pass the relative_path in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
     end
 
     it "should pass the links in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['links'] == @metadata.links
     end
 
     it "should pass the path owner in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
     end
 
     it "should pass the group in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['group'] == @metadata.group
     end
 
     it "should pass the mode in the hash verbatum" do
       @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
     end
 
     it "should pass the ftype in the hash verbatum as the 'type'" do
       @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
     end
 
     it "should pass the destination verbatum" do
       @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
     end
 
     it "should pass the checksum in the hash as a nested hash" do
       @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
     end
 
     it "should pass the checksum_type in the hash verbatum as the checksum's type" do
       @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
     end
 
     it "should pass the checksum in the hash verbatum as the checksum's value" do
       @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
     end
 
   end
 end
 
 describe Puppet::FileServing::Metadata do
   include PuppetSpec::Files
 
   shared_examples_for "metadata collector" do
     let(:metadata) do
       data = described_class.new(path)
       data.collect
       data
     end
 
     describe "when collecting attributes" do
       describe "when managing files" do
         let(:path) { tmpfile('file_serving_metadata') }
 
         before :each do
           FileUtils.touch(path)
         end
 
         it "should be able to produce xmlrpc-style attribute information" do
           metadata.should respond_to(:attributes_with_tabs)
         end
 
         it "should set the owner to the file's current owner" do
           metadata.owner.should == owner
         end
 
         it "should set the group to the file's current group" do
           metadata.group.should == group
         end
 
         it "should set the mode to the file's masked mode" do
           set_mode(33261, path)
 
           metadata.mode.should == 0755
         end
 
         describe "#checksum" do
           let(:checksum) { Digest::MD5.hexdigest("some content\n") }
 
           before :each do
             File.open(path, "w") {|f| f.print("some content\n")}
           end
 
           it "should default to a checksum of type MD5 with the file's current checksum" do
             metadata.checksum.should == "{md5}#{checksum}"
           end
 
           it "should give a mtime checksum when checksum_type is set" do
             time = Time.now
             metadata.checksum_type = "mtime"
             metadata.expects(:mtime_file).returns(@time)
             metadata.collect
             metadata.checksum.should == "{mtime}#{@time}"
           end
 
           it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
             set_mode(0755, path)
 
             metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t#{owner}\t#{group}\t{md5}#{checksum}"
           end
         end
       end
 
       describe "when managing directories" do
         let(:path) { tmpdir('file_serving_metadata_dir') }
         let(:time) { Time.now }
 
         before :each do
           metadata.expects(:ctime_file).returns(time)
         end
 
         it "should only use checksums of type 'ctime' for directories" do
           metadata.collect
           metadata.checksum.should == "{ctime}#{time}"
         end
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
           metadata.checksum_type = "mtime"
           metadata.expects(:mtime_file).never
           metadata.collect
           metadata.checksum.should == "{ctime}#{time}"
         end
 
         it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
           set_mode(0755, path)
           metadata.collect
 
           metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t#{owner}\t#{group}\t{ctime}#{time.to_s}"
         end
       end
 
       describe "when managing links", :unless => Puppet.features.microsoft_windows? 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 }
 
         before :each do
           File.open(target, "w") {|f| f.print("some content\n")}
           set_mode(0644, target)
 
           FileUtils.symlink(target, path)
-          set_mode(0755, path)
         end
 
         it "should read links instead of returning their checksums" do
           metadata.destination.should == target
         end
 
         pending "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
           # "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
           metadata.attributes_with_tabs.should == "#{0755}\tlink\t#{owner}\t#{group}\t#{target}"
         end
 
         it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
-          metadata.attributes_with_tabs.should == "#{0755}\tlink\t#{owner}\t#{group}\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t#{target}"
+          metadata.attributes_with_tabs.should == "#{fmode}\tlink\t#{owner}\t#{group}\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t#{target}"
         end
       end
     end
 
     describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
       let(:path) { tmpfile('file_serving_metadata_find_file') }
 
       before :each do
         File.open(path, "w") {|f| f.print("some content\n")}
         set_mode(0755, path)
       end
 
       it "should accept a base path to which the file should be relative" do
         dir = tmpdir('metadata_dir')
         metadata = described_class.new(dir)
         metadata.relative_path = 'relative_path'
 
         FileUtils.touch(metadata.full_path)
 
         metadata.collect
       end
 
       it "should use the set base path if one is not provided" do
         metadata.collect
       end
 
       it "should raise an exception if the file does not exist" do
         File.delete(path)
 
         proc { metadata.collect}.should raise_error(Errno::ENOENT)
       end
     end
   end
 
   describe "on POSIX systems", :if => Puppet.features.posix? do
     let(:owner) {10}
     let(:group) {20}
 
     before :each do
       File::Stat.any_instance.stubs(:uid).returns owner
       File::Stat.any_instance.stubs(:gid).returns group
     end
 
     it_should_behave_like "metadata collector"
 
     def set_mode(mode, path)
       File.chmod(mode, path)
     end
   end
 
   describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
     let(:owner) {'S-1-1-50'}
     let(:group) {'S-1-1-51'}
 
     before :each do
       require 'puppet/util/windows/security'
       Puppet::Util::Windows::Security.stubs(:get_owner).returns owner
       Puppet::Util::Windows::Security.stubs(:get_group).returns group
     end
 
     it_should_behave_like "metadata collector"
 
     def set_mode(mode, path)
       Puppet::Util::Windows::Security.set_mode(mode, path)
     end
   end
 end
 
 
 describe Puppet::FileServing::Metadata, " when pointing to a link", :unless => Puppet.features.microsoft_windows? 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"
 
       @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
       @file.stubs(:md5_file).returns(@checksum)           #
     end
     it "should store the destination of the link in :destination if links are :manage" do
       @file.collect
       @file.destination.should == "/some/other/path"
     end
     pending "should not collect the checksum if links are :manage" do
       # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
       @file.collect
       @file.checksum.should be_nil
     end
     it "should collect the checksum if links are :manage" do # see pending note above
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 
   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
       @checksum = Digest::MD5.hexdigest("some content\n")
       @file.stubs(:md5_file).returns(@checksum)
     end
     it "should not store the destination of the link in :destination if links are :follow" do
       @file.collect
       @file.destination.should be_nil
     end
     it "should collect the checksum if links are :follow" do
       @file.collect
       @file.checksum.should == "{md5}#{@checksum}"
     end
   end
 end