diff --git a/lib/puppet/configurer/plugin_handler.rb b/lib/puppet/configurer/plugin_handler.rb
index 539441e75..8192d4719 100644
--- a/lib/puppet/configurer/plugin_handler.rb
+++ b/lib/puppet/configurer/plugin_handler.rb
@@ -1,28 +1,26 @@
 # Break out the code related to plugins.  This module is
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::PluginHandler
   def download_plugins?
     Puppet[:pluginsync]
   end
 
   # Retrieve facts from the central server.
   def download_plugins
     return nil unless download_plugins?
     Puppet::Configurer::Downloader.new("plugin", Puppet[:plugindest], Puppet[:pluginsource], Puppet[:pluginsignore]).evaluate.each { |file| load_plugin(file) }
   end
 
   def load_plugin(file)
     return unless FileTest.exist?(file)
     return if FileTest.directory?(file)
 
     begin
       Puppet.info "Loading downloaded plugin #{file}"
       load file
-    rescue SystemExit,NoMemoryError
-      raise
-    rescue Exception => detail
+    rescue StandardError, LoadError => detail
       Puppet.err "Could not load downloaded file #{file}: #{detail}"
     end
   end
 end
diff --git a/spec/unit/configurer/plugin_handler_spec.rb b/spec/unit/configurer/plugin_handler_spec.rb
index 25d2d47af..1423ae4b5 100755
--- a/spec/unit/configurer/plugin_handler_spec.rb
+++ b/spec/unit/configurer/plugin_handler_spec.rb
@@ -1,112 +1,112 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/plugin_handler'
 
 class PluginHandlerTester
   include Puppet::Configurer::PluginHandler
 end
 
 describe Puppet::Configurer::PluginHandler do
   before do
     @pluginhandler = PluginHandlerTester.new
   end
 
   it "should have a method for downloading plugins" do
     @pluginhandler.should respond_to(:download_plugins)
   end
 
   it "should have a boolean method for determining whether plugins should be downloaded" do
     @pluginhandler.should respond_to(:download_plugins?)
   end
 
   it "should download plugins when :pluginsync is true" do
     Puppet.settings.expects(:value).with(:pluginsync).returns true
     @pluginhandler.should be_download_plugins
   end
 
   it "should not download plugins when :pluginsync is false" do
     Puppet.settings.expects(:value).with(:pluginsync).returns false
     @pluginhandler.should_not be_download_plugins
   end
 
   it "should not download plugins when downloading is disabled" do
     Puppet::Configurer::Downloader.expects(:new).never
     @pluginhandler.expects(:download_plugins?).returns false
     @pluginhandler.download_plugins
   end
 
   it "should use an Agent Downloader, with the name, source, destination, and ignore set correctly, to download plugins when downloading is enabled" do
     downloader = mock 'downloader'
 
     Puppet.settings.expects(:value).with(:pluginsource).returns "psource"
     Puppet.settings.expects(:value).with(:plugindest).returns "pdest"
     Puppet.settings.expects(:value).with(:pluginsignore).returns "pignore"
 
     Puppet::Configurer::Downloader.expects(:new).with("plugin", "pdest", "psource", "pignore").returns downloader
 
     downloader.expects(:evaluate).returns []
 
     @pluginhandler.expects(:download_plugins?).returns true
     @pluginhandler.download_plugins
   end
 
   it "should be able to load plugins" do
     @pluginhandler.should respond_to(:load_plugin)
   end
 
   it "should load each downloaded file" do
     FileTest.stubs(:exist?).returns true
     downloader = mock 'downloader'
 
     Puppet::Configurer::Downloader.expects(:new).returns downloader
 
     downloader.expects(:evaluate).returns %w{one two}
 
     @pluginhandler.expects(:download_plugins?).returns true
 
     @pluginhandler.expects(:load_plugin).with("one")
     @pluginhandler.expects(:load_plugin).with("two")
 
     @pluginhandler.download_plugins
   end
 
   it "should load plugins when asked to do so" do
     FileTest.stubs(:exist?).returns true
     @pluginhandler.expects(:load).with("foo")
 
     @pluginhandler.load_plugin("foo")
   end
 
   it "should not try to load files that don't exist" do
-    FileTest.expects(:exist?).with("foo").returns true
+    FileTest.expects(:exist?).with("foo").returns false
     @pluginhandler.expects(:load).never
 
     @pluginhandler.load_plugin("foo")
   end
 
   it "should not try to load directories" do
     FileTest.stubs(:exist?).returns true
     FileTest.expects(:directory?).with("foo").returns true
     @pluginhandler.expects(:load).never
 
     @pluginhandler.load_plugin("foo")
   end
 
   it "should warn but not fail if loading a file raises an exception" do
     FileTest.stubs(:exist?).returns true
     @pluginhandler.expects(:load).with("foo").raises "eh"
 
     Puppet.expects(:err)
     @pluginhandler.load_plugin("foo")
   end
 
   it "should warn but not fail if loading a file raises a LoadError" do
     FileTest.stubs(:exist?).returns true
     @pluginhandler.expects(:load).with("foo").raises LoadError.new("eh")
 
     Puppet.expects(:err)
     @pluginhandler.load_plugin("foo")
   end
 end
diff --git a/spec/unit/configurer_spec.rb b/spec/unit/configurer_spec.rb
index 0c9d06362..ebc5768ea 100755
--- a/spec/unit/configurer_spec.rb
+++ b/spec/unit/configurer_spec.rb
@@ -1,494 +1,494 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-11-12.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/configurer'
 
 describe Puppet::Configurer do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
   end
 
   it "should include the Plugin Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::PluginHandler)
   end
 
   it "should include the Fact Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
   end
 
   it "should use the puppetdlockfile as its lockfile path" do
     Puppet.settings.expects(:value).with(:puppetdlockfile).returns("/my/lock")
     Puppet::Configurer.lockfile_path.should == "/my/lock"
   end
 
   describe "when executing a pre-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:prerun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_prerun_command
     end
 
     it "should execute any pre-run command provided via the 'prerun_command' setting" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_prerun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_prerun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 
   describe "when executing a post-run hook" do
     it "should do nothing if the hook is set to an empty string" do
       Puppet.settings[:postrun_command] = ""
       Puppet::Util.expects(:exec).never
 
       @agent.execute_postrun_command
     end
 
     it "should execute any post-run command provided via the 'postrun_command' setting" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
 
       @agent.execute_postrun_command
     end
 
     it "should fail if the command fails" do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
 
       lambda { @agent.execute_postrun_command }.should raise_error(Puppet::Configurer::CommandHookError)
     end
   end
 end
 
 describe Puppet::Configurer, "when initializing a report" do
   it "should return an instance of a transaction report" do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.initialize_report.should be_instance_of(Puppet::Transaction::Report)
   end
 end
 
 describe Puppet::Configurer, "when executing a catalog run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:prepare)
     @agent.stubs(:facts_for_uploading).returns({})
     @catalog = Puppet::Resource::Catalog.new
     @catalog.stubs(:apply)
     @agent.stubs(:retrieve_catalog).returns @catalog
 
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:close)
   end
 
   it "should prepare for the run" do
     @agent.expects(:prepare)
 
     @agent.run
   end
 
   it "should initialize a transaction report if one is not provided" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     @agent.run
   end
 
   it "should pass the new report to the catalog" do
     report = stub 'report'
     @agent.stubs(:initialize_report).returns report
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run
   end
 
   it "should use the provided report if it was passed one" do
     report = stub 'report'
     @agent.expects(:initialize_report).never
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run(:report => report)
   end
 
   it "should set the report as a log destination" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     Puppet::Util::Log.expects(:newdestination).with(report)
 
     @agent.run
   end
 
   it "should retrieve the catalog" do
     @agent.expects(:retrieve_catalog)
 
     @agent.run
   end
 
   it "should log a failure and do nothing if no catalog can be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     Puppet.expects(:err).with "Could not retrieve catalog; skipping run"
 
     @agent.run
   end
 
   it "should apply the catalog with all options to :run" do
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).with { |args| args[:one] == true }
     @agent.run :one => true
   end
 
   it "should accept a catalog and use it instead of retrieving a different one" do
     @agent.expects(:retrieve_catalog).never
 
     @catalog.expects(:apply)
     @agent.run :one => true, :catalog => @catalog
   end
 
   it "should benchmark how long it takes to apply the catalog" do
     @agent.expects(:benchmark).with(:notice, "Finished catalog run")
 
     @agent.expects(:retrieve_catalog).returns @catalog
 
     @catalog.expects(:apply).never # because we're not yielding
     @agent.run
   end
 
   it "should execute post-run hooks after the run" do
     @agent.expects(:execute_postrun_command)
 
     @agent.run
   end
 
   it "should send the report" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report).with { |r, trans| r == report }
 
     @agent.run
   end
 
   it "should send the transaction report with a reference to the transaction if a run was actually made" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     trans = stub 'transaction'
     @catalog.expects(:apply).returns trans
 
     @agent.expects(:send_report).with { |r, t| t == trans }
 
     @agent.run :catalog => @catalog
   end
 
   it "should send the transaction report even if the catalog could not be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report)
 
     @agent.run
   end
 
   it "should send the transaction report even if there is a failure" do
     @agent.expects(:retrieve_catalog).raises "whatever"
 
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
     @agent.expects(:send_report)
 
     lambda { @agent.run }.should raise_error
   end
 
   it "should remove the report as a log destination when the run is finished" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     Puppet::Util::Log.expects(:close).with(report)
 
     @agent.run
   end
 
   it "should return the report as the result of the run" do
     report = stub 'report'
     @agent.expects(:initialize_report).returns report
 
     @agent.run.should equal(report)
   end
 end
 
 describe Puppet::Configurer, "when sending a report" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @configurer = Puppet::Configurer.new
 
     @report = stub 'report'
     @trans = stub 'transaction'
   end
 
   it "should require a report" do
     lambda { @configurer.send_report }.should raise_error(ArgumentError)
   end
 
   it "should allow specification of a transaction" do
     lambda { @configurer.send_report(@report, @trans)  }.should_not raise_error(ArgumentError)
   end
 
   it "should use any provided transaction to add metrics to the report" do
     @trans.expects(:generate_report)
     @configurer.send_report(@report, @trans)
   end
 
   it "should print a report summary if configured to do so" do
     Puppet.settings[:summarize] = true
 
     @report.expects(:summary).returns "stuff"
 
     @configurer.expects(:puts).with("stuff")
     @configurer.send_report(@report)
   end
 
   it "should not print a report summary if not configured to do so" do
     Puppet.settings[:summarize] = false
 
     @configurer.expects(:puts).never
     @configurer.send_report(@report)
   end
 
   it "should save the report if reporting is enabled" do
     Puppet.settings[:report] = true
 
     @report.expects(:save)
     @configurer.send_report(@report)
   end
 
   it "should not save the report if reporting is disabled" do
     Puppet.settings[:report] = false
 
     @report.expects(:save).never
     @configurer.send_report(@report)
   end
 
   it "should log but not fail if saving the report fails" do
     Puppet.settings[:report] = true
 
     @report.expects(:save).raises "whatever"
 
     Puppet.expects(:err)
     lambda { @configurer.send_report(@report) }.should_not raise_error
   end
 end
 
 describe Puppet::Configurer, "when retrieving a catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:facts_for_uploading).returns({})
 
     @catalog = Puppet::Resource::Catalog.new
 
     # this is the default when using a Configurer instance
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
 
     @agent.stubs(:convert_catalog).returns @catalog
   end
 
   describe "and configured to only retrieve a catalog from the cache" do
     before do
       Puppet.settings[:use_cached_catalog] = true
     end
 
     it "should first look in the cache for a catalog" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
 
       @agent.retrieve_catalog.should == @catalog
     end
 
     it "should compile a new catalog if none is found in the cache" do
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
       Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
       @agent.retrieve_catalog.should == @catalog
     end
   end
 
   describe "when not using a REST terminus for catalogs" do
     it "should not pass any facts when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).never
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts].nil?
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   describe "when using a REST terminus for catalogs" do
     it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
       @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
       Puppet::Resource::Catalog.expects(:find).with { |name, options|
         options[:facts] == "myfacts" and options[:facts_format] == :foo
       }.returns @catalog
 
       @agent.retrieve_catalog
     end
   end
 
   it "should use the Catalog class to get its catalog" do
     Puppet::Resource::Catalog.expects(:find).returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should use its certname to retrieve the catalog" do
     Facter.stubs(:value).returns "eh"
     Puppet.settings[:certname] = "myhost.domain.com"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
 
     @agent.retrieve_catalog
   end
 
   it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return the cached catalog when no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     Puppet.expects(:notice)
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should not look in the cache for a catalog if one is returned from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should return the cached catalog when retrieving the remote catalog throws an exception" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
 
     @agent.retrieve_catalog.should == @catalog
   end
 
   it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
     Puppet.stubs(:[])
     Puppet.expects(:[]).with(:usecacheonfailure).returns false
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
 
     Puppet.expects(:warning)
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
     Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
 
     @agent.retrieve_catalog.should be_nil
   end
 
   it "should convert the catalog before returning" do
     Puppet::Resource::Catalog.stubs(:find).returns @catalog
 
     @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
     @agent.retrieve_catalog.should == "converted catalog"
   end
 
   it "should return nil if there is an error while retrieving the catalog" do
-    Puppet::Resource::Catalog.expects(:find).raises "eh"
+    Puppet::Resource::Catalog.expects(:find).at_least_once.raises "eh"
 
     @agent.retrieve_catalog.should be_nil
   end
 end
 
 describe Puppet::Configurer, "when converting the catalog" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
 
     @catalog = Puppet::Resource::Catalog.new
     @oldcatalog = stub 'old_catalog', :to_ral => @catalog
   end
 
   it "should convert the catalog to a RAL-formed catalog" do
     @oldcatalog.expects(:to_ral).returns @catalog
 
     @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
   end
 
   it "should finalize the catalog" do
     @catalog.expects(:finalize)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should record the passed retrieval time with the RAL catalog" do
     @catalog.expects(:retrieval_duration=).with 10
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 
   it "should write the RAL catalog's class file" do
     @catalog.expects(:write_class_file)
 
     @agent.convert_catalog(@oldcatalog, 10)
   end
 end
 
 describe Puppet::Configurer, "when preparing for a run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
     @agent = Puppet::Configurer.new
     @agent.stubs(:dostorage)
     @agent.stubs(:download_fact_plugins)
     @agent.stubs(:download_plugins)
     @agent.stubs(:execute_prerun_command)
     @facts = {"one" => "two", "three" => "four"}
   end
 
   it "should initialize the metadata store" do
     @agent.class.stubs(:facts).returns(@facts)
     @agent.expects(:dostorage)
     @agent.prepare
   end
 
   it "should download fact plugins" do
     @agent.expects(:download_fact_plugins)
 
     @agent.prepare
   end
 
   it "should download plugins" do
     @agent.expects(:download_plugins)
 
     @agent.prepare
   end
 
   it "should perform the pre-run commands" do
     @agent.expects(:execute_prerun_command)
     @agent.prepare
   end
 end
diff --git a/spec/unit/file_serving/fileset_spec.rb b/spec/unit/file_serving/fileset_spec.rb
index 9a90cff15..ecc77812c 100755
--- a/spec/unit/file_serving/fileset_spec.rb
+++ b/spec/unit/file_serving/fileset_spec.rb
@@ -1,347 +1,348 @@
 #!/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}
+    File.stubs(:lstat).returns stub("stat", :directory? => false)
 
     @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
diff --git a/spec/unit/indirector/ssl_file_spec.rb b/spec/unit/indirector/ssl_file_spec.rb
index 83145cffc..37098a7a9 100755
--- a/spec/unit/indirector/ssl_file_spec.rb
+++ b/spec/unit/indirector/ssl_file_spec.rb
@@ -1,281 +1,281 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2008-3-10.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/indirector/ssl_file'
 
 describe Puppet::Indirector::SslFile do
   before do
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :testing, :model => @model
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
     @file_class = Class.new(Puppet::Indirector::SslFile) do
       def self.to_s
         "Testing::Mytype"
       end
     end
 
-    @setting = :mydir
+    @setting = :certdir
     @file_class.store_in @setting
-    @path = "/my/directory"
-    Puppet.settings.stubs(:value).with(:noop).returns(false)
-    Puppet.settings.stubs(:value).with(@setting).returns(@path)
-    Puppet.settings.stubs(:value).with(:trace).returns(false)
+    @path = "/tmp/my_directory"
+    Puppet[:noop] = false
+    Puppet[@setting] = @path
+    Puppet[:trace] = false
   end
 
   it "should use :main and :ssl upon initialization" do
     Puppet.settings.expects(:use).with(:main, :ssl)
     @file_class.new
   end
 
   it "should return a nil collection directory if no directory setting has been provided" do
     @file_class.store_in nil
     @file_class.collection_directory.should be_nil
   end
 
   it "should return a nil file location if no location has been provided" do
     @file_class.store_at nil
     @file_class.file_location.should be_nil
   end
 
   it "should fail if no store directory or file location has been set" do
     @file_class.store_in nil
     @file_class.store_at nil
     lambda { @file_class.new }.should raise_error(Puppet::DevError)
   end
 
   describe "when managing ssl files" do
     before do
       Puppet.settings.stubs(:use)
       @searcher = @file_class.new
 
       @cert = stub 'certificate', :name => "myname"
       @certpath = File.join(@path, "myname.pem")
 
       @request = stub 'request', :key => @cert.name, :instance => @cert
     end
 
     it "should consider the file a ca file if the name is equal to what the SSL::Host class says is the CA name" do
       Puppet::SSL::Host.expects(:ca_name).returns "amaca"
       @searcher.should be_ca("amaca")
     end
 
     describe "when choosing the location for certificates" do
       it "should set them at the ca setting's path if a ca setting is available and the name resolves to the CA name" do
         @file_class.store_in nil
         @file_class.store_at :mysetting
         @file_class.store_ca_at :casetting
 
         Puppet.settings.stubs(:value).with(:casetting).returns "/ca/file"
 
         @searcher.expects(:ca?).with(@cert.name).returns true
         @searcher.path(@cert.name).should == "/ca/file"
       end
 
       it "should set them at the file location if a file setting is available" do
         @file_class.store_in nil
         @file_class.store_at :mysetting
 
         Puppet.settings.stubs(:value).with(:mysetting).returns "/some/file"
 
         @searcher.path(@cert.name).should == "/some/file"
       end
 
       it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
         @searcher.path(@cert.name).should == @certpath
       end
     end
 
     describe "when finding certificates on disk" do
       describe "and no certificate is present" do
         before do
           # Stub things so the case management bits work.
           FileTest.stubs(:exist?).with(File.dirname(@certpath)).returns false
           FileTest.expects(:exist?).with(@certpath).returns false
         end
 
         it "should return nil" do
           @searcher.find(@request).should be_nil
         end
       end
 
       describe "and a certificate is present" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns true
         end
 
         it "should return an instance of the model, which it should use to read the certificate" do
           cert = mock 'cert'
           model = mock 'model'
           @file_class.stubs(:model).returns model
 
           model.expects(:new).with("myname").returns cert
           cert.expects(:read).with(@certpath)
           @searcher.find(@request).should equal(cert)
         end
       end
 
       describe "and a certificate is present but has uppercase letters" do
         before do
           @request = stub 'request', :key => "myhost"
         end
 
         # This is kind of more an integration test; it's for #1382, until
         # the support for upper-case certs can be removed around mid-2009.
         it "should rename the existing file to the lower-case path" do
           @path = @searcher.path("myhost")
           FileTest.expects(:exist?).with(@path).returns(false)
           dir, file = File.split(@path)
           FileTest.expects(:exist?).with(dir).returns true
           Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
 
           File.expects(:rename).with(File.join(dir, file.upcase), @path)
 
           cert = mock 'cert'
           model = mock 'model'
           @searcher.stubs(:model).returns model
           @searcher.model.expects(:new).with("myhost").returns cert
           cert.expects(:read).with(@path)
 
           @searcher.find(@request)
         end
       end
     end
 
     describe "when saving certificates to disk" do
       before do
         FileTest.stubs(:directory?).returns true
         FileTest.stubs(:writable?).returns true
       end
 
       it "should fail if the directory is absent" do
         FileTest.expects(:directory?).with(File.dirname(@certpath)).returns false
         lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
       end
 
       it "should fail if the directory is not writeable" do
         FileTest.stubs(:directory?).returns true
         FileTest.expects(:writable?).with(File.dirname(@certpath)).returns false
         lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
       end
 
       it "should save to the path the output of converting the certificate to a string" do
         fh = mock 'filehandle'
         fh.expects(:print).with("mycert")
 
         @searcher.stubs(:write).yields fh
         @cert.expects(:to_s).returns "mycert"
 
         @searcher.save(@request)
       end
 
       describe "and a directory setting is set" do
         it "should use the Settings class to write the file" do
           @searcher.class.store_in @setting
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:writesub).with(@setting, @certpath).yields fh
 
           @searcher.save(@request)
         end
       end
 
       describe "and a file location is set" do
         it "should use the filehandle provided by the Settings" do
           @searcher.class.store_at @setting
 
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:write).with(@setting).yields fh
           @searcher.save(@request)
         end
       end
 
       describe "and the name is the CA name and a ca setting is set" do
         it "should use the filehandle provided by the Settings" do
           @searcher.class.store_at @setting
           @searcher.class.store_ca_at :castuff
           Puppet.settings.stubs(:value).with(:castuff).returns "castuff stub"
 
           fh = mock 'filehandle'
           fh.stubs :print
           Puppet.settings.expects(:write).with(:castuff).yields fh
           @searcher.stubs(:ca?).returns true
           @searcher.save(@request)
         end
       end
     end
 
     describe "when destroying certificates" do
       describe "that do not exist" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns false
         end
 
         it "should return false" do
           @searcher.destroy(@request).should be_false
         end
       end
 
       describe "that exist" do
         before do
           FileTest.expects(:exist?).with(@certpath).returns true
         end
 
         it "should unlink the certificate file" do
           File.expects(:unlink).with(@certpath)
           @searcher.destroy(@request)
         end
 
         it "should log that is removing the file" do
           File.stubs(:exist?).returns true
           File.stubs(:unlink)
           Puppet.expects(:notice)
           @searcher.destroy(@request)
         end
       end
     end
 
     describe "when searching for certificates" do
       before do
         @model = mock 'model'
         @file_class.stubs(:model).returns @model
       end
       it "should return a certificate instance for all files that exist" do
         Dir.expects(:entries).with(@path).returns %w{one.pem two.pem}
 
         one = stub 'one', :read => nil
         two = stub 'two', :read => nil
 
         @model.expects(:new).with("one").returns one
         @model.expects(:new).with("two").returns two
 
         @searcher.search(@request).should == [one, two]
       end
 
       it "should read each certificate in using the model's :read method" do
         Dir.expects(:entries).with(@path).returns %w{one.pem}
 
         one = stub 'one'
         one.expects(:read).with(File.join(@path, "one.pem"))
 
         @model.expects(:new).with("one").returns one
 
         @searcher.search(@request)
       end
 
       it "should skip any files that do not match /\.pem$/" do
         Dir.expects(:entries).with(@path).returns %w{. .. one.pem}
 
         one = stub 'one', :read => nil
 
         @model.expects(:new).with("one").returns one
 
         @searcher.search(@request)
       end
     end
   end
 end
diff --git a/spec/unit/provider/service/init_spec.rb b/spec/unit/provider/service/init_spec.rb
index bbc88ff76..856821985 100755
--- a/spec/unit/provider/service/init_spec.rb
+++ b/spec/unit/provider/service/init_spec.rb
@@ -1,168 +1,170 @@
 #!/usr/bin/env ruby
 #
 # Unit testing for the Init service Provider
 #
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 provider_class = Puppet::Type.type(:service).provider(:init)
 
 describe provider_class do
 
   before :each do
     @class = Puppet::Type.type(:service).provider(:init)
     @resource = stub 'resource'
     @resource.stubs(:[]).returns(nil)
     @resource.stubs(:[]).with(:name).returns "myservice"
 #        @resource.stubs(:[]).with(:ensure).returns :enabled
     @resource.stubs(:[]).with(:path).returns ["/service/path","/alt/service/path"]
 #        @resource.stubs(:ref).returns "Service[myservice]"
     File.stubs(:directory?).returns(true)
 
     @provider = provider_class.new
     @provider.resource = @resource
   end
 
   describe "when getting all service instances" do
     before :each do
       @services = ['one', 'two', 'three', 'four']
       Dir.stubs(:entries).returns @services
       FileTest.stubs(:directory?).returns(true)
       FileTest.stubs(:executable?).returns(true)
       @class.stubs(:defpath).returns('tmp')
     end
     it "should return instances for all services" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = @services.collect {|x| "#{x}_instance"}
       @class.instances.should == results
     end
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
       (@services-exclude).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = (@services-exclude).collect {|x| "#{x}_instance"}
       @class.get_services(@class.defpath, exclude).should == results
     end
     it "should omit a single service from the exclude list" do
       exclude = 'two'
       (@services-exclude.to_a).each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
       end
       results = @services.reject{|x| x==exclude }.collect {|x| "#{x}_instance"}
       @class.get_services(@class.defpath, exclude).should == results
     end
     it "should use defpath" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:path] == @class.defpath}.returns("#{inst}_instance")
       end
       results = @services.sort.collect {|x| "#{x}_instance"}
       @class.instances.sort.should == results
     end
     it "should set hasstatus to true for providers" do
       @services.each do |inst|
         @class.expects(:new).with{|hash| hash[:name] == inst && hash[:hasstatus] == true}.returns("#{inst}_instance")
       end
       results = @services.collect {|x| "#{x}_instance"}
       @class.instances.should == results
     end
   end
 
   describe "when searching for the init script" do
     it "should discard paths that do not exist" do
       File.stubs(:exist?).returns(false)
       File.stubs(:directory?).returns(false)
       @provider.paths.should be_empty
     end
 
     it "should discard paths that are not directories" do
       File.stubs(:exist?).returns(true)
       File.stubs(:directory?).returns(false)
       @provider.paths.should be_empty
     end
 
     it "should be able to find the init script in the service path" do
+      File.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
       File.expects(:stat).with("/service/path/myservice").returns true
       @provider.initscript.should == "/service/path/myservice"
     end
     it "should be able to find the init script in the service path" do
+      File.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
       File.expects(:stat).with("/alt/service/path/myservice").returns true
       @provider.initscript.should == "/alt/service/path/myservice"
     end
     it "should fail if the service isn't there" do
       lambda { @provider.initscript }.should raise_error(Puppet::Error, "Could not find init script for 'myservice'")
     end
   end
 
   describe "if the init script is present" do
     before :each do
       File.stubs(:stat).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
         @provider.should respond_to(method)
       end
       describe "when running #{method}" do
 
         it "should use any provided explicit command" do
           @resource.stubs(:[]).with(method).returns "/user/specified/command"
           @provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
           @provider.send(method)
         end
 
         it "should pass #{method} to the init script when no explicit command is provided" do
           @resource.stubs(:[]).with("has#{method}".intern).returns :true
           @provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
           @provider.send(method)
         end
       end
     end
 
     describe "when checking status" do
       describe "when hasstatus is :true" do
         before :each do
           @resource.stubs(:[]).with(:hasstatus).returns :true
         end
         it "should execute the command" do
           @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
           @provider.status
         end
         it "should consider the process running if the command returns 0" do
           @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
           $CHILD_STATUS.stubs(:exitstatus).returns(0)
           @provider.status.should == :running
         end
         [-10,-1,1,10].each { |ec|
           it "should consider the process stopped if the command returns something non-0" do
             @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
             $CHILD_STATUS.stubs(:exitstatus).returns(ec)
             @provider.status.should == :stopped
           end
         }
       end
       describe "when hasstatus is not :true" do
         it "should consider the service :running if it has a pid" do
           @provider.expects(:getpid).returns "1234"
           @provider.status.should == :running
         end
         it "should consider the service :stopped if it doesn't have a pid" do
           @provider.expects(:getpid).returns nil
           @provider.status.should == :stopped
         end
       end
     end
 
     describe "when restarting and hasrestart is not :true" do
       it "should stop and restart the process" do
         @provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
         @provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
         $CHILD_STATUS.stubs(:exitstatus).returns(0)
         @provider.restart
       end
     end
 
   end
 end
diff --git a/spec/unit/type/file/source_spec.rb b/spec/unit/type/file/source_spec.rb
index 522ae1f0e..00cc2f235 100755
--- a/spec/unit/type/file/source_spec.rb
+++ b/spec/unit/type/file/source_spec.rb
@@ -1,272 +1,272 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 source = Puppet::Type.type(:file).attrclass(:source)
 describe Puppet::Type.type(:file).attrclass(:source) do
   before do
     # Wow that's a messy interface to the resource.
-    @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false)
+    @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false), :line => 0, :file => ''
   end
 
   it "should be a subclass of Parameter" do
     source.superclass.must == Puppet::Parameter
   end
 
   describe "when initializing" do
     it "should fail if the set values are not URLs" do
       s = source.new(:resource => @resource)
       URI.expects(:parse).with('foo').raises RuntimeError
 
       lambda { s.value = %w{foo} }.must raise_error(Puppet::Error)
     end
 
     it "should fail if the URI is not a local file, file URI, or puppet URI" do
       s = source.new(:resource => @resource)
 
       lambda { s.value = %w{http://foo/bar} }.must raise_error(Puppet::Error)
     end
   end
 
   it "should have a method for retrieving its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata)
   end
 
   it "should have a method for setting its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata=)
   end
 
   describe "when returning the metadata" do
     before do
       @metadata = stub 'metadata', :source= => nil
     end
 
     it "should return already-available metadata" do
       @source = source.new(:resource => @resource)
       @source.metadata = "foo"
       @source.metadata.should == "foo"
     end
 
     it "should return nil if no @should value is set and no metadata is available" do
       @source = source.new(:resource => @resource)
       @source.metadata.should be_nil
     end
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns @metadata
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
       metadata = stub 'metadata', :source= => nil
       @source = source.new(:resource => @resource, :value => ["/foo/bar", "/fee/booz"])
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
       @source.metadata.should equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
       metadata = mock 'metadata'
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns metadata
 
       metadata.expects(:source=).with("/foo/bar")
       @source.metadata
     end
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").raises RuntimeError
 
       @source.expects(:fail).raises ArgumentError
       lambda { @source.metadata }.should raise_error(ArgumentError)
     end
 
     it "should fail if no specified sources can be found" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
 
       @source.expects(:fail).raises RuntimeError
 
       lambda { @source.metadata }.should raise_error(RuntimeError)
     end
 
     it "should expire the metadata appropriately" do
       expirer = stub 'expired', :dependent_data_expired? => true
 
       metadata = stub 'metadata', :source= => nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
 
       @source = source.new(:resource => @resource, :value => ["/fee/booz"])
       @source.metadata = "foo"
 
       @source.stubs(:expirer).returns expirer
 
       @source.metadata.should_not == "foo"
     end
   end
 
   it "should have a method for setting the desired values on the resource" do
     source.new(:resource => @resource).must respond_to(:copy_source_values)
   end
 
   describe "when copying the source values" do
     before do
 
       @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
 
       @source = source.new(:resource => @resource)
       @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf", :ftype => "file"
       @source.stubs(:metadata).returns @metadata
     end
 
     it "should fail if there is no metadata" do
       @source.stubs(:metadata).returns nil
       @source.expects(:devfail).raises ArgumentError
       lambda { @source.copy_source_values }.should raise_error(ArgumentError)
     end
 
     it "should set :ensure to the file type" do
       @metadata.stubs(:ftype).returns "file"
 
       @source.copy_source_values
       @resource[:ensure].must == :file
     end
 
     it "should not set 'ensure' if it is already set to 'absent'" do
       @metadata.stubs(:ftype).returns "file"
 
       @resource[:ensure] = :absent
       @source.copy_source_values
       @resource[:ensure].must == :absent
     end
 
     describe "and the source is a file" do
       before do
         @metadata.stubs(:ftype).returns "file"
       end
 
       it "should copy the metadata's owner, group, checksum, and mode to the resource if they are not set on the resource" do
         Puppet.features.expects(:root?).returns true
 
         @source.copy_source_values
 
         @resource[:owner].must == 100
         @resource[:group].must == 200
         @resource[:mode].must == "173"
 
         # Metadata calls it checksum, we call it content.
         @resource[:content].must == @metadata.checksum
       end
 
       it "should not copy the metadata's owner to the resource if it is already set" do
         @resource[:owner] = 1
         @resource[:group] = 2
         @resource[:mode] = 3
         @resource[:content] = "foobar"
 
         @source.copy_source_values
 
         @resource[:owner].must == 1
         @resource[:group].must == 2
         @resource[:mode].must == "3"
         @resource[:content].should_not == @metadata.checksum
       end
 
       describe "and puppet is not running as root" do
         it "should not try to set the owner" do
           Puppet.features.expects(:root?).returns false
 
           @source.copy_source_values
           @resource[:owner].should be_nil
         end
       end
     end
 
     describe "and the source is a link" do
       it "should set the target to the link destination" do
         @metadata.stubs(:ftype).returns "link"
         @resource.stubs(:[])
         @resource.stubs(:[]=)
 
         @metadata.expects(:destination).returns "/path/to/symlink"
 
         @resource.expects(:[]=).with(:target, "/path/to/symlink")
         @source.copy_source_values
       end
     end
   end
 
   it "should have a local? method" do
     source.new(:resource => @resource).must be_respond_to(:local?)
   end
 
   context "when accessing source properties" do
     before(:each) do
       @source = source.new(:resource => @resource)
       @metadata = stub_everything
       @source.stubs(:metadata).returns(@metadata)
     end
 
     describe "for local sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("file:///path/to/source")
       end
 
       it "should be local" do
         @source.must be_local
       end
 
       it "should be local if there is no scheme" do
         @metadata.stubs(:source).returns("/path/to/source")
         @source.must be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
     end
 
     describe "for remote sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("puppet://server:8192/path/to/source")
       end
 
       it "should not be local" do
         @source.should_not be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
 
       it "should be able to return the source server" do
         @source.server.should == "server"
       end
 
       it "should be able to return the source port" do
         @source.port.should == 8192
       end
 
       describe "which don't specify server or port" do
         before(:each) do
           @metadata.stubs(:source).returns("puppet:///path/to/source")
         end
 
         it "should return the default source server" do
           Puppet.settings.expects(:[]).with(:server).returns("myserver")
           @source.server.should == "myserver"
         end
 
         it "should return the default source port" do
           Puppet.settings.expects(:[]).with(:masterport).returns(1234)
           @source.port.should == 1234
         end
       end
     end
   end
 
 end
diff --git a/spec/unit/type/file_spec.rb b/spec/unit/type/file_spec.rb
index 7d93dfd64..4fcad07e1 100755
--- a/spec/unit/type/file_spec.rb
+++ b/spec/unit/type/file_spec.rb
@@ -1,1070 +1,1070 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:file) do
   before do
     Puppet.settings.stubs(:use)
     @real_posix = Puppet.features.posix?
     Puppet.features.stubs("posix?").returns(true)
 
     @path = Tempfile.new("puppetspec")
     pathname = @path.path
     @path.close!()
     @path = pathname
     @file = Puppet::Type::File.new(:name => @path)
 
     @catalog = Puppet::Resource::Catalog.new
     @file.catalog = @catalog
   end
 
   describe "when determining if recursion is enabled" do
     it "should default to recursion being disabled" do
       @file.should_not be_recurse
     end
     [true, "true", 10, "inf", "remote"].each do |value|
       it "should consider #{value} to enable recursion" do
         @file[:recurse] = value
         @file.must be_recurse
       end
     end
 
     [false, "false", 0].each do |value|
       it "should consider #{value} to disable recursion" do
         @file[:recurse] = value
         @file.should_not be_recurse
       end
     end
   end
 
   describe "#write" do
 
     it "should propagate failures encountered when renaming the temporary file" do
       File.stubs(:open)
 
       File.expects(:rename).raises ArgumentError
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
 
       file.stubs(:validate_checksum?).returns(false)
 
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file.stubs(:property).with(:content).returns(property)
 
       lambda { file.write(:content) }.should raise_error(Puppet::Error)
     end
 
     it "should delegate writing to the content property" do
       filehandle = stub_everything 'fh'
       File.stubs(:open).yields(filehandle)
       File.stubs(:rename)
       property = stub('content_property', :actual_content => "something", :length => "something".length)
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.stubs(:validate_checksum?).returns(false)
       file.stubs(:property).with(:content).returns(property)
 
       property.expects(:write).with(filehandle)
 
       file.write(:content)
     end
 
     describe "when validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(true) }
 
       it "should fail if the checksum parameter and content checksums do not match" do
-        checksum = stub('checksum_parameter',  :sum => 'checksum_b')
+        checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should raise_error(Puppet::Error)
       end
     end
 
     describe "when not validating the checksum" do
       before { @file.stubs(:validate_checksum?).returns(false) }
 
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         @file.stubs(:parameter).with(:checksum).returns(checksum)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         @file.stubs(:property).with(:content).returns(property)
 
         lambda { @file.write :NOTUSED }.should_not raise_error(Puppet::Error)
       end
 
     end
   end
 
   it "should have a method for determining if the file is present" do
     @file.must respond_to(:exist?)
   end
 
   it "should be considered existent if it can be stat'ed" do
     @file.expects(:stat).returns mock('stat')
     @file.must be_exist
   end
 
   it "should be considered nonexistent if it can not be stat'ed" do
     @file.expects(:stat).returns nil
     @file.must_not be_exist
   end
 
   it "should have a method for determining if the file should be a normal file" do
     @file.must respond_to(:should_be_file?)
   end
 
   it "should be a file if :ensure is set to :file" do
     @file[:ensure] = :file
     @file.must be_should_be_file
   end
 
   it "should be a file if :ensure is set to :present and the file exists as a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "file"))
     @file[:ensure] = :present
     @file.must be_should_be_file
   end
 
   it "should not be a file if :ensure is set to something other than :file" do
     @file[:ensure] = :directory
     @file.must_not be_should_be_file
   end
 
   it "should not be a file if :ensure is set to :present and the file exists but is not a normal file" do
     @file.stubs(:stat).returns(mock('stat', :ftype => "directory"))
     @file[:ensure] = :present
     @file.must_not be_should_be_file
   end
 
   it "should be a file if :ensure is not set and :content is" do
     @file[:content] = "foo"
     @file.must be_should_be_file
   end
 
   it "should be a file if neither :ensure nor :content is set but the file exists as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "file"))
     @file.must be_should_be_file
   end
 
   it "should not be a file if neither :ensure nor :content is set but the file exists but not as a normal file" do
     @file.stubs(:stat).returns(mock("stat", :ftype => "directory"))
     @file.must_not be_should_be_file
   end
 
   describe "when using POSIX filenames" do
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "/foo/bar")
         dir = Puppet::Type::File.new(:path => "/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz/")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar//baz")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "/foo/bar/baz//")
         file[:path].should == "/foo/bar/baz"
       end
 
       it "should leave a single slash alone" do
         file = Puppet::Type::File.new(:path => "/")
         file[:path].should == "/"
       end
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when using Microsoft Windows filenames" do
     confine "Only works on Microsoft Windows" => Puppet.features.microsoft_windows?
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar")
         dir = Puppet::Type::File.new(:path => "X:/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "X:/")
         @catalog.add_resource file
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz/")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar//baz")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "X:/foo/bar/baz//")
         file[:path].should == "X:/foo/bar/baz"
       end
 
       it "should leave a drive letter with a slash alone" do
         file = Puppet::Type::File.new(:path => "X:/")
         file[:path].should == "X:/"
       end
 
       it "should add a slash to a drive letter" do
         file = Puppet::Type::File.new(:path => "X:")
         file[:path].should == "X:/"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when using UNC filenames" do
     describe "on Microsoft Windows systems" do
       confine "Only works on Microsoft Windows" => Puppet.features.microsoft_windows?
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should autorequire its parent directory" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar")
         dir = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         @catalog.add_resource dir
         reqs = file.autorequire
         reqs[0].source.must == dir
         reqs[0].target.must == file
       end
 
       it "should not autorequire its parent dir if its parent dir is itself" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         @catalog.add_resource file
         puts file.autorequire
         file.autorequire.should be_empty
       end
 
       it "should remove trailing slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz/")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar//baz")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove trailing double slashes" do
         file = Puppet::Type::File.new(:path => "//server/foo/bar/baz//")
         file[:path].should == "//server/foo/bar/baz"
       end
 
       it "should remove a trailing slash from a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo/")
         file[:path].should == "//server/foo"
       end
 
       it "should not modify a sharename" do
         file = Puppet::Type::File.new(:path => "//server/foo")
         file[:path].should == "//server/foo"
       end
     end
 
     describe "on POSIX systems" do
       before do
         Puppet.features.stubs(:posix?).returns(true)
         Puppet.features.stubs(:microsoft_windows?).returns(false)
       end
 
       it "should refuse to work" do
         lambda { Puppet::Type::File.new(:path => "X:/foo/bar") }.should raise_error(Puppet::Error)
       end
     end
   end
 
   describe "when initializing" do
     it "should set a desired 'ensure' value if none is set and 'content' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :content => "/foo/bar")
       file[:ensure].should == :file
     end
 
     it "should set a desired 'ensure' value if none is set and 'target' is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :target => "/foo/bar")
       file[:ensure].should == :symlink
     end
   end
 
   describe "when validating attributes" do
     %w{path checksum backup recurse recurselimit source replace force ignore links purge sourceselect}.each do |attr|
       it "should have a '#{attr}' parameter" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :param
       end
     end
 
     %w{content target ensure owner group mode type}.each do |attr|
       it "should have a '#{attr}' property" do
         Puppet::Type.type(:file).attrtype(attr.intern).should == :property
       end
     end
 
     it "should have its 'path' attribute set as its namevar" do
       Puppet::Type.type(:file).key_attributes.should == [:path]
     end
   end
 
   describe "when managing links" do
     require 'puppettest/support/assertions'
     include PuppetTest
     require 'tempfile'
 
     if @real_posix
       describe "on POSIX systems" do
         before do
           @basedir = tempfile
           Dir.mkdir(@basedir)
           @file = File.join(@basedir, "file")
           @link = File.join(@basedir, "link")
 
           File.open(@file, "w", 0644) { |f| f.puts "yayness"; f.flush }
           File.symlink(@file, @link)
 
 
                 @resource = Puppet::Type.type(:file).new(
                 
             :path => @link,
         
             :mode => "755"
           )
           @catalog.add_resource @resource
         end
 
         after do
           remove_tmp_files
         end
 
         it "should default to managing the link" do
           @catalog.apply
           # I convert them to strings so they display correctly if there's an error.
           ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0644
         end
 
         it "should be able to follow links" do
           @resource[:links] = :follow
           @catalog.apply
 
           ("%o" % (File.stat(@file).mode & 007777)).should == "%o" % 0755
         end
       end
     else # @real_posix
       # should recode tests using expectations instead of using the filesystem
     end
 
     describe "on Microsoft Windows systems" do
       before do
         Puppet.features.stubs(:posix?).returns(false)
         Puppet.features.stubs(:microsoft_windows?).returns(true)
       end
 
       it "should refuse to work with links"
     end
   end
 
   it "should be able to retrieve a stat instance for the file it is managing" do
     Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo").should respond_to(:stat)
   end
 
   describe "when stat'ing its file" do
     before do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       @resource[:links] = :manage # so we always use :lstat
     end
 
     it "should use :stat if it is following links" do
       @resource[:links] = :follow
       File.expects(:stat)
 
       @resource.stat
     end
 
     it "should use :lstat if is it not following links" do
       @resource[:links] = :manage
       File.expects(:lstat)
 
       @resource.stat
     end
 
     it "should stat the path of the file" do
       File.expects(:lstat).with("/foo/bar")
 
       @resource.stat
     end
 
     # This only happens in testing.
     it "should return nil if the stat does not exist" do
       File.expects(:lstat).returns nil
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file does not exist" do
       File.expects(:lstat).raises(Errno::ENOENT)
 
       @resource.stat.should be_nil
     end
 
     it "should return nil if the file cannot be stat'ed" do
       File.expects(:lstat).raises(Errno::EACCES)
 
       @resource.stat.should be_nil
     end
 
     it "should return the stat instance" do
       File.expects(:lstat).returns "mystat"
 
       @resource.stat.should == "mystat"
     end
 
     it "should cache the stat instance if it has a catalog and is applying" do
       stat = mock 'stat'
       File.expects(:lstat).returns stat
 
       catalog = Puppet::Resource::Catalog.new
       @resource.catalog = catalog
 
       catalog.stubs(:applying?).returns true
 
       @resource.stat.should equal(@resource.stat)
     end
   end
 
   describe "when flushing" do
     it "should flush all properties that respond to :flush" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar", :source => "/bar/foo")
       @resource.parameter(:source).expects(:flush)
       @resource.flush
     end
 
     it "should reset its stat reference" do
       @resource = Puppet::Type.type(:file).new(:path => "/foo/bar")
       File.expects(:lstat).times(2).returns("stat1").then.returns("stat2")
       @resource.stat.should == "stat1"
       @resource.flush
       @resource.stat.should == "stat2"
     end
   end
 
   it "should have a method for performing recursion" do
     @file.must respond_to(:perform_recursion)
   end
 
   describe "when executing a recursive search" do
     it "should use Metadata to do its recursion" do
       Puppet::FileServing::Metadata.expects(:search)
       @file.perform_recursion(@file[:path])
     end
 
     it "should use the provided path as the key to the search" do
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| key == "/foo" }
       @file.perform_recursion("/foo")
     end
 
     it "should return the results of the metadata search" do
       Puppet::FileServing::Metadata.expects(:search).returns "foobar"
       @file.perform_recursion(@file[:path]).should == "foobar"
     end
 
     it "should pass its recursion value to the search" do
       @file[:recurse] = true
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass true if recursion is remote" do
       @file[:recurse] = :remote
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurse] == true }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its recursion limit value to the search" do
       @file[:recurselimit] = 10
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:recurselimit] == 10 }
       @file.perform_recursion(@file[:path])
     end
 
     it "should configure the search to ignore or manage links" do
       @file[:links] = :manage
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:links] == :manage }
       @file.perform_recursion(@file[:path])
     end
 
     it "should pass its 'ignore' setting to the search if it has one" do
       @file[:ignore] = %w{.svn CVS}
       Puppet::FileServing::Metadata.expects(:search).with { |key, options| options[:ignore] == %w{.svn CVS} }
       @file.perform_recursion(@file[:path])
     end
   end
 
   it "should have a method for performing local recursion" do
     @file.must respond_to(:recurse_local)
   end
 
   describe "when doing local recursion" do
     before do
       @metadata = stub 'metadata', :relative_path => "my/file"
     end
 
     it "should pass its path to the :perform_recursion method" do
       @file.expects(:perform_recursion).with(@file[:path]).returns [@metadata]
       @file.stubs(:newchild)
       @file.recurse_local
     end
 
     it "should return an empty hash if the recursion returns nothing" do
       @file.expects(:perform_recursion).returns nil
       @file.recurse_local.should == {}
     end
 
     it "should create a new child resource with each generated metadata instance's relative path" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with(@metadata.relative_path).returns "fiebar"
       @file.recurse_local
     end
 
     it "should not create a new child resource for the '.' directory" do
       @metadata.stubs(:relative_path).returns "."
 
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).never
       @file.recurse_local
     end
 
     it "should return a hash of the created resources with the relative paths as the hash keys" do
       @file.expects(:perform_recursion).returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local.should == {"my/file" => "fiebar"}
     end
 
     it "should set checksum_type to none if this file checksum is none" do
       @file[:checksum] = :none
       Puppet::FileServing::Metadata.expects(:search).with { |path,params| params[:checksum_type] == :none }.returns [@metadata]
       @file.expects(:newchild).with("my/file").returns "fiebar"
       @file.recurse_local
     end
   end
 
   it "should have a method for performing link recursion" do
     @file.must respond_to(:recurse_link)
   end
 
   describe "when doing link recursion" do
     before do
       @first = stub 'first', :relative_path => "first", :full_path => "/my/first", :ftype => "directory"
       @second = stub 'second', :relative_path => "second", :full_path => "/my/second", :ftype => "file"
 
       @resource = stub 'file', :[]= => nil
     end
 
     it "should pass its target to the :perform_recursion method" do
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_link({})
     end
 
     it "should ignore the recursively-found '.' file and configure the top-level file to create a directory" do
       @first.stubs(:relative_path).returns "."
       @file[:target] = "mylinks"
       @file.expects(:perform_recursion).with("mylinks").returns [@first]
       @file.stubs(:newchild).never
       @file.expects(:[]=).with(:ensure, :directory)
       @file.recurse_link({})
     end
 
     it "should create a new child resource for each generated metadata instance's relative path that doesn't already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.expects(:newchild).with(@first.relative_path).returns @resource
       @file.recurse_link("second" => @resource)
     end
 
     it "should not create a new child resource for paths that already exist in the children hash" do
       @file.expects(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_link("first" => @resource)
     end
 
     it "should set the target to the full path of discovered file and set :ensure to :link if the file is not a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:target, "/my/second")
       file.expects(:[]=).with(:ensure, :link)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => @resource, "second" => file)
     end
 
     it "should :ensure to :directory if the file is a directory" do
       file = stub 'file'
       file.expects(:[]=).with(:ensure, :directory)
 
       @file.stubs(:perform_recursion).returns [@first, @second]
       @file.recurse_link("first" => file, "second" => @resource)
     end
 
     it "should return a hash with both created and existing resources with the relative paths as the hash keys" do
       file = stub 'file', :[]= => nil
 
       @file.expects(:perform_recursion).returns [@first, @second]
       @file.stubs(:newchild).returns file
       @file.recurse_link("second" => @resource).should == {"second" => @resource, "first" => file}
     end
   end
 
   it "should have a method for performing remote recursion" do
     @file.must respond_to(:recurse_remote)
   end
 
   describe "when doing remote recursion" do
     before do
       @file[:source] = "puppet://foo/bar"
 
       @first = Puppet::FileServing::Metadata.new("/my", :relative_path => "first")
       @second = Puppet::FileServing::Metadata.new("/my", :relative_path => "second")
       @first.stubs(:ftype).returns "directory"
       @second.stubs(:ftype).returns "directory"
 
       @parameter = stub 'property', :metadata= => nil
       @resource = stub 'file', :[]= => nil, :parameter => @parameter
     end
 
     it "should pass its source to the :perform_recursion method" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should not recurse when the remote file is not a directory" do
       data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => ".")
       data.stubs(:ftype).returns "file"
       @file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       @file.expects(:newchild).never
       @file.recurse_remote({})
     end
 
     it "should set the source of each returned file to the searched-for URI plus the found relative path" do
       @first.expects(:source=).with File.join("puppet://foo/bar", @first.relative_path)
       @file.expects(:perform_recursion).returns [@first]
       @file.stubs(:newchild).returns @resource
       @file.recurse_remote({})
     end
 
     it "should create a new resource for any relative file paths that do not already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).with("first").returns @resource
       @file.recurse_remote({}).should == {"first" => @resource}
     end
 
     it "should not create a new resource for any relative file paths that do already have a resource" do
       @file.stubs(:perform_recursion).returns [@first]
       @file.expects(:newchild).never
       @file.recurse_remote("first" => @resource)
     end
 
     it "should set the source of each resource to the source of the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:source, File.join("puppet://foo/bar", @first.relative_path))
       @file.recurse_remote("first" => @resource)
     end
 
     # LAK:FIXME This is a bug, but I can't think of a fix for it.  Fortunately it's already
     # filed, and when it's fixed, we'll just fix the whole flow.
     it "should set the checksum type to :md5 if the remote file is a file" do
       @first.stubs(:ftype).returns "file"
       @file.stubs(:perform_recursion).returns [@first]
       @resource.stubs(:[]=)
       @resource.expects(:[]=).with(:checksum, :md5)
       @file.recurse_remote("first" => @resource)
     end
 
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       @file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
 
       @parameter.expects(:metadata=).with(@first)
 
       @file.recurse_remote("first" => @resource)
     end
 
     it "should not create a new resource for the '.' file" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.expects(:newchild).never
 
       @file.recurse_remote({})
     end
 
     it "should store the metadata in the main file's source property if the relative path is '.'" do
       @first.stubs(:relative_path).returns "."
       @file.stubs(:perform_recursion).returns [@first]
 
       @file.parameter(:source).expects(:metadata=).with @first
 
       @file.recurse_remote("first" => @resource)
     end
 
     describe "and multiple sources are provided" do
       describe "and :sourceselect is set to :first" do
         it "should create file instances for the results for the first source to return any values" do
           data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
           @file[:source] = %w{/one /two /three /four}
           @file.expects(:perform_recursion).with("/one").returns nil
           @file.expects(:perform_recursion).with("/two").returns []
           @file.expects(:perform_recursion).with("/three").returns [data]
           @file.expects(:perform_recursion).with("/four").never
           @file.expects(:newchild).with("foobar").returns @resource
           @file.recurse_remote({})
         end
       end
 
       describe "and :sourceselect is set to :all" do
         before do
           @file[:sourceselect] = :all
         end
 
         it "should return every found file that is not in a previous source" do
           klass = Puppet::FileServing::Metadata
           @file[:source] = %w{/one /two /three /four}
           @file.stubs(:newchild).returns @resource
 
           one = [klass.new("/one", :relative_path => "a")]
           @file.expects(:perform_recursion).with("/one").returns one
           @file.expects(:newchild).with("a").returns @resource
 
           two = [klass.new("/two", :relative_path => "a"), klass.new("/two", :relative_path => "b")]
           @file.expects(:perform_recursion).with("/two").returns two
           @file.expects(:newchild).with("b").returns @resource
 
           three = [klass.new("/three", :relative_path => "a"), klass.new("/three", :relative_path => "c")]
           @file.expects(:perform_recursion).with("/three").returns three
           @file.expects(:newchild).with("c").returns @resource
 
           @file.expects(:perform_recursion).with("/four").returns []
 
           @file.recurse_remote({})
         end
       end
     end
   end
 
   describe "when returning resources with :eval_generate" do
     before do
       @graph = stub 'graph', :add_edge => nil
       @catalog.stubs(:relationship_graph).returns @graph
 
       @file.catalog = @catalog
       @file[:recurse] = true
     end
 
     it "should recurse if recursion is enabled" do
       resource = stub('resource', :[] => "resource")
       @file.expects(:recurse?).returns true
       @file.expects(:recurse).returns [resource]
       @file.eval_generate.should == [resource]
     end
 
     it "should not recurse if recursion is disabled" do
       @file.expects(:recurse?).returns false
       @file.expects(:recurse).never
       @file.eval_generate.should == []
     end
 
     it "should return each resource found through recursion" do
       foo = stub 'foo', :[] => "/foo"
       bar = stub 'bar', :[] => "/bar"
       bar2 = stub 'bar2', :[] => "/bar"
 
       @file.expects(:recurse).returns [foo, bar]
 
       @file.eval_generate.should == [foo, bar]
     end
   end
 
   describe "when recursing" do
     before do
       @file[:recurse] = true
       @metadata = Puppet::FileServing::Metadata
     end
 
     describe "and a source is set" do
       before { @file[:source] = "/my/source" }
 
       it "should pass the already-discovered resources to recurse_remote" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_remote).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     describe "and a target is set" do
       before { @file[:target] = "/link/target" }
 
       it "should use recurse_link" do
         @file.stubs(:recurse_local).returns(:foo => "bar")
         @file.expects(:recurse_link).with(:foo => "bar").returns []
         @file.recurse
       end
     end
 
     it "should use recurse_local if recurse is not remote" do
       @file.expects(:recurse_local).returns({})
       @file.recurse
     end
 
     it "should not use recurse_local if recurse remote" do
       @file[:recurse] = :remote
       @file.expects(:recurse_local).never
       @file.recurse
     end
 
     it "should return the generated resources as an array sorted by file path" do
       one = stub 'one', :[] => "/one"
       two = stub 'two', :[] => "/one/two"
       three = stub 'three', :[] => "/three"
       @file.expects(:recurse_local).returns(:one => one, :two => two, :three => three)
       @file.recurse.should == [one, two, three]
     end
 
     describe "and purging is enabled" do
       before do
         @file[:purge] = true
       end
 
       it "should configure each file to be removed" do
         local = stub 'local'
         local.stubs(:[]).with(:source).returns nil # Thus, a local file
         local.stubs(:[]).with(:path).returns "foo"
         @file.expects(:recurse_local).returns("local" => local)
         local.expects(:[]=).with(:ensure, :absent)
 
         @file.recurse
       end
 
       it "should not remove files that exist in the remote repository" do
         @file["source"] = "/my/file"
         @file.expects(:recurse_local).returns({})
 
         remote = stub 'remote'
         remote.stubs(:[]).with(:source).returns "/whatever" # Thus, a remote file
         remote.stubs(:[]).with(:path).returns "foo"
 
         @file.expects(:recurse_remote).with { |hash| hash["remote"] = remote }
         remote.expects(:[]=).with(:ensure, :absent).never
 
         @file.recurse
       end
     end
 
     describe "and making a new child resource" do
       it "should not copy the parent resource's parent" do
         Puppet::Type.type(:file).expects(:new).with { |options| ! options.include?(:parent) }
         @file.newchild("my/path")
       end
 
       {:recurse => true, :target => "/foo/bar", :ensure => :present, :alias => "yay", :source => "/foo/bar"}.each do |param, value|
         it "should not pass on #{param} to the sub resource" do
           @file = Puppet::Type::File.new(:name => @path, param => value, :catalog => @catalog)
 
           @file.class.expects(:new).with { |params| params[param].nil? }
 
           @file.newchild("sub/file")
         end
       end
 
       it "should copy all of the parent resource's 'should' values that were set at initialization" do
         file = @file.class.new(:path => "/foo/bar", :owner => "root", :group => "wheel")
         @catalog.add_resource(file)
         file.class.expects(:new).with { |options| options[:owner] == "root" and options[:group] == "wheel" }
         file.newchild("my/path")
       end
 
       it "should not copy default values to the new child" do
         @file.class.expects(:new).with { |params| params[:backup].nil? }
         @file.newchild("my/path")
       end
 
       it "should not copy values to the child which were set by the source" do
         @file[:source] = "/foo/bar"
         metadata = stub 'metadata', :owner => "root", :group => "root", :mode => 0755, :ftype => "file", :checksum => "{md5}whatever"
         @file.parameter(:source).stubs(:metadata).returns metadata
 
         @file.parameter(:source).copy_source_values
 
         @file.class.expects(:new).with { |params| params[:group].nil? }
         @file.newchild("my/path")
       end
     end
   end
 
   describe "when setting the backup" do
     it "should default to 'puppet'" do
       Puppet::Type::File.new(:name => "/my/file")[:backup].should == "puppet"
     end
 
     it "should allow setting backup to 'false'" do
       (!Puppet::Type::File.new(:name => "/my/file", :backup => false)[:backup]).should be_true
     end
 
     it "should set the backup to '.puppet-bak' if it is set to true" do
       Puppet::Type::File.new(:name => "/my/file", :backup => true)[:backup].should == ".puppet-bak"
     end
 
     it "should support any other backup extension" do
       Puppet::Type::File.new(:name => "/my/file", :backup => ".bak")[:backup].should == ".bak"
     end
 
     it "should set the filebucket when backup is set to a string matching the name of a filebucket in the catalog" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file")
       catalog.add_resource file
 
       file[:backup] = "foo"
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should find filebuckets added to the catalog after the file resource was created" do
       catalog = Puppet::Resource::Catalog.new
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog.add_resource file
 
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file.bucket.should == bucket_resource.bucket
     end
 
     it "should have a nil filebucket if backup is false" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => false)
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should have a nil filebucket if backup is set to a string starting with '.'" do
       catalog = Puppet::Resource::Catalog.new
       bucket_resource = Puppet::Type.type(:filebucket).new :name => "foo", :path => "/my/file/bucket"
       catalog.add_resource bucket_resource
 
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       catalog.add_resource file
 
       file.bucket.should be_nil
     end
 
     it "should fail if there's no catalog and backup is not false" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should fail if a non-existent catalog is specified" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "foo")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource file
 
       lambda { file.bucket }.should raise_error(Puppet::Error)
     end
 
     it "should be able to use the default filebucket without a catalog" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => "puppet")
       file.bucket.should be_instance_of(Puppet::FileBucket::Dipper)
     end
 
     it "should look up the filebucket during finish()" do
       file = Puppet::Type::File.new(:name => "/my/file", :backup => ".foo")
       file.expects(:bucket)
       file.finish
     end
   end
 
   describe "when retrieving the current file state" do
     it "should copy the source values if the 'source' parameter is set" do
       file = Puppet::Type::File.new(:name => "/my/file", :source => "/foo/bar")
       file.parameter(:source).expects(:copy_source_values)
       file.retrieve
     end
   end
 
   describe ".title_patterns" do
     before do
       @type_class = Puppet::Type.type(:file)
     end
     
     it "should have a regexp that captures the entire string, except for a terminating slash" do
       patterns = @type_class.title_patterns
       string = "abc/\n\tdef/"
       patterns[0][0] =~ string
       $1.should == "abc/\n\tdef"
     end
   end
 
 end