puppet 0.25.5 → 2.6.0

data/spec/unit/file_serving/fileset.rb

@@ -1,347 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/file_serving/fileset'
-
-describe Puppet::FileServing::Fileset, " when initializing" do
-    it "should require a path" do
-        proc { Puppet::FileServing::Fileset.new }.should raise_error(ArgumentError)
-    end
-
-    it "should fail if its path is not fully qualified" do
-        proc { Puppet::FileServing::Fileset.new("some/file") }.should raise_error(ArgumentError)
-    end
-
-    it "should fail if its path does not exist" do
-        File.expects(:lstat).with("/some/file").returns nil
-        proc { Puppet::FileServing::Fileset.new("/some/file") }.should raise_error(ArgumentError)
-    end
-
-    it "should accept a 'recurse' option" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        set = Puppet::FileServing::Fileset.new("/some/file", :recurse => true)
-        set.recurse.should be_true
-    end
-
-    it "should accept a 'recurselimit' option" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        set = Puppet::FileServing::Fileset.new("/some/file", :recurselimit => 3)
-        set.recurselimit.should == 3
-    end
-
-    it "should accept an 'ignore' option" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        set = Puppet::FileServing::Fileset.new("/some/file", :ignore => ".svn")
-        set.ignore.should == [".svn"]
-    end
-
-    it "should accept a 'links' option" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        set = Puppet::FileServing::Fileset.new("/some/file", :links => :manage)
-        set.links.should == :manage
-    end
-
-    it "should accept a 'checksum_type' option" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        set = Puppet::FileServing::Fileset.new("/some/file", :checksum_type => :test)
-        set.checksum_type.should == :test
-    end
-
-    it "should fail if 'links' is set to anything other than :manage or :follow" do
-        proc { Puppet::FileServing::Fileset.new("/some/file", :links => :whatever) }.should raise_error(ArgumentError)
-    end
-
-    it "should default to 'false' for recurse" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        Puppet::FileServing::Fileset.new("/some/file").recurse.should == false
-    end
-
-    it "should default to :infinite for recurselimit" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        Puppet::FileServing::Fileset.new("/some/file").recurselimit.should == :infinite
-    end
-
-    it "should default to an empty ignore list" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        Puppet::FileServing::Fileset.new("/some/file").ignore.should == []
-    end
-
-    it "should default to :manage for links" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        Puppet::FileServing::Fileset.new("/some/file").links.should == :manage
-    end
-
-    it "should support using an Indirector Request for its options" do
-        File.expects(:lstat).with("/some/file").returns stub("stat")
-        request = Puppet::Indirector::Request.new(:file_serving, :find, "foo")
-        lambda { Puppet::FileServing::Fileset.new("/some/file", request) }.should_not raise_error
-    end
-
-    describe "using an indirector request" do
-        before do
-            File.stubs(:lstat).returns stub("stat")
-            @values = {:links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234}
-            @request = Puppet::Indirector::Request.new(:file_serving, :find, "foo")
-        end
-
-        [:recurse, :recurselimit, :ignore, :links].each do |option|
-            it "should pass :recurse, :recurselimit, :ignore, and :links settings on to the fileset if present" do
-                @request.stubs(:options).returns(option => @values[option])
-                Puppet::FileServing::Fileset.new("/my/file", @request).send(option).should == @values[option]
-            end
-
-            it "should pass :recurse, :recurselimit, :ignore, and :links settings on to the fileset if present with the keys stored as strings" do
-                @request.stubs(:options).returns(option.to_s => @values[option])
-                Puppet::FileServing::Fileset.new("/my/file", @request).send(option).should == @values[option]
-            end
-        end
-
-        it "should convert the integer as a string to their integer counterpart when setting options" do
-            @request.stubs(:options).returns(:recurselimit => "1234")
-            Puppet::FileServing::Fileset.new("/my/file", @request).recurselimit.should == 1234
-        end
-
-        it "should convert the string 'true' to the boolean true when setting options" do
-            @request.stubs(:options).returns(:recurse => "true")
-            Puppet::FileServing::Fileset.new("/my/file", @request).recurse.should == true
-        end
-
-        it "should convert the string 'false' to the boolean false when setting options" do
-            @request.stubs(:options).returns(:recurse => "false")
-            Puppet::FileServing::Fileset.new("/my/file", @request).recurse.should == false
-        end
-    end
-end
-
-describe Puppet::FileServing::Fileset, " when determining whether to recurse" do
-    before do
-        @path = "/my/path"
-        File.expects(:lstat).with(@path).returns stub("stat")
-        @fileset = Puppet::FileServing::Fileset.new(@path)
-    end
-
-    it "should always recurse if :recurse is set to 'true' and with infinite recursion" do
-        @fileset.recurse = true
-        @fileset.recurselimit = :infinite
-        @fileset.recurse?(0).should be_true
-    end
-
-    it "should never recurse if :recurse is set to 'false'" do
-        @fileset.recurse = false
-        @fileset.recurse?(-1).should be_false
-    end
-
-    it "should recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is less than that integer" do
-        @fileset.recurse = true
-        @fileset.recurselimit = 1
-        @fileset.recurse?(0).should be_true
-    end
-
-    it "should recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is equal to that integer" do
-        @fileset.recurse = true
-        @fileset.recurselimit = 1
-        @fileset.recurse?(1).should be_true
-    end
-
-    it "should not recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is greater than that integer" do
-        @fileset.recurse = true
-        @fileset.recurselimit = 1
-        @fileset.recurse?(2).should be_false
-    end
-end
-
-describe Puppet::FileServing::Fileset, " when recursing" do
-    before do
-        @path = "/my/path"
-        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
-        @fileset = Puppet::FileServing::Fileset.new(@path)
-
-        @dirstat = stub 'dirstat', :directory? => true
-        @filestat = stub 'filestat', :directory? => false
-    end
-
-    def mock_dir_structure(path, stat_method = :lstat)
-        File.stubs(stat_method).with(path).returns(@dirstat)
-        Dir.stubs(:entries).with(path).returns(%w{one two .svn CVS})
-
-        # Keep track of the files we're stubbing.
-        @files = %w{.}
-
-        %w{one two .svn CVS}.each do |subdir|
-            @files << subdir # relative path
-            subpath = File.join(path, subdir)
-            File.stubs(stat_method).with(subpath).returns(@dirstat)
-            Dir.stubs(:entries).with(subpath).returns(%w{.svn CVS file1 file2})
-            %w{file1 file2 .svn CVS}.each do |file|
-                @files << File.join(subdir, file) # relative path
-                File.stubs(stat_method).with(File.join(subpath, file)).returns(@filestat)
-            end
-        end
-    end
-
-    it "should recurse through the whole file tree if :recurse is set to 'true'" do
-        mock_dir_structure(@path)
-        @fileset.stubs(:recurse?).returns(true)
-        @fileset.files.sort.should == @files.sort
-    end
-
-    it "should not recurse if :recurse is set to 'false'" do
-        mock_dir_structure(@path)
-        @fileset.stubs(:recurse?).returns(false)
-        @fileset.files.should == %w{.}
-    end
-
-    # It seems like I should stub :recurse? here, or that I shouldn't stub the
-    # examples above, but...
-    it "should recurse to the level set if :recurselimit is set to an integer" do
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.recurselimit = 1
-        @fileset.files.should == %w{. one two .svn CVS}
-    end
-
-    it "should ignore the '.' and '..' directories in subdirectories" do
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.files.sort.should == @files.sort
-    end
-
-    it "should function if the :ignore value provided is nil" do
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.ignore = nil
-        lambda { @fileset.files }.should_not raise_error
-    end
-
-    it "should ignore files that match a single pattern in the ignore list" do
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.ignore = ".svn"
-        @fileset.files.find { |file| file.include?(".svn") }.should be_nil
-    end
-
-    it "should ignore files that match any of multiple patterns in the ignore list" do
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.ignore = %w{.svn CVS}
-        @fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }.should be_nil
-    end
-
-    it "should use File.stat if :links is set to :follow" do
-        mock_dir_structure(@path, :stat)
-        @fileset.recurse = true
-        @fileset.links = :follow
-        @fileset.files.sort.should == @files.sort
-    end
-
-    it "should use File.lstat if :links is set to :manage" do
-        mock_dir_structure(@path, :lstat)
-        @fileset.recurse = true
-        @fileset.links = :manage
-        @fileset.files.sort.should == @files.sort
-    end
-
-    it "should succeed when paths have regexp significant characters" do
-        @path = "/my/path/rV1x2DafFr0R6tGG+1bbk++++TM"
-        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
-        @fileset = Puppet::FileServing::Fileset.new(@path)
-        mock_dir_structure(@path)
-        @fileset.recurse = true
-        @fileset.files.sort.should == @files.sort
-    end
-end
-
-describe Puppet::FileServing::Fileset, " when following links that point to missing files" do
-    before do
-        @path = "/my/path"
-        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
-        @fileset = Puppet::FileServing::Fileset.new(@path)
-        @fileset.links = :follow
-        @fileset.recurse = true
-
-        @stat = stub 'stat', :directory? => true
-
-        File.expects(:stat).with(@path).returns(@stat)
-        File.expects(:stat).with(File.join(@path, "mylink")).raises(Errno::ENOENT)
-        Dir.stubs(:entries).with(@path).returns(["mylink"])
-    end
-
-    it "should not fail" do
-        proc { @fileset.files }.should_not raise_error
-    end
-
-    it "should still manage the link" do
-        @fileset.files.sort.should == %w{. mylink}.sort
-    end
-end
-
-describe Puppet::FileServing::Fileset, " when ignoring" do
-    before do
-        @path = "/my/path"
-        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
-        @fileset = Puppet::FileServing::Fileset.new(@path)
-    end
-
-    it "should use ruby's globbing to determine what files should be ignored" do
-        @fileset.ignore = ".svn"
-        File.expects(:fnmatch?).with(".svn", "my_file")
-        @fileset.ignore?("my_file")
-    end
-
-    it "should ignore files whose paths match a single provided ignore value" do
-        @fileset.ignore = ".svn"
-        File.stubs(:fnmatch?).with(".svn", "my_file").returns true
-        @fileset.ignore?("my_file").should be_true
-    end
-
-    it "should ignore files whose paths match any of multiple provided ignore values" do
-        @fileset.ignore = [".svn", "CVS"]
-        File.stubs(:fnmatch?).with(".svn", "my_file").returns false
-        File.stubs(:fnmatch?).with("CVS", "my_file").returns true
-        @fileset.ignore?("my_file").should be_true
-    end
-end
-
-describe Puppet::FileServing::Fileset, "when merging other filesets" do
-    before do
-        @paths = %w{/first/path /second/path /third/path}
-
-        @filesets = @paths.collect do |path|
-            File.stubs(:lstat).with(path).returns stub("stat", :directory? => true)
-            Puppet::FileServing::Fileset.new(path, :recurse => true)
-        end
-
-        Dir.stubs(:entries).returns []
-    end
-
-    it "should return a hash of all files in each fileset with the value being the base path" do
-        Dir.expects(:entries).with("/first/path").returns(%w{one uno})
-        Dir.expects(:entries).with("/second/path").returns(%w{two dos})
-        Dir.expects(:entries).with("/third/path").returns(%w{three tres})
-
-        Puppet::FileServing::Fileset.merge(*@filesets).should == {
-            "." => "/first/path",
-            "one" => "/first/path",
-            "uno" => "/first/path",
-            "two" => "/second/path",
-            "dos" => "/second/path",
-            "three" => "/third/path",
-            "tres" => "/third/path",
-        }
-    end
-
-    it "should include the base directory from the first fileset" do
-        Dir.expects(:entries).with("/first/path").returns(%w{one})
-        Dir.expects(:entries).with("/second/path").returns(%w{two})
-
-        Puppet::FileServing::Fileset.merge(*@filesets)["."].should == "/first/path"
-    end
-
-    it "should use the base path of the first found file when relative file paths conflict" do
-        Dir.expects(:entries).with("/first/path").returns(%w{one})
-        Dir.expects(:entries).with("/second/path").returns(%w{one})
-
-        Puppet::FileServing::Fileset.merge(*@filesets)["one"].should == "/first/path"
-    end
-end

data/spec/unit/file_serving/indirection_hooks.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-10-18.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/file_serving/indirection_hooks'
-
-describe Puppet::FileServing::IndirectionHooks do
-    before do
-        @object = Object.new
-        @object.extend(Puppet::FileServing::IndirectionHooks)
-
-        @request = stub 'request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil
-    end
-
-    describe "when being used to select termini" do
-        it "should return :file if the request key is fully qualified" do
-            @request.expects(:key).returns "#{File::SEPARATOR}foo"
-            @object.select_terminus(@request).should == :file
-        end
-
-        it "should return :file if the URI protocol is set to 'file'" do
-            @request.expects(:protocol).returns "file"
-            @object.select_terminus(@request).should == :file
-        end
-
-        it "should fail when a protocol other than :puppet or :file is used" do
-            @request.stubs(:protocol).returns "http"
-            proc { @object.select_terminus(@request) }.should raise_error(ArgumentError)
-        end
-
-        describe "and the protocol is 'puppet'" do
-            before do
-                @request.stubs(:protocol).returns "puppet"
-            end
-
-            it "should choose :rest when a server is specified" do
-                @request.stubs(:protocol).returns "puppet"
-                @request.expects(:server).returns "foo"
-                @object.select_terminus(@request).should == :rest
-            end
-
-            # This is so a given file location works when bootstrapping with no server.
-            it "should choose :rest when the Settings name isn't 'puppet'" do
-                @request.stubs(:protocol).returns "puppet"
-                @request.stubs(:server).returns "foo"
-                Puppet.settings.stubs(:value).with(:name).returns "foo"
-                @object.select_terminus(@request).should == :rest
-            end
-
-            it "should choose :file_server when the settings name is 'puppet' and no server is specified" do
-                modules = mock 'modules'
-
-                @request.expects(:protocol).returns "puppet"
-                @request.expects(:server).returns nil
-                Puppet.settings.expects(:value).with(:name).returns "puppet"
-                @object.select_terminus(@request).should == :file_server
-            end
-        end
-    end
-end

data/spec/unit/file_serving/metadata.rb

@@ -1,286 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../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.metaclass.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, " when finding the file to use for setting attributes" do
-    before do
-        @path = "/my/path"
-        @metadata = Puppet::FileServing::Metadata.new(@path)
-
-        # Use a link because it's easier to test -- no checksumming
-        @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
-
-        # Not quite.  We don't want to checksum links, but we must because they might be being followed.
-        @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
-        @metadata.stubs(:md5_file).returns(@checksum)           #
-    end
-
-    it "should accept a base path path to which the file should be relative" do
-        File.expects(:lstat).with(@path).returns @stat
-        File.expects(:readlink).with(@path).returns "/what/ever"
-        @metadata.collect
-    end
-
-    it "should use the set base path if one is not provided" do
-        File.expects(:lstat).with(@path).returns @stat
-        File.expects(:readlink).with(@path).returns "/what/ever"
-        @metadata.collect()
-    end
-
-    it "should raise an exception if the file does not exist" do
-        File.expects(:lstat).with(@path).raises(Errno::ENOENT)
-        proc { @metadata.collect()}.should raise_error(Errno::ENOENT)
-    end
-end
-
-describe Puppet::FileServing::Metadata, " when collecting attributes" do
-    before do
-        @path = "/my/file"
-        # Use a real file mode, so we can validate the masking is done.
-        @stat = stub 'stat', :uid => 10, :gid => 20, :mode => 33261, :ftype => "file"
-        File.stubs(:lstat).returns(@stat)
-        @checksum = Digest::MD5.hexdigest("some content\n")
-        @metadata = Puppet::FileServing::Metadata.new("/my/file")
-        @metadata.stubs(:md5_file).returns(@checksum)
-        @metadata.collect
-    end
-
-    it "should be able to produce xmlrpc-style attribute information" do
-        @metadata.should respond_to(:attributes_with_tabs)
-    end
-
-    # LAK:FIXME This should actually change at some point
-    it "should set the owner by id" do
-        @metadata.owner.should be_instance_of(Fixnum)
-    end
-
-    # LAK:FIXME This should actually change at some point
-    it "should set the group by id" do
-        @metadata.group.should be_instance_of(Fixnum)
-    end
-
-    it "should set the owner to the file's current owner" do
-        @metadata.owner.should == 10
-    end
-
-    it "should set the group to the file's current group" do
-        @metadata.group.should == 20
-    end
-
-    it "should set the mode to the file's masked mode" do
-        @metadata.mode.should == 0755
-    end
-
-    it "should set the checksum to the file's current checksum" do
-        @metadata.checksum.should == "{md5}" + @checksum
-    end
-
-    describe "when managing files" do
-        it "should default to a checksum of type MD5" 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.to_s
-        end
-
-        it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
-            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tfile\t10\t20\t{md5}#{@checksum}"
-        end
-    end
-
-    describe "when managing directories" do
-        before do
-            @stat.stubs(:ftype).returns("directory")
-            @time = Time.now
-            @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.to_s
-        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.to_s
-        end
-
-        it "should produce tab-separated mode, type, owner, group, and checksum for xmlrpc" do
-            @metadata.collect
-            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tdirectory\t10\t20\t{ctime}#{@time.to_s}"
-        end
-    end
-
-    describe "when managing links" do
-        before do
-            @stat.stubs(:ftype).returns("link")
-            File.expects(:readlink).with("/my/file").returns("/path/to/link")
-            @metadata.collect
- 
-            @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 read links instead of returning their checksums" do
-            @metadata.destination.should == "/path/to/link"
-        end
-
-        it "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
-            pending "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\t10\t20\t/path/to/link"
-        end
-
-        it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
-            @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t/path/to/link"
-        end
-    end
-end
-
-describe Puppet::FileServing::Metadata, " when pointing to a link" 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
-        it "should not collect the checksum if links are :manage" do
-            pending "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