diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 73a4ad8aa..6864aa1a9 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -1,114 +1,115 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
 require 'puppet/parser/files'
+require 'erb'
 
 class Puppet::Parser::TemplateWrapper
   attr_writer :scope
   attr_reader :file
   attr_accessor :string
   include Puppet::Util
   Puppet::Util.logmethods(self)
 
   def initialize(scope)
     @__scope__ = scope
   end
 
   def scope
     @__scope__
   end
 
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
     if scope.lookupvar(name.to_s, false) != :undefined
       true
     else
       false
     end
   end
 
   # Allow templates to access the defined classes
   def classes
     scope.catalog.classes
   end
 
   # Allow templates to access the tags defined in the current scope
   def tags
     scope.tags
   end
 
   # Allow templates to access the all the defined tags
   def all_tags
     scope.catalog.tags
   end
 
   # Ruby treats variables like methods, so we used to expose variables
   # within scope to the ERB code via method_missing.  As per RedMine #1427,
   # though, this means that conflicts between methods in our inheritance
   # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
   #
   # Worse, /new/ conflicts could pop up when a new kernel or object method
   # was added to Ruby, causing templates to suddenly fail mysteriously when
   # Ruby was upgraded.
   #
   # To ensure that legacy templates using unqualified names work we retain
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
     # We have to tell lookupvar to return :undefined to us when
     # appropriate; otherwise it converts to "".
     value = scope.lookupvar(name.to_s, false)
     if value != :undefined
       return value
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
       raise Puppet::ParseError, "Could not find value for '#{name}'"
     end
   end
 
   def file=(filename)
     unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment.to_s)
       raise Puppet::ParseError, "Could not find template '#{filename}'"
     end
 
     # We'll only ever not have a parser in testing, but, eh.
     scope.known_resource_types.watch_file(file)
 
     @string = File.read(file)
   end
 
   def result(string = nil)
     if string
       self.string = string
       template_source = "inline template"
     else
       template_source = file
     end
 
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
     benchmark(:debug, "Bound template variables for #{template_source}") do
       scope.to_hash.each { |name, value|
         if name.kind_of?(String)
           realname = name.gsub(/[^\w]/, "_")
         else
           realname = name
         end
         instance_variable_set("@#{realname}", value)
       }
     end
 
     result = nil
     benchmark(:debug, "Interpolated template #{template_source}") do
       template = ERB.new(self.string, 0, "-")
       result = template.result(binding)
     end
 
     result
   end
 
   def to_s
     "template[#{(file ? file : "inline")}]"
   end
 end
diff --git a/spec/integration/defaults_spec.rb b/spec/integration/defaults_spec.rb
index 1f90c7cbc..2f30014e8 100755
--- a/spec/integration/defaults_spec.rb
+++ b/spec/integration/defaults_spec.rb
@@ -1,258 +1,259 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/defaults'
+require 'puppet/rails'
 
 describe "Puppet defaults" do
     include Puppet::Util::Execution
   after { Puppet.settings.clear }
 
   describe "when setting the :factpath" do
     it "should add the :factpath to Facter's search paths" do
       Facter.expects(:search).with("/my/fact/path")
 
       Puppet.settings[:factpath] = "/my/fact/path"
     end
   end
 
   describe "when setting the :certname" do
     it "should fail if the certname is not downcased" do
       lambda { Puppet.settings[:certname] = "Host.Domain.Com" }.should raise_error(ArgumentError)
     end
   end
 
   describe "when configuring the :crl" do
     it "should warn if :cacrl is set to false" do
       Puppet.expects(:warning)
       Puppet.settings[:cacrl] = 'false'
     end
   end
 
   describe "when setting the :catalog_format" do
     it "should log a deprecation notice" do
       Puppet.expects(:warning)
       Puppet.settings[:catalog_format] = 'marshal'
     end
     it "should copy the value to :preferred_serialization_format" do
       Puppet.settings[:catalog_format] = 'marshal'
       Puppet.settings[:preferred_serialization_format].should == 'marshal'
     end
   end
 
   it "should have a clientyamldir setting" do
     Puppet.settings[:clientyamldir].should_not be_nil
   end
 
   it "should have different values for the yamldir and clientyamldir" do
     Puppet.settings[:yamldir].should_not == Puppet.settings[:clientyamldir]
   end
 
   it "should have a client_datadir setting" do
     Puppet.settings[:client_datadir].should_not be_nil
   end
 
   it "should have different values for the server_datadir and client_datadir" do
     Puppet.settings[:server_datadir].should_not == Puppet.settings[:client_datadir]
   end
 
   # See #1232
   it "should not specify a user or group for the clientyamldir" do
     Puppet.settings.setting(:clientyamldir).owner.should be_nil
     Puppet.settings.setting(:clientyamldir).group.should be_nil
   end
 
   it "should use the service user and group for the yamldir" do
     Puppet.settings.stubs(:service_user_available?).returns true
     Puppet.settings.setting(:yamldir).owner.should == Puppet.settings[:user]
     Puppet.settings.setting(:yamldir).group.should == Puppet.settings[:group]
   end
 
   # See #1232
   it "should not specify a user or group for the rundir" do
     Puppet.settings.setting(:rundir).owner.should be_nil
     Puppet.settings.setting(:rundir).group.should be_nil
   end
 
   it "should specify that the host private key should be owned by the service user" do
     Puppet.settings.stubs(:service_user_available?).returns true
     Puppet.settings.setting(:hostprivkey).owner.should == Puppet.settings[:user]
   end
 
   it "should specify that the host certificate should be owned by the service user" do
     Puppet.settings.stubs(:service_user_available?).returns true
     Puppet.settings.setting(:hostcert).owner.should == Puppet.settings[:user]
   end
 
   it "should use a bind address of ''" do
     Puppet.settings.clear
     Puppet.settings[:bindaddress].should == ""
   end
 
   [:factdest].each do |setting|
     it "should force the :factdest to be a directory" do
       Puppet.settings[setting].should =~ /\/$/
     end
   end
 
   [:modulepath, :factpath].each do |setting|
     it "should configure '#{setting}' not to be a file setting, so multi-directory settings are acceptable" do
       Puppet.settings.setting(setting).should be_instance_of(Puppet::Util::Settings::Setting)
     end
   end
 
   it "should add /usr/sbin and /sbin to the path if they're not there" do
     withenv("PATH" => "/usr/bin:/usr/local/bin") do
       Puppet.settings[:path] = "none" # this causes it to ignore the setting
       ENV["PATH"].split(File::PATH_SEPARATOR).should be_include("/usr/sbin")
       ENV["PATH"].split(File::PATH_SEPARATOR).should be_include("/sbin")
     end
   end
 
   it "should default to pson for the preferred serialization format" do
     Puppet.settings.value(:preferred_serialization_format).should == "pson"
   end
 
   describe "when enabling storeconfigs" do
     before do
       Puppet::Resource::Catalog.stubs(:cache_class=)
       Puppet::Node::Facts.stubs(:cache_class=)
       Puppet::Node.stubs(:cache_class=)
 
       Puppet.features.stubs(:rails?).returns true
     end
 
     it "should set the Catalog cache class to :active_record" do
       Puppet::Resource::Catalog.expects(:cache_class=).with(:active_record)
       Puppet.settings[:storeconfigs] = true
     end
 
     it "should not set the Catalog cache class to :active_record if asynchronous storeconfigs is enabled" do
       Puppet::Resource::Catalog.expects(:cache_class=).with(:active_record).never
       Puppet.settings.expects(:value).with(:async_storeconfigs).returns true
       Puppet.settings[:storeconfigs] = true
     end
 
     it "should set the Facts cache class to :active_record" do
       Puppet::Node::Facts.expects(:cache_class=).with(:active_record)
       Puppet.settings[:storeconfigs] = true
     end
 
     it "should set the Node cache class to :active_record" do
       Puppet::Node.expects(:cache_class=).with(:active_record)
       Puppet.settings[:storeconfigs] = true
     end
 
     it "should fail if rails is not available" do
       Puppet.features.stubs(:rails?).returns false
       lambda { Puppet.settings[:storeconfigs] = true }.should raise_error
     end
   end
 
   describe "when enabling asynchronous storeconfigs" do
     before do
       Puppet::Resource::Catalog.stubs(:cache_class=)
       Puppet::Node::Facts.stubs(:cache_class=)
       Puppet::Node.stubs(:cache_class=)
       Puppet.features.stubs(:rails?).returns true
     end
 
     it "should set storeconfigs to true" do
       Puppet.settings[:async_storeconfigs] = true
       Puppet.settings[:storeconfigs].should be_true
     end
 
     it "should set the Catalog cache class to :queue" do
       Puppet::Resource::Catalog.expects(:cache_class=).with(:queue)
       Puppet.settings[:async_storeconfigs] = true
     end
 
     it "should set the Facts cache class to :active_record" do
       Puppet::Node::Facts.expects(:cache_class=).with(:active_record)
       Puppet.settings[:storeconfigs] = true
     end
 
     it "should set the Node cache class to :active_record" do
       Puppet::Node.expects(:cache_class=).with(:active_record)
       Puppet.settings[:storeconfigs] = true
     end
   end
 
   describe "when enabling thin storeconfigs" do
     before do
       Puppet::Resource::Catalog.stubs(:cache_class=)
       Puppet::Node::Facts.stubs(:cache_class=)
       Puppet::Node.stubs(:cache_class=)
       Puppet.features.stubs(:rails?).returns true
     end
 
     it "should set storeconfigs to true" do
       Puppet.settings[:thin_storeconfigs] = true
       Puppet.settings[:storeconfigs].should be_true
     end
   end
 
   it "should have a setting for determining the configuration version and should default to an empty string" do
     Puppet.settings[:config_version].should == ""
   end
 
   describe "when enabling reports" do
     it "should use the default server value when report server is unspecified" do
       Puppet.settings[:server] = "server"
       Puppet.settings[:report_server].should == "server"
     end
 
     it "should use the default masterport value when report port is unspecified" do
       Puppet.settings[:masterport] = "1234"
       Puppet.settings[:report_port].should == "1234"
     end
 
     it "should set report_server when reportserver is set" do
       Puppet.settings[:reportserver] = "reportserver"
       Puppet.settings[:report_server].should == "reportserver"
     end
 
     it "should use report_port when set" do
       Puppet.settings[:masterport] = "1234"
       Puppet.settings[:report_port] = "5678"
       Puppet.settings[:report_port].should == "5678"
     end
 
     it "should prefer report_server over reportserver" do
       Puppet.settings[:reportserver] = "reportserver"
       Puppet.settings[:report_server] = "report_server"
       Puppet.settings[:report_server].should == "report_server"
     end
   end
 
   it "should have a :caname setting that defaults to the cert name" do
     Puppet.settings[:certname] = "foo"
     Puppet.settings[:ca_name].should == "Puppet CA: foo"
   end
 
   it "should have a 'prerun_command' that defaults to the empty string" do
     Puppet.settings[:prerun_command].should == ""
   end
 
   it "should have a 'postrun_command' that defaults to the empty string" do
     Puppet.settings[:postrun_command].should == ""
   end
 
   it "should have a 'certificate_revocation' setting that defaults to true" do
     Puppet.settings[:certificate_revocation].should be_true
   end
 
   it "should have an http_compression setting that defaults to false" do
     Puppet.settings[:http_compression].should be_false
   end
 
   describe "reportdir" do
     subject { Puppet.settings[:reportdir] }
     it { should == "#{Puppet[:vardir]}/reports" }
   end
 
   describe "reporturl" do
     subject { Puppet.settings[:reporturl] }
     it { should == "http://localhost:3000/reports" }
   end
 end
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 54726c185..ff504eedf 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -1,588 +1,589 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/agent'
 require 'puppet/application/agent'
 require 'puppet/network/server'
+require 'puppet/network/handler'
 require 'puppet/daemon'
 
 describe Puppet::Application::Agent do
   before :each do
     @puppetd = Puppet::Application[:agent]
     @puppetd.stubs(:puts)
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     @agent = stub_everything 'agent'
     Puppet::Agent.stubs(:new).returns(@agent)
     @puppetd.preinit
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.stubs(:terminus_class=)
     Puppet::Node.stubs(:cache_class=)
     Puppet::Node::Facts.stubs(:terminus_class=)
   end
 
   it "should operate in agent run_mode" do
     @puppetd.class.run_mode.name.should == :agent
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @puppetd.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @puppetd.should respond_to(:main)
   end
 
   it "should declare a onetime command" do
     @puppetd.should respond_to(:onetime)
   end
 
   it "should declare a fingerprint command" do
     @puppetd.should respond_to(:fingerprint)
   end
 
   it "should declare a preinit block" do
     @puppetd.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     before :each do
       @puppetd.stubs(:trap)
     end
 
     it "should catch INT" do
       @puppetd.expects(:trap).with { |arg,block| arg == :INT }
 
       @puppetd.preinit
     end
 
     it "should init client to true" do
       @puppetd.preinit
 
       @puppetd.options[:client].should be_true
     end
 
     it "should init fqdn to nil" do
       @puppetd.preinit
 
       @puppetd.options[:fqdn].should be_nil
     end
 
     it "should init serve to []" do
       @puppetd.preinit
 
       @puppetd.options[:serve].should == []
     end
 
     it "should use MD5 as default digest algorithm" do
       @puppetd.preinit
 
       @puppetd.options[:digest].should == :MD5
     end
 
     it "should not fingerprint by default" do
       @puppetd.preinit
 
       @puppetd.options[:fingerprint].should be_false
     end
   end
 
   describe "when handling options" do
     before do
       @puppetd.command_line.stubs(:args).returns([])
     end
 
     [:centrallogging, :disable, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
         @puppetd.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @puppetd.options.expects(:[]=).with(option, 'arg')
         @puppetd.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set an existing handler on server" do
       Puppet::Network::Handler.stubs(:handler).with("handler").returns(true)
 
       @puppetd.handle_serve("handler")
       @puppetd.options[:serve].should == [ :handler ]
     end
 
     it "should set client to false with --no-client" do
       @puppetd.handle_no_client(nil)
       @puppetd.options[:client].should be_false
     end
 
     it "should set waitforcert to 0 with --onetime and if --waitforcert wasn't given" do
       Puppet[:onetime] = true
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(0)
       @puppetd.setup_host
     end
 
     it "should use supplied waitforcert when --onetime is specified" do
       Puppet[:onetime] = true
       @puppetd.handle_waitforcert(60)
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(60)
       @puppetd.setup_host
     end
 
     it "should use a default value for waitforcert when --onetime and --waitforcert are not specified" do
       Puppet::SSL::Host.any_instance.expects(:wait_for_cert).with(120)
       @puppetd.setup_host
     end
 
     it "should set the log destination with --logdest" do
       @puppetd.options.stubs(:[]=).with { |opt,val| opt == :setdest }
       Puppet::Log.expects(:newdestination).with("console")
 
       @puppetd.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
       @puppetd.options.expects(:[]=).with(:setdest,true)
 
       @puppetd.handle_logdest("console")
     end
 
     it "should parse the log destination from the command line" do
       @puppetd.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
       Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @puppetd.parse_options
     end
 
     it "should store the waitforcert options with --waitforcert" do
       @puppetd.options.expects(:[]=).with(:waitforcert,42)
 
       @puppetd.handle_waitforcert("42")
     end
 
     it "should set args[:Port] with --port" do
       @puppetd.handle_port("42")
       @puppetd.args[:Port].should == "42"
     end
 
   end
 
   describe "during setup" do
     before :each do
       @puppetd.options.stubs(:[])
       Puppet.stubs(:info)
       FileTest.stubs(:exists?).returns(true)
       Puppet.stubs(:[])
       Puppet.stubs(:[]=)
       Puppet.stubs(:[]).with(:libdir).returns("/dev/null/lib")
       Puppet.settings.stubs(:print_config?)
       Puppet.settings.stubs(:print_config)
       Puppet::SSL::Host.stubs(:ca_location=)
       Puppet::Transaction::Report.stubs(:terminus_class=)
       Puppet::Resource::Catalog.stubs(:terminus_class=)
       Puppet::Resource::Catalog.stubs(:cache_class=)
       Puppet::Node::Facts.stubs(:terminus_class=)
       @host = stub_everything 'host'
       Puppet::SSL::Host.stubs(:new).returns(@host)
       Puppet.stubs(:settraps)
     end
 
     describe "with --test" do
       before :each do
         Puppet.settings.stubs(:handlearg)
         @puppetd.options.stubs(:[]=)
       end
 
       it "should call setup_test" do
         @puppetd.options.stubs(:[]).with(:test).returns(true)
         @puppetd.expects(:setup_test)
         @puppetd.setup
       end
 
       it "should set options[:verbose] to true" do
         @puppetd.options.expects(:[]=).with(:verbose,true)
         @puppetd.setup_test
       end
       it "should set options[:onetime] to true" do
         Puppet.expects(:[]=).with(:onetime,true)
         @puppetd.setup_test
       end
       it "should set options[:detailed_exitcodes] to true" do
         @puppetd.options.expects(:[]=).with(:detailed_exitcodes,true)
         @puppetd.setup_test
       end
     end
 
     it "should call setup_logs" do
       @puppetd.expects(:setup_logs)
       @puppetd.setup
     end
 
     describe "when setting up logs" do
       before :each do
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       it "should set log level to debug if --debug was passed" do
         @puppetd.options.stubs(:[]).with(:debug).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:debug)
 
         @puppetd.setup_logs
       end
 
       it "should set log level to info if --verbose was passed" do
         @puppetd.options.stubs(:[]).with(:verbose).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:info)
 
         @puppetd.setup_logs
       end
 
       [:verbose, :debug].each do |level|
         it "should set console as the log destination with level #{level}" do
           @puppetd.options.stubs(:[]).with(level).returns(true)
 
           Puppet::Util::Log.expects(:newdestination).with(:console)
 
           @puppetd.setup_logs
         end
       end
 
       it "should set syslog as the log destination if no --logdest" do
         @puppetd.options.stubs(:[]).with(:setdest).returns(false)
 
         Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
         @puppetd.setup_logs
       end
 
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @puppetd.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @puppetd.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @puppetd.setup }.should raise_error(SystemExit)
     end
 
     it "should set a central log destination with --centrallogs" do
       @puppetd.options.stubs(:[]).with(:centrallogs).returns(true)
       Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
       Puppet::Util::Log.stubs(:newdestination).with(:syslog)
 
       Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
 
       @puppetd.setup
     end
 
     it "should use :main, :puppetd, and :ssl" do
       Puppet.settings.expects(:use).with(:main, :agent, :ssl)
 
       @puppetd.setup
     end
 
     it "should install a remote ca location" do
       Puppet::SSL::Host.expects(:ca_location=).with(:remote)
 
       @puppetd.setup
     end
 
     it "should install a none ca location in fingerprint mode" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
       Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
       @puppetd.setup
     end
 
     it "should tell the report handler to use REST" do
       Puppet::Transaction::Report.expects(:terminus_class=).with(:rest)
 
       @puppetd.setup
     end
 
     it "should change the catalog_terminus setting to 'rest'" do
       Puppet.expects(:[]=).with(:catalog_terminus, :rest)
       @puppetd.setup
     end
 
     it "should tell the catalog handler to use cache" do
       Puppet::Resource::Catalog.expects(:cache_class=).with(:yaml)
 
       @puppetd.setup
     end
 
     it "should change the facts_terminus setting to 'facter'" do
       Puppet.expects(:[]=).with(:facts_terminus, :facter)
 
       @puppetd.setup
     end
 
     it "should create an agent" do
       Puppet::Agent.stubs(:new).with(Puppet::Configurer)
 
       @puppetd.setup
     end
 
     [:enable, :disable].each do |action|
       it "should delegate to enable_disable_client if we #{action} the agent" do
         @puppetd.options.stubs(:[]).with(action).returns(true)
         @puppetd.expects(:enable_disable_client).with(@agent)
 
         @puppetd.setup
       end
     end
 
     describe "when enabling or disabling agent" do
       [:enable, :disable].each do |action|
         it "should call client.#{action}" do
           @puppetd.stubs(:exit)
           @puppetd.options.stubs(:[]).with(action).returns(true)
 
           @agent.expects(action)
 
           @puppetd.enable_disable_client(@agent)
         end
       end
 
       it "should finally exit" do
         lambda { @puppetd.enable_disable_client(@agent) }.should raise_error(SystemExit)
       end
     end
 
     it "should inform the daemon about our agent if :client is set to 'true'" do
       @puppetd.options.expects(:[]).with(:client).returns true
       @daemon.expects(:agent=).with(@agent)
       @puppetd.setup
     end
 
     it "should not inform the daemon about our agent if :client is set to 'false'" do
       @puppetd.options[:client] = false
       @daemon.expects(:agent=).never
       @puppetd.setup
     end
 
     it "should daemonize if needed" do
       Puppet.stubs(:[]).with(:daemonize).returns(true)
 
       @daemon.expects(:daemonize)
 
       @puppetd.setup
     end
 
     it "should wait for a certificate" do
       @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).with(123)
 
       @puppetd.setup
     end
 
     it "should not wait for a certificate in fingerprint mode" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
       @puppetd.options.stubs(:[]).with(:waitforcert).returns(123)
       @host.expects(:wait_for_cert).never
 
       @puppetd.setup
     end
 
     it "should setup listen if told to and not onetime" do
       Puppet.stubs(:[]).with(:listen).returns(true)
       @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
       @puppetd.expects(:setup_listen)
 
       @puppetd.setup
     end
 
     describe "when setting up listen" do
       before :each do
         Puppet.stubs(:[]).with(:authconfig).returns('auth')
         FileTest.stubs(:exists?).with('auth').returns(true)
         File.stubs(:exist?).returns(true)
         @puppetd.options.stubs(:[]).with(:serve).returns([])
         @puppetd.stubs(:exit)
         @server = stub_everything 'server'
         Puppet::Network::Server.stubs(:new).returns(@server)
       end
 
 
       it "should exit if no authorization file" do
         Puppet.stubs(:err)
         FileTest.stubs(:exists?).with('auth').returns(false)
 
         @puppetd.expects(:exit)
 
         @puppetd.setup_listen
       end
 
       it "should create a server to listen on at least the Runner handler" do
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Runner] }
 
         @puppetd.setup_listen
       end
 
       it "should create a server to listen for specific handlers" do
         @puppetd.options.stubs(:[]).with(:serve).returns([:handler])
         Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:handler] }
 
         @puppetd.setup_listen
       end
 
       it "should use puppet default port" do
         Puppet.stubs(:[]).with(:puppetport).returns(:port)
 
         Puppet::Network::Server.expects(:new).with { |args| args[:port] == :port }
 
         @puppetd.setup_listen
       end
     end
   end
 
 
   describe "when running" do
     before :each do
       @puppetd.agent = @agent
       @puppetd.daemon = @daemon
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(false)
     end
 
     it "should dispatch to fingerprint if --fingerprint is used" do
       @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
 
       @puppetd.stubs(:fingerprint)
       @puppetd.run_command
     end
 
     it "should dispatch to onetime if --onetime is used" do
       @puppetd.options.stubs(:[]).with(:onetime).returns(true)
 
       @puppetd.stubs(:onetime)
       @puppetd.run_command
     end
 
     it "should dispatch to main if --onetime and --fingerprint are not used" do
       @puppetd.options.stubs(:[]).with(:onetime).returns(false)
 
       @puppetd.stubs(:main)
       @puppetd.run_command
     end
 
     describe "with --onetime" do
 
       before :each do
         @agent.stubs(:run).returns(:report)
         @puppetd.options.stubs(:[]).with(:client).returns(:client)
         @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
         @puppetd.stubs(:exit).with(0)
         Puppet.stubs(:newservice)
       end
 
       it "should exit if no defined --client" do
         $stderr.stubs(:puts)
         @puppetd.options.stubs(:[]).with(:client).returns(nil)
 
         @puppetd.expects(:exit).with(43)
 
         @puppetd.onetime
       end
 
       it "should setup traps" do
         @daemon.expects(:set_signal_traps)
 
         @puppetd.onetime
       end
 
       it "should let the agent run" do
         @agent.expects(:run).returns(:report)
 
         @puppetd.onetime
       end
 
       it "should finish by exiting with 0 error code" do
         @puppetd.expects(:exit).with(0)
 
         @puppetd.onetime
       end
 
       describe "and --detailed-exitcodes" do
         before :each do
           @puppetd.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
         end
 
         it "should exit with report's computed exit status" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end
 
         it "should always exit with 0 if --noop" do
           Puppet.stubs(:[]).with(:noop).returns(true)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
           @puppetd.expects(:exit).with(0)
 
           @puppetd.onetime
         end
       end
     end
 
     describe "with --fingerprint" do
       before :each do
         @cert = stub_everything 'cert'
         @puppetd.options.stubs(:[]).with(:fingerprint).returns(true)
         @puppetd.options.stubs(:[]).with(:digest).returns(:MD5)
         @host = stub_everything 'host'
         @puppetd.stubs(:host).returns(@host)
       end
 
       it "should fingerprint the certificate if it exists" do
         @host.expects(:certificate).returns(@cert)
         @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should fingerprint the certificate request if no certificate have been signed" do
         @host.expects(:certificate).returns(nil)
         @host.expects(:certificate_request).returns(@cert)
         @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should display the fingerprint" do
         @host.stubs(:certificate).returns(@cert)
         @cert.stubs(:fingerprint).with(:MD5).returns("DIGEST")
 
         Puppet.expects(:notice).with("DIGEST")
 
         @puppetd.fingerprint
       end
     end
 
     describe "without --onetime and --fingerprint" do
       before :each do
         Puppet.stubs(:notice)
         @puppetd.options.stubs(:[]).with(:client)
       end
 
       it "should start our daemon" do
         @daemon.expects(:start)
 
         @puppetd.main
       end
     end
   end
 end
diff --git a/spec/unit/application/filebucket_spec.rb b/spec/unit/application/filebucket_spec.rb
index 6e7a7b819..e6272f179 100644
--- a/spec/unit/application/filebucket_spec.rb
+++ b/spec/unit/application/filebucket_spec.rb
@@ -1,223 +1,224 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/filebucket'
+require 'puppet/file_bucket/dipper'
 
 describe Puppet::Application::Filebucket do
   before :each do
     @filebucket = Puppet::Application[:filebucket]
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
     @filebucket.should_parse_config?.should be_false
   end
 
   it "should declare a get command" do
     @filebucket.should respond_to(:get)
   end
 
   it "should declare a backup command" do
     @filebucket.should respond_to(:backup)
   end
 
   it "should declare a restore command" do
     @filebucket.should respond_to(:restore)
   end
 
   [:bucket, :debug, :local, :remote, :verbose].each do |option|
     it "should declare handle_#{option} method" do
       @filebucket.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @filebucket.options.expects(:[]=).with("#{option}".to_sym, 'arg')
       @filebucket.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @filebucket.setup
     end
 
     it "should trap INT" do
       @filebucket.expects(:trap).with(:INT)
 
       @filebucket.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @filebucket.options.stubs(:[]).with(:debug).returns(true)
 
       Puppet::Log.expects(:level=).with(:debug)
 
       @filebucket.setup
     end
 
     it "should set log level to info if --verbose was passed" do
       @filebucket.options.stubs(:[]).with(:verbose).returns(true)
 
       Puppet::Log.expects(:level=).with(:info)
 
       @filebucket.setup
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
       @filebucket.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @filebucket.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @filebucket.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @filebucket.setup }.should raise_error(SystemExit)
     end
 
     describe "with local bucket" do
 
       before :each do
         @filebucket.options.stubs(:[]).with(:local).returns(true)
       end
 
       it "should create a client with the default bucket if none passed" do
         Puppet.stubs(:[]).with(:bucketdir).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
       it "should create a local Dipper with the given bucket" do
         @filebucket.options.stubs(:[]).with(:bucket).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
     end
 
     describe "with remote bucket" do
 
       it "should create a remote Client to the configured server" do
         Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "puppet.reductivelabs.com" }
 
         @filebucket.setup
       end
 
     end
 
   end
 
   describe "when running" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
 
       @client = stub 'client'
       Puppet::FileBucket::Dipper.stubs(:new).returns(@client)
 
       @filebucket.setup
     end
 
     it "should use the first non-option parameter as the dispatch" do
       @filebucket.command_line.stubs(:args).returns(['get'])
 
       @filebucket.expects(:get)
 
       @filebucket.run_command
     end
 
     describe "the command get" do
 
       before :each do
         @filebucket.stubs(:print)
         @filebucket.stubs(:args).returns([])
       end
 
       it "should call the client getfile method" do
         @client.expects(:getfile)
 
         @filebucket.get
       end
 
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         @filebucket.stubs(:args).returns([md5])
 
         @client.expects(:getfile).with(md5)
 
         @filebucket.get
       end
 
       it "should print the file content" do
         @client.stubs(:getfile).returns("content")
 
         @filebucket.expects(:print).returns("content")
 
         @filebucket.get
       end
 
     end
 
     describe "the command backup" do
       it "should call the client backup method for each given parameter" do
         @filebucket.stubs(:puts)
         FileTest.stubs(:exists?).returns(true)
         FileTest.stubs(:readable?).returns(true)
         @filebucket.stubs(:args).returns(["file1", "file2"])
 
         @client.expects(:backup).with("file1")
         @client.expects(:backup).with("file2")
 
         @filebucket.backup
       end
     end
 
     describe "the command restore" do
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         file="testfile"
         @filebucket.stubs(:args).returns([file, md5])
 
         @client.expects(:restore).with(file,md5)
 
         @filebucket.restore
       end
     end
 
   end
 
 
 end
diff --git a/spec/unit/application/queue_spec.rb b/spec/unit/application/queue_spec.rb
index 87c96dfff..bd0d53ab1 100755
--- a/spec/unit/application/queue_spec.rb
+++ b/spec/unit/application/queue_spec.rb
@@ -1,186 +1,187 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/queue'
+require 'puppet/indirector/catalog/queue'
 
 describe Puppet::Application::Queue do
   before :each do
     @queue = Puppet::Application[:queue]
     @queue.stubs(:puts)
     @daemon = stub_everything 'daemon', :daemonize => nil
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Util::Log.stubs(:level=)
 
     Puppet::Resource::Catalog.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to parse Puppet configuration file" do
     @queue.should_parse_config?.should be_true
   end
 
   it "should declare a main command" do
     @queue.should respond_to(:main)
   end
 
   it "should declare a preinit block" do
     @queue.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     before :each do
       @queue.stubs(:trap)
     end
 
     it "should catch INT" do
       @queue.expects(:trap).with { |arg,block| arg == :INT }
 
       @queue.preinit
     end
 
     it "should init :verbose to false" do
       @queue.preinit
 
       @queue.options[:verbose].should be_false
     end
 
     it "should init :debug to false" do
       @queue.preinit
 
       @queue.options[:debug].should be_false
     end
 
     it "should create a Daemon instance and copy ARGV to it" do
       ARGV.expects(:dup).returns "eh"
       daemon = mock("daemon")
       daemon.expects(:argv=).with("eh")
       Puppet::Daemon.expects(:new).returns daemon
       @queue.preinit
     end
   end
 
   describe "when handling options" do
 
     [:debug, :verbose].each do |option|
       it "should declare handle_#{option} method" do
         @queue.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @queue.options.expects(:[]=).with(option, 'arg')
         @queue.send("handle_#{option}".to_sym, 'arg')
       end
     end
   end
 
   describe "during setup" do
     before :each do
       @queue.options.stubs(:[])
       @queue.daemon.stubs(:daemonize)
       Puppet.stubs(:info)
       Puppet.features.stubs(:stomp?).returns true
       Puppet::Resource::Catalog.stubs(:terminus_class=)
       Puppet.stubs(:settraps)
       Puppet.settings.stubs(:print_config?)
       Puppet.settings.stubs(:print_config)
     end
 
     it "should fail if the stomp feature is missing" do
       Puppet.features.expects(:stomp?).returns false
       lambda { @queue.setup }.should raise_error(ArgumentError)
     end
 
     it "should print puppet config if asked to in Puppet config" do
       @queue.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       Puppet.settings.expects(:print_configs)
 
       @queue.setup
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
 
       lambda { @queue.setup }.should raise_error(SystemExit)
     end
 
     it "should call setup_logs" do
       @queue.expects(:setup_logs)
       @queue.setup
     end
 
     describe "when setting up logs" do
       before :each do
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       it "should set log level to debug if --debug was passed" do
         @queue.options.stubs(:[]).with(:debug).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:debug)
 
         @queue.setup_logs
       end
 
       it "should set log level to info if --verbose was passed" do
         @queue.options.stubs(:[]).with(:verbose).returns(true)
 
         Puppet::Util::Log.expects(:level=).with(:info)
 
         @queue.setup_logs
       end
 
       [:verbose, :debug].each do |level|
         it "should set console as the log destination with level #{level}" do
           @queue.options.stubs(:[]).with(level).returns(true)
 
           Puppet::Util::Log.expects(:newdestination).with(:console)
 
           @queue.setup_logs
         end
       end
     end
 
     it "should configure the Catalog class to use ActiveRecord" do
       Puppet::Resource::Catalog.expects(:terminus_class=).with(:active_record)
 
       @queue.setup
     end
 
     it "should daemonize if needed" do
       Puppet.expects(:[]).with(:daemonize).returns(true)
 
       @queue.daemon.expects(:daemonize)
 
       @queue.setup
     end
   end
 
   describe "when running" do
     before :each do
       @queue.stubs(:sleep_forever)
       Puppet::Resource::Catalog::Queue.stubs(:subscribe)
       Thread.list.each { |t| t.stubs(:join) }
     end
 
     it "should subscribe to the queue" do
       Puppet::Resource::Catalog::Queue.expects(:subscribe)
       @queue.main
     end
 
     it "should log and save each catalog passed by the queue" do
       catalog = mock 'catalog', :name => 'eh'
       catalog.expects(:save)
 
       Puppet::Resource::Catalog::Queue.expects(:subscribe).yields(catalog)
       Puppet.expects(:notice).times(2)
       @queue.main
     end
 
     it "should join all of the running threads" do
       Thread.list.each { |t| t.expects(:join) }
       @queue.main
     end
   end
 end
diff --git a/spec/unit/indirector/active_record_spec.rb b/spec/unit/indirector/active_record_spec.rb
index 258c4e793..40af146c8 100755
--- a/spec/unit/indirector/active_record_spec.rb
+++ b/spec/unit/indirector/active_record_spec.rb
@@ -1,76 +1,77 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
+require 'puppet/rails'
 require 'puppet/indirector/active_record'
 
 describe Puppet::Indirector::ActiveRecord do
   before do
     Puppet::Rails.stubs(:init)
 
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @model = mock 'model'
     @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
     Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
     @active_record_class = Class.new(Puppet::Indirector::ActiveRecord) do
       def self.to_s
         "Mystuff::Testing"
       end
     end
 
     @ar_model = mock 'ar_model'
 
     @active_record_class.use_ar_model @ar_model
     @terminus = @active_record_class.new
 
     @name = "me"
     @instance = stub 'instance', :name => @name
 
     @request = stub 'request', :key => @name, :instance => @instance
   end
 
   it "should allow declaration of an ActiveRecord model to use" do
     @active_record_class.use_ar_model "foo"
     @active_record_class.ar_model.should == "foo"
   end
 
   describe "when initializing" do
     it "should init Rails" do
       Puppet::Rails.expects(:init)
       @active_record_class.new
     end
   end
 
   describe "when finding an instance" do
     it "should use the ActiveRecord model to find the instance" do
       @ar_model.expects(:find_by_name).with(@name)
 
       @terminus.find(@request)
     end
 
     it "should return nil if no instance is found" do
       @ar_model.expects(:find_by_name).with(@name).returns nil
       @terminus.find(@request).should be_nil
     end
 
     it "should convert the instance to a Puppet object if it is found" do
       instance = mock 'rails_instance'
       instance.expects(:to_puppet).returns "mypuppet"
 
       @ar_model.expects(:find_by_name).with(@name).returns instance
       @terminus.find(@request).should == "mypuppet"
     end
   end
 
   describe "when saving an instance" do
     it "should use the ActiveRecord model to convert the instance into a Rails object and then save that rails object" do
       rails_object = mock 'rails_object'
       @ar_model.expects(:from_puppet).with(@instance).returns rails_object
 
       rails_object.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/catalog/active_record_spec.rb b/spec/unit/indirector/catalog/active_record_spec.rb
index df61d59d7..ba8f1dad9 100755
--- a/spec/unit/indirector/catalog/active_record_spec.rb
+++ b/spec/unit/indirector/catalog/active_record_spec.rb
@@ -1,156 +1,159 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 
 describe "Puppet::Resource::Catalog::ActiveRecord" do
   confine "Missing Rails" => Puppet.features.rails?
 
   require 'puppet/rails'
-  class Tableless < ActiveRecord::Base
-    def self.columns
-      @columns ||= []
-    end
-    def self.column(name, sql_type=nil, default=nil, null=true)
-      columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+
+  before :all do
+    class Tableless < ActiveRecord::Base
+      def self.columns
+        @columns ||= []
+      end
+      def self.column(name, sql_type=nil, default=nil, null=true)
+        columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+      end
     end
-  end
 
-  class Host < Tableless
-    column :name, :string, :null => false
-    column :ip, :string
-    column :environment, :string
-    column :last_compile, :datetime
+    class Host < Tableless
+      column :name, :string, :null => false
+      column :ip, :string
+      column :environment, :string
+      column :last_compile, :datetime
+    end
   end
 
   before do
     require 'puppet/indirector/catalog/active_record'
     Puppet.features.stubs(:rails?).returns true
     Puppet::Rails.stubs(:init)
     @terminus = Puppet::Resource::Catalog::ActiveRecord.new
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   describe "when finding an instance" do
     before do
       @request = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
     end
 
     # This hack is here because we don't want to look in the db unless we actually want
     # to look in the db, but our indirection architecture in 0.24.x isn't flexible
     # enough to tune that via configuration.
     it "should return nil unless ':cache_integration_hack' is set to true" do
       @request.options[:cache_integration_hack] = false
       Puppet::Rails::Host.expects(:find_by_name).never
       @terminus.find(@request).should be_nil
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
       @terminus.find(@request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
       @terminus.find(@request).should be_nil
     end
 
     it "should return a catalog with the same name as the host if the host can be found" do
       host = stub 'host', :name => "foo", :resources => []
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       result = @terminus.find(@request)
       result.should be_instance_of(Puppet::Resource::Catalog)
       result.name.should == "foo"
     end
 
     it "should set each of the host's resources as a transportable resource within the catalog" do
       host = stub 'host', :name => "foo"
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       res1 = mock 'res1', :to_transportable => "trans_res1"
       res2 = mock 'res2', :to_transportable => "trans_res2"
 
       host.expects(:resources).returns [res1, res2]
 
       catalog = stub 'catalog'
       Puppet::Resource::Catalog.expects(:new).returns catalog
 
       catalog.expects(:add_resource).with "trans_res1"
       catalog.expects(:add_resource).with "trans_res2"
 
       @terminus.find(@request)
     end
   end
 
   describe "when saving an instance" do
     before do
       @host = Host.new(:name => "foo")
       @host.stubs(:merge_resources)
       @host.stubs(:save)
       @host.stubs(:railsmark).yields
 
       @node = Puppet::Node.new("foo", :environment => "environment")
       Puppet::Node.indirection.stubs(:find).with("foo").returns(@node)
 
       Puppet::Rails::Host.stubs(:find_by_name).returns @host
       @catalog = Puppet::Resource::Catalog.new("foo")
       @request = Puppet::Indirector::Request.new(:active_record, :save, @catalog)
     end
 
     it "should find the Rails host with the same name" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should create a new Rails host if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
 
       Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should set the catalog vertices as resources on the Rails host instance" do
       @catalog.expects(:vertices).returns "foo"
       @host.expects(:merge_resources).with("foo")
 
       @terminus.save(@request)
     end
 
     it "should set host ip if we could find a matching node" do
       @node.stubs(:parameters).returns({"ipaddress" => "192.168.0.1"})
 
       @terminus.save(@request)
       @host.ip.should == '192.168.0.1'
     end
 
     it "should set host environment if we could find a matching node" do
       @terminus.save(@request)
       @host.environment.should == "environment"
     end
 
     it "should set the last compile time on the host" do
       now = Time.now
       Time.expects(:now).returns now
 
       @terminus.save(@request)
       @host.last_compile.should == now
     end
 
     it "should save the Rails host instance" do
       @host.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/indirector/facts/active_record_spec.rb b/spec/unit/indirector/facts/active_record_spec.rb
index 0cdb70e01..0bdcfcb77 100755
--- a/spec/unit/indirector/facts/active_record_spec.rb
+++ b/spec/unit/indirector/facts/active_record_spec.rb
@@ -1,104 +1,105 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
+require 'puppet/rails'
 require 'puppet/node/facts'
 
 describe "Puppet::Node::Facts::ActiveRecord" do
   confine "Missing Rails" => Puppet.features.rails?
 
   before do
     require 'puppet/indirector/facts/active_record'
     Puppet.features.stubs(:rails?).returns true
     Puppet::Rails.stubs(:init)
     @terminus = Puppet::Node::Facts::ActiveRecord.new
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Node::Facts::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
 
   it "should use Puppet::Rails::Host as its ActiveRecord model" do
     Puppet::Node::Facts::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
   end
 
   describe "when finding an instance" do
     before do
       @request = stub 'request', :key => "foo"
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
       @terminus.find(@request)
     end
 
     it "should include the fact names and values when finding the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| args[:include] == {:fact_values => :fact_name} }
       @terminus.find(@request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
       @terminus.find(@request).should be_nil
     end
 
     it "should convert the node's parameters into a Facts instance if a host instance is found" do
       host = stub 'host', :name => "foo"
       host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")], "three" => [mock("three_value", :value => "four")])
 
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       result = @terminus.find(@request)
 
       result.should be_instance_of(Puppet::Node::Facts)
       result.name.should == "foo"
       result.values.should == {"one" => "two", "three" => "four"}
     end
 
     it "should convert all single-member arrays into non-arrays" do
       host = stub 'host', :name => "foo"
       host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")])
 
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
       @terminus.find(@request).values["one"].should == "two"
     end
   end
 
   describe "when saving an instance" do
     before do
       @host = stub 'host', :name => "foo", :save => nil, :merge_facts => nil
       Puppet::Rails::Host.stubs(:find_by_name).returns @host
       @facts = Puppet::Node::Facts.new("foo", "one" => "two", "three" => "four")
       @request = stub 'request', :key => "foo", :instance => @facts
     end
 
     it "should find the Rails host with the same name" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should create a new Rails host if none can be found" do
       Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
 
       Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
 
       @terminus.save(@request)
     end
 
     it "should set the facts as facts on the Rails host instance" do
       # There is other stuff added to the hash.
       @host.expects(:merge_facts).with { |args| args["one"] == "two" and args["three"] == "four" }
 
       @terminus.save(@request)
     end
 
     it "should save the Rails host instance" do
       @host.expects(:save)
 
       @terminus.save(@request)
     end
   end
 end
diff --git a/spec/unit/network/http/rack/xmlrpc_spec.rb b/spec/unit/network/http/rack/xmlrpc_spec.rb
index 63ba28bf2..870438f2c 100755
--- a/spec/unit/network/http/rack/xmlrpc_spec.rb
+++ b/spec/unit/network/http/rack/xmlrpc_spec.rb
@@ -1,157 +1,158 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'puppet/network/handler'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/xmlrpc' if Puppet.features.rack?
 
 describe "Puppet::Network::HTTP::RackXMLRPC" do
   confine "Rack is not available" => Puppet.features.rack?
 
   describe "when initializing" do
     it "should create an Puppet::Network::XMLRPCServer" do
       Puppet::Network::XMLRPCServer.expects(:new).returns stub_everything
       Puppet::Network::HTTP::RackXMLRPC.new([])
     end
 
     it "should create each handler" do
       handler = stub_everything 'handler'
       Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
       Puppet::Network::Handler.expects(:handler).returns(handler).times(2)
       Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
     end
 
     it "should add each handler to the XMLRPCserver" do
       handler = stub_everything 'handler'
       Puppet::Network::Handler.stubs(:handler).returns(handler)
       Puppet::Network::XMLRPCServer.any_instance.expects(:add_handler).times(2)
       Puppet::Network::HTTP::RackXMLRPC.new([:foo, :bar])
     end
   end
 
   describe "when serving a request" do
 
     before :each do
       foo_handler = stub_everything 'foo_handler'
       Puppet::Network::Handler.stubs(:handler).with(:foo).returns foo_handler
       Puppet::Network::XMLRPCServer.any_instance.stubs(:add_handler)
       Puppet::Network::XMLRPCServer.any_instance.stubs(:process).returns('<xml/>')
       @handler = Puppet::Network::HTTP::RackXMLRPC.new([:foo])
     end
 
     before :each do
       @response = Rack::Response.new
     end
 
     def mk_req(opts = {})
       opts[:method] = 'POST' if !opts[:method]
       opts['CONTENT_TYPE'] = 'text/xml; foo=bar' if !opts['CONTENT_TYPE']
       env = Rack::MockRequest.env_for('/RPC2', opts)
       Rack::Request.new(env)
     end
 
     it "should reject non-POST requests" do
       req = mk_req :method => 'PUT'
       @handler.process(req, @response)
       @response.status.should == 405
     end
 
     it "should reject non text/xml requests" do
       req = mk_req 'CONTENT_TYPE' => 'yadda/plain'
     end
 
     it "should create a ClientRequest" do
       cr = Puppet::Network::ClientRequest.new(nil, '127.0.0.1', false)
       Puppet::Network::ClientRequest.expects(:new).returns cr
       req = mk_req
       @handler.process(req, @response)
     end
 
     it "should let xmlrpcserver process the request" do
       Puppet::Network::XMLRPCServer.any_instance.expects(:process).returns('yay')
       req = mk_req
       @handler.process(req, @response)
     end
 
     it "should report the response as OK" do
       req = mk_req
       @handler.process(req, @response)
       @response.status.should == 200
     end
 
     it "should report the response with the correct content type" do
       req = mk_req
       @handler.process(req, @response)
       @response['Content-Type'].should == 'text/xml; charset=utf-8'
     end
 
     it "should set 'authenticated' to false if no certificate is present" do
       req = mk_req
       Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
       @handler.process(req, @response)
     end
 
     it "should use the client's ip address" do
       req = mk_req 'REMOTE_ADDR' => 'ipaddress'
       Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| ip == 'ipaddress' }
       @handler.process(req, @response)
     end
 
     describe "with pre-validated certificates" do
 
       it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         req = mk_req "myheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should retrieve the hostname by matching the certificate parameter" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
         req = mk_req "myheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
         req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == true }
         req = mk_req "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
         req = mk_req "myheader" => "whatever", "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| authenticated == false }
         req = mk_req "myheader" => nil, "certheader" => "/CN=host.domain.com"
         @handler.process(req, @response)
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
         Resolv.any_instance.expects(:getname).returns("host.domain.com")
         Puppet::Network::ClientRequest.expects(:new).with { |node,ip,authenticated| node == "host.domain.com" }
         req = mk_req "myheader" => nil
         @handler.process(req, @response)
       end
     end
   end
 end
diff --git a/spec/unit/network/http/rack_spec.rb b/spec/unit/network/http/rack_spec.rb
index df42a1ffa..8be9ccb50 100755
--- a/spec/unit/network/http/rack_spec.rb
+++ b/spec/unit/network/http/rack_spec.rb
@@ -1,102 +1,103 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/handler'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 
 describe "Puppet::Network::HTTP::Rack" do
   confine "Rack is not available" => Puppet.features.rack?
 
   describe "while initializing" do
 
     it "should require a protocol specification" do
       Proc.new { Puppet::Network::HTTP::Rack.new({}) }.should raise_error(ArgumentError)
     end
 
     it "should not accept imaginary protocols" do
       Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:foo]}) }.should raise_error(ArgumentError)
     end
 
     it "should accept the REST protocol" do
       Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:rest]}) }.should_not raise_error(ArgumentError)
     end
 
     it "should create a RackREST instance" do
       Puppet::Network::HTTP::RackREST.expects(:new)
       Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
     end
 
     describe "with XMLRPC enabled" do
 
       it "should require XMLRPC handlers" do
         Proc.new { Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc]}) }.should raise_error(ArgumentError)
       end
 
       it "should create a RackXMLRPC instance" do
         Puppet::Network::HTTP::RackXMLRPC.expects(:new)
         Puppet::Network::HTTP::Rack.new({:protocols => [:xmlrpc], :xmlrpc_handlers => [:Status]})
       end
 
     end
 
   end
 
   describe "when called" do
 
     before :all do
       @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest]})
       # let's use Rack::Lint to verify that we're OK with the rack specification
       @linted = Rack::Lint.new(@app)
     end
 
     before :each do
       @env = Rack::MockRequest.env_for('/')
     end
 
     it "should create a Request object" do
       request = Rack::Request.new(@env)
       Rack::Request.expects(:new).returns request
       @linted.call(@env)
     end
 
     it "should create a Response object" do
       Rack::Response.expects(:new).returns stub_everything
       @app.call(@env) # can't lint when Rack::Response is a stub
     end
 
     it "should let RackREST process the request" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:process).once
       @linted.call(@env)
     end
 
     it "should catch unhandled exceptions from RackREST" do
       Puppet::Network::HTTP::RackREST.any_instance.expects(:process).raises(ArgumentError, 'test error')
       Proc.new { @linted.call(@env) }.should_not raise_error
     end
 
     it "should finish() the Response" do
       Rack::Response.any_instance.expects(:finish).once
       @app.call(@env) # can't lint when finish is a stub
     end
 
   end
 
   describe "when serving XMLRPC" do
 
     before :all do
       @app = Puppet::Network::HTTP::Rack.new({:protocols => [:rest, :xmlrpc], :xmlrpc_handlers => [:Status]})
       @linted = Rack::Lint.new(@app)
     end
 
     before :each do
       @env = Rack::MockRequest.env_for('/RPC2', :method => 'POST')
     end
 
     it "should use RackXMLRPC to serve /RPC2 requests" do
       Puppet::Network::HTTP::RackXMLRPC.any_instance.expects(:process).once
       @linted.call(@env)
     end
 
   end
 
 end
 
diff --git a/spec/unit/network/http/webrick_spec.rb b/spec/unit/network/http/webrick_spec.rb
index 2a6ef2268..8e7c92b71 100755
--- a/spec/unit/network/http/webrick_spec.rb
+++ b/spec/unit/network/http/webrick_spec.rb
@@ -1,339 +1,340 @@
 #!/usr/bin/env ruby
 #
 #  Created by Rick Bradley on 2007-10-15.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/handler'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick'
 
 describe Puppet::Network::HTTP::WEBrick, "after initializing" do
   it "should not be listening" do
     Puppet::Network::HTTP::WEBrick.new.should_not be_listening
   end
 end
 
 describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
   before do
     @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
     [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
     @listen_params = { :address => "127.0.0.1", :port => 31337, :xmlrpc_handlers => [], :protocols => [ :rest ] }
   end
 
   it "should fail if already listening" do
     @server.listen(@listen_params)
     Proc.new { @server.listen(@listen_params) }.should raise_error(RuntimeError)
   end
 
   it "should require at least one protocol" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :protocols == k}) }.should raise_error(ArgumentError)
   end
 
   it "should require a listening address to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :address == k})}.should raise_error(ArgumentError)
   end
 
   it "should require a listening port to be specified" do
     Proc.new { @server.listen(@listen_params.delete_if {|k,v| :port == k})}.should raise_error(ArgumentError)
   end
 
   it "should order a webrick server to start in a separate thread" do
     @mock_webrick.expects(:start)
     # If you remove this you'll sometimes get race condition problems
     Thread.expects(:new).yields
     @server.listen(@listen_params)
   end
 
   it "should tell webrick to listen on the specified address and port" do
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Port] == 31337 and args[:BindAddress] == "127.0.0.1"
     }.returns(@mock_webrick)
     @server.listen(@listen_params)
   end
 
   it "should configure a logger for webrick" do
     @server.expects(:setup_logger).returns(:Logger => :mylogger)
 
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Logger] == :mylogger
     }.returns(@mock_webrick)
 
     @server.listen(@listen_params)
   end
 
   it "should configure SSL for webrick" do
     @server.expects(:setup_ssl).returns(:Ssl => :testing, :Other => :yay)
 
     WEBrick::HTTPServer.expects(:new).with {|args|
       args[:Ssl] == :testing and args[:Other] == :yay
     }.returns(@mock_webrick)
 
     @server.listen(@listen_params)
   end
 
   it "should be listening" do
     @server.listen(@listen_params)
     @server.should be_listening
   end
 
   describe "when the REST protocol is requested" do
     it "should register the REST handler at /" do
       # We don't care about the options here.
       @mock_webrick.expects(:mount).with { |path, klass, options| path == "/" and klass == Puppet::Network::HTTP::WEBrickREST }
 
       @server.listen(@listen_params.merge(:protocols => [:rest]))
     end
   end
 
   describe "when the XMLRPC protocol is requested" do
     before do
       @servlet = mock 'servlet'
 
       Puppet::Network::XMLRPC::WEBrickServlet.stubs(:new).returns @servlet
 
       @master_handler = mock('master_handler')
       @file_handler = mock('file_handler')
 
       @master = mock 'master'
       @file = mock 'file'
       @master_handler.stubs(:new).returns @master
       @file_handler.stubs(:new).returns @file
 
       Puppet::Network::Handler.stubs(:handler).with(:master).returns @master_handler
       Puppet::Network::Handler.stubs(:handler).with(:fileserver).returns @file_handler
     end
 
     it "should do nothing if no xmlrpc handlers have been specified" do
       Puppet::Network::Handler.expects(:handler).never
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => []))
     end
 
     it "should look the handler classes up via their base class" do
       Puppet::Network::Handler.expects(:handler).with(:master).returns @master_handler
       Puppet::Network::Handler.expects(:handler).with(:fileserver).returns @file_handler
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should create an instance for each requested xmlrpc handler" do
       @master_handler.expects(:new).returns @master
       @file_handler.expects(:new).returns @file
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should create a webrick servlet with the xmlrpc handler instances" do
       Puppet::Network::XMLRPC::WEBrickServlet.expects(:new).with([@master, @file]).returns @servlet
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
 
     it "should mount the webrick servlet at /RPC2" do
       @mock_webrick.stubs(:mount)
       @mock_webrick.expects(:mount).with("/RPC2", @servlet)
 
       @server.listen(@listen_params.merge(:protocols => [:xmlrpc], :xmlrpc_handlers => [:master, :fileserver]))
     end
   end
 end
 
 
 describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a protocol" do
   it "should require a protocol" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol }.should raise_error(ArgumentError)
   end
 
   it "should accept a protocol" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("bob") }.should_not raise_error(ArgumentError)
   end
 
   it "should use a WEBrick + REST class when a REST protocol is specified" do
     Puppet::Network::HTTP::WEBrick.class_for_protocol("rest").should == Puppet::Network::HTTP::WEBrickREST
   end
 
   it "should fail when an unknown protocol is specified" do
     lambda { Puppet::Network::HTTP::WEBrick.class_for_protocol("abcdefg") }.should raise_error
   end
 end
 
 describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do
   before do
     @mock_webrick = stub('webrick', :[] => {}, :listeners => [], :status => :Running)
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
     [:setup_logger, :setup_ssl].each {|meth| @server.stubs(meth).returns({})} # the empty hash is required because of how we're merging
     @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
   end
 
   it "should fail unless listening" do
     Proc.new { @server.unlisten }.should raise_error(RuntimeError)
   end
 
   it "should order webrick server to stop" do
     @mock_webrick.expects(:shutdown)
     @server.listen(@listen_params)
     @server.unlisten
   end
 
   it "should no longer be listening" do
     @server.listen(@listen_params)
     @server.unlisten
     @server.should_not be_listening
   end
 end
 
 describe Puppet::Network::HTTP::WEBrick do
   before do
     @mock_webrick = stub('webrick', :[] => {})
     [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
     WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
     @server = Puppet::Network::HTTP::WEBrick.new
   end
 
   describe "when configuring an http logger" do
     before do
       Puppet.settings.stubs(:value).returns "something"
       Puppet.settings.stubs(:use)
       @filehandle = stub 'handle', :fcntl => nil, :sync => nil
 
       File.stubs(:open).returns @filehandle
     end
 
     it "should use the settings for :main, :ssl, and the process name" do
       Puppet.settings.stubs(:value).with(:name).returns "myname"
       Puppet.settings.expects(:use).with(:main, :ssl, "myname")
 
       @server.setup_logger
     end
 
     it "should use the masterlog if the run_mode is master" do
       Puppet.run_mode.stubs(:master?).returns(true)
       Puppet.settings.expects(:value).with(:masterhttplog).returns "/master/log"
 
       File.expects(:open).with("/master/log", "a+").returns @filehandle
 
       @server.setup_logger
     end
 
     it "should use the httplog if the run_mode is not master" do
       Puppet.run_mode.stubs(:master?).returns(false)
       Puppet.settings.expects(:value).with(:httplog).returns "/other/log"
 
       File.expects(:open).with("/other/log", "a+").returns @filehandle
 
       @server.setup_logger
     end
 
     describe "and creating the logging filehandle" do
       it "should set fcntl to 'Fcntl::F_SETFD, Fcntl::FD_CLOEXEC'" do
         @filehandle.expects(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
         @server.setup_logger
       end
 
       it "should sync the filehandle" do
         @filehandle.expects(:sync)
 
         @server.setup_logger
       end
     end
 
     it "should create a new WEBrick::Log instance with the open filehandle" do
       WEBrick::Log.expects(:new).with(@filehandle)
 
       @server.setup_logger
     end
 
     it "should set debugging if the current loglevel is :debug" do
       Puppet::Util::Log.expects(:level).returns :debug
 
       WEBrick::Log.expects(:new).with { |handle, debug| debug == WEBrick::Log::DEBUG }
 
       @server.setup_logger
     end
 
     it "should return the logger as the main log" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
       @server.setup_logger[:Logger].should == logger
     end
 
     it "should return the logger as the access log using both the Common and Referer log format" do
       logger = mock 'logger'
       WEBrick::Log.expects(:new).returns logger
 
       @server.setup_logger[:AccessLog].should == [
         [logger, WEBrick::AccessLog::COMMON_LOG_FORMAT],
         [logger, WEBrick::AccessLog::REFERER_LOG_FORMAT]
       ]
     end
   end
 
   describe "when configuring ssl" do
     before do
       @key = stub 'key', :content => "mykey"
       @cert = stub 'cert', :content => "mycert"
       @host = stub 'host', :key => @key, :certificate => @cert, :name => "yay", :ssl_store => "mystore"
 
       Puppet::SSL::Certificate.stubs(:find).with('ca').returns @cert
 
       Puppet::SSL::Host.stubs(:localhost).returns @host
     end
 
     it "should use the key from the localhost SSL::Host instance" do
       Puppet::SSL::Host.expects(:localhost).returns @host
       @host.expects(:key).returns @key
 
       @server.setup_ssl[:SSLPrivateKey].should == "mykey"
     end
 
     it "should configure the certificate" do
       @server.setup_ssl[:SSLCertificate].should == "mycert"
     end
 
     it "should fail if no CA certificate can be found" do
       Puppet::SSL::Certificate.stubs(:find).with('ca').returns nil
 
       lambda { @server.setup_ssl }.should raise_error(Puppet::Error)
     end
 
     it "should specify the path to the CA certificate" do
       Puppet.settings.stubs(:value).returns "whatever"
       Puppet.settings.stubs(:value).with(:hostcrl).returns 'false'
       Puppet.settings.stubs(:value).with(:localcacert).returns '/ca/crt'
 
       @server.setup_ssl[:SSLCACertificateFile].should == "/ca/crt"
     end
 
     it "should start ssl immediately" do
       @server.setup_ssl[:SSLStartImmediately].should be_true
     end
 
     it "should enable ssl" do
       @server.setup_ssl[:SSLEnable].should be_true
     end
 
     it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
       @server.setup_ssl[:SSLVerifyClient].should == OpenSSL::SSL::VERIFY_PEER
     end
 
     it "should add an x509 store" do
       Puppet.settings.stubs(:value).returns "whatever"
       Puppet.settings.stubs(:value).with(:hostcrl).returns '/my/crl'
 
       @host.expects(:ssl_store).returns "mystore"
 
       @server.setup_ssl[:SSLCertificateStore].should == "mystore"
     end
 
     it "should set the certificate name to 'nil'" do
       @server.setup_ssl[:SSLCertName].should be_nil
     end
   end
 end
diff --git a/spec/unit/network/xmlrpc/client_spec.rb b/spec/unit/network/xmlrpc/client_spec.rb
index 0b9b2b095..8440d39fa 100755
--- a/spec/unit/network/xmlrpc/client_spec.rb
+++ b/spec/unit/network/xmlrpc/client_spec.rb
@@ -1,171 +1,172 @@
 #!/usr/bin/env ruby
+require 'puppet/network/client'
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 describe Puppet::Network::XMLRPCClient do
   describe "when performing the rpc call" do
     before do
       Puppet::SSL::Host.any_instance.stubs(:certificate_matches_key?).returns true
       @client = Puppet::Network::Client.report.xmlrpc_client.new
       @client.stubs(:call).returns "foo"
     end
 
     it "should call the specified namespace and method, with the specified arguments" do
       @client.expects(:call).with("puppetreports.report", "eh").returns "foo"
       @client.report("eh")
     end
 
     it "should return the results from the call" do
       @client.expects(:call).returns "foo"
       @client.report("eh").should == "foo"
     end
 
     it "should always close the http connection if it is still open after the call" do
       http = mock 'http'
       @client.stubs(:http).returns http
 
       http.expects(:started?).returns true
       http.expects(:finish)
 
       @client.report("eh").should == "foo"
     end
 
     it "should always close the http connection if it is still open after a call that raises an exception" do
       http = mock 'http'
       @client.stubs(:http).returns http
 
       @client.expects(:call).raises RuntimeError
 
       http.expects(:started?).returns true
       http.expects(:finish)
 
       lambda { @client.report("eh") }.should raise_error
     end
 
     describe "when returning the http instance" do
       it "should use the http pool to create the instance" do
         @client.instance_variable_set("@http", nil)
         @client.expects(:host).returns "myhost"
         @client.expects(:port).returns "myport"
         Puppet::Network::HttpPool.expects(:http_instance).with("myhost", "myport", true).returns "http"
 
         @client.http.should == "http"
       end
 
       it "should reuse existing instances" do
         @client.http.should equal(@client.http)
       end
     end
 
     describe "when recycling the connection" do
       it "should close the existing instance if it's open" do
         http = mock 'http'
         @client.stubs(:http).returns http
 
         http.expects(:started?).returns true
         http.expects(:finish)
 
         @client.recycle_connection
       end
 
       it "should force creation of a new instance" do
         Puppet::Network::HttpPool.expects(:http_instance).returns "second_http"
 
         @client.recycle_connection
 
         @client.http.should == "second_http"
       end
     end
 
     describe "and an exception is raised" do
       it "should raise XMLRPCClientError if XMLRPC::FaultException is raised" do
         error = XMLRPC::FaultException.new("foo", "bar")
 
         @client.expects(:call).raises(error)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should raise XMLRPCClientError if Errno::ECONNREFUSED is raised" do
         @client.expects(:call).raises(Errno::ECONNREFUSED)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should log and raise XMLRPCClientError if Timeout::Error is raised" do
         Puppet.expects(:err)
         @client.expects(:call).raises(Timeout::Error)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should log and raise XMLRPCClientError if SocketError is raised" do
         Puppet.expects(:err)
         @client.expects(:call).raises(SocketError)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should log, recycle the connection, and retry if Errno::EPIPE is raised" do
         @client.expects(:call).times(2).raises(Errno::EPIPE).then.returns "eh"
 
         Puppet.expects(:info)
         @client.expects(:recycle_connection)
 
         @client.report("eh")
       end
 
       it "should log, recycle the connection, and retry if EOFError is raised" do
         @client.expects(:call).times(2).raises(EOFError).then.returns "eh"
 
         Puppet.expects(:info)
         @client.expects(:recycle_connection)
 
         @client.report("eh")
       end
 
       it "should log and retry if an exception containing 'Wrong size' is raised" do
         error = RuntimeError.new("Wrong size. Was 15, should be 30")
         @client.expects(:call).times(2).raises(error).then.returns "eh"
 
         Puppet.expects(:warning)
 
         @client.report("eh")
       end
 
       it "should raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised" do
         @client.expects(:call).raises(OpenSSL::SSL::SSLError)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should log and raise XMLRPCClientError if OpenSSL::SSL::SSLError is raised with certificate issues" do
         error = OpenSSL::SSL::SSLError.new("hostname was not match")
         @client.expects(:call).raises(error)
 
         Puppet.expects(:warning)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
 
       it "should log, recycle the connection, and retry if OpenSSL::SSL::SSLError is raised containing 'bad write retry'" do
         error = OpenSSL::SSL::SSLError.new("bad write retry")
         @client.expects(:call).times(2).raises(error).then.returns "eh"
 
         @client.expects(:recycle_connection)
 
         Puppet.expects(:warning)
 
         @client.report("eh")
       end
 
       it "should log and raise XMLRPCClientError if any other exception is raised" do
         @client.expects(:call).raises(RuntimeError)
 
         Puppet.expects(:err)
 
         lambda { @client.report("eh") }.should raise_error(Puppet::Network::XMLRPCClientError)
       end
     end
   end
 end
diff --git a/spec/unit/parser/collector_spec.rb b/spec/unit/parser/collector_spec.rb
index 15808d6ff..908cda63a 100755
--- a/spec/unit/parser/collector_spec.rb
+++ b/spec/unit/parser/collector_spec.rb
@@ -1,559 +1,560 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
+require 'puppet/rails'
 require 'puppet/parser/collector'
 
 describe Puppet::Parser::Collector, "when initializing" do
   before do
     @scope = mock 'scope'
     @resource_type = 'resource_type'
     @form = :exported
     @vquery = mock 'vquery'
     @equery = mock 'equery'
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, @form)
   end
 
   it "should require a scope" do
     @collector.scope.should equal(@scope)
   end
 
   it "should require a resource type" do
     @collector.type.should == 'Resource_type'
   end
 
   it "should only accept :virtual or :exported as the collector form" do
     proc { @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @vquery, @equery, :other) }.should raise_error(ArgumentError)
   end
 
   it "should accept an optional virtual query" do
     @collector.vquery.should equal(@vquery)
   end
 
   it "should accept an optional exported query" do
     @collector.equery.should equal(@equery)
   end
 
   it "should canonize the type name" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     @collector.type.should == "Resource::Type"
   end
 
   it "should accept an optional resource override" do
     @collector = Puppet::Parser::Collector.new(@scope, "resource::type", @equery, @vquery, @form)
     override = { :parameters => "whatever" }
     @collector.add_override(override)
     @collector.overrides.should equal(override)
   end
 
 end
 
 describe Puppet::Parser::Collector, "when collecting specific virtual resources" do
   before do
     @scope = mock 'scope'
     @vquery = mock 'vquery'
     @equery = mock 'equery'
 
     @collector = Puppet::Parser::Collector.new(@scope, "resource_type", @equery, @vquery, :virtual)
   end
 
   it "should not fail when it does not find any resources to collect" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     @scope.stubs(:findresource).returns(false)
     proc { @collector.evaluate }.should_not raise_error
   end
 
   it "should mark matched resources as non-virtual" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     one.expects(:virtual=).with(false)
 
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate
   end
 
   it "should return matched resources" do
     @collector.resources = ["File[virtual1]", "File[virtual2]"]
     one = stub_everything 'one'
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @scope.stubs(:findresource).with("File[virtual2]").returns(nil)
     @collector.evaluate.should == [one]
   end
 
   it "should delete itself from the compile's collection list if it has found all of its resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).with(@collector)
     @scope.expects(:compiler).returns(@compiler)
     @scope.stubs(:findresource).with("File[virtual1]").returns(one)
     @collector.evaluate
   end
 
   it "should not delete itself from the compile's collection list if it has unfound resources" do
     @collector.resources = ["File[virtual1]"]
     one = stub_everything 'one'
     @compiler.expects(:delete_collection).never
     @scope.stubs(:findresource).with("File[virtual1]").returns(nil)
     @collector.evaluate
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting virtual and catalog resources" do
   before do
     @scope = mock 'scope'
     @compiler = mock 'compile'
     @scope.stubs(:compiler).returns(@compiler)
     @resource_type = "Mytype"
     @vquery = proc { |res| true }
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, @vquery, :virtual)
   end
 
   it "should find all virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should find all non-virtual resources matching the vquery" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => false
     two = stub_everything 'two', :type => "Mytype", :virtual? => false
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all matched resources as non-virtual" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.evaluate
   end
 
   it "should return matched resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should return all resources of the correct type if there is no virtual query" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, nil, nil, :virtual)
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should not return or mark resources of a different type" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :type => :other, :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 
   it "should create a resource with overridden parameters" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
   end
 
   it "should define a new allow all child_of? on overriden resource" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     source = stub 'source'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.add_override(:parameters => param, :source => source )
     Puppet::Parser::Resource.stubs(:new)
 
     source.expects(:meta_def).with { |name,block| name == :child_of? }
 
     @collector.evaluate
   end
 
 
   it "should not override already overriden resources for this same collection in a previous run" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
     @compiler.stubs(:add_override)
 
     @compiler.expects(:resources).at_least(2).returns([one])
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
 
     @collector.evaluate
   end
 
   it "should not return resources that were collected in a previous run of this collector" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     @compiler.stubs(:resources).returns([one])
 
     @collector.evaluate
 
     @collector.evaluate.should be_false
   end
 
 
   it "should tell the compiler about the overriden resources" do
     one = stub_everything 'one', :type => "Mytype", :virtual? => true, :title => "test"
     param = stub 'param'
 
     one.expects(:virtual=).with(false)
     @compiler.expects(:resources).returns([one])
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.stubs(:new).returns("whatever")
 
     @compiler.expects(:add_override).with("whatever")
 
     @collector.evaluate
   end
 
   it "should not return or mark non-matching resources" do
     @collector.vquery = proc { |res| res.name == :one }
 
     one = stub_everything 'one', :name => :one, :type => "Mytype", :virtual? => true
     two = stub_everything 'two', :name => :two, :type => "Mytype", :virtual? => true
 
     one.expects(:virtual=).with(false)
     two.expects(:virtual=).never
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one]
   end
 end
 
 describe Puppet::Parser::Collector, "when collecting exported resources" do
   confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
 
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
     @resource_type = "Mytype"
     @equery = "test = true"
     @vquery = proc { |r| true }
 
     res = stub("resource 1")
     res.stubs(:type).returns @resource_type
     Puppet::Resource.stubs(:new).returns res
 
     Puppet.settings.stubs(:value).with(:storeconfigs).returns true
     Puppet.settings.stubs(:value).with(:environment).returns "production"
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
   end
 
   # Stub most of our interface to Rails.
   def stub_rails(everything = false)
     ActiveRecord::Base.stubs(:connected?).returns(false)
     Puppet::Rails.stubs(:init)
     if everything
       Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
       Puppet::Rails::Resource.stubs(:find).returns([])
     end
   end
 
   it "should just return false if :storeconfigs is not enabled" do
     Puppet.settings.expects(:value).with(:storeconfigs).returns false
     @collector.evaluate.should be_false
   end
 
   it "should use initialize the Rails support if ActiveRecord is not connected" do
     @compiler.stubs(:resources).returns([])
     ActiveRecord::Base.expects(:connected?).returns(false)
     Puppet::Rails.expects(:init)
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
     Puppet::Rails::Resource.stubs(:find).returns([])
 
     @collector.evaluate
   end
 
   it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
     stub_rails(true)
 
     one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
     two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "two"
 
     one.stubs(:exported=)
     one.stubs(:virtual=)
     two.stubs(:exported=)
     two.stubs(:virtual=)
 
     @compiler.expects(:resources).returns([one, two])
 
     @collector.evaluate.should == [one, two]
   end
 
   it "should mark all returned resources as not virtual" do
     stub_rails(true)
 
     one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
 
     one.stubs(:exported=)
     one.expects(:virtual=).with(false)
 
     @compiler.expects(:resources).returns([one])
 
     @collector.evaluate.should == [one]
   end
 
   it "should convert all found resources into parser resources" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.stubs(:add_resource)
 
     @collector.evaluate.should == [resource]
   end
 
   it "should override all exported collected resources if collector has an override" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource', :type => "Mytype"
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
     resource.stubs(:title)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     param = stub 'param'
     @compiler.stubs(:add_override)
     @compiler.stubs(:add_resource)
 
     @collector.add_override(:parameters => param )
     Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
       h[:parameters] == param
     }
 
     @collector.evaluate
   end
 
   it "should store converted resources in the compile's resource list" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.stubs(:exported=)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.expects(:add_resource).with(@scope, resource)
 
     @collector.evaluate.should == [resource]
   end
 
   # This way one host doesn't store another host's resources as exported.
   it "should mark resources collected from the database as not exported" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
     Puppet::Rails::Resource.stubs(:find).returns([one])
 
     resource = mock 'resource'
     one.expects(:to_resource).with(@scope).returns(resource)
     resource.expects(:exported=).with(false)
     resource.stubs(:virtual=)
     resource.stubs(:ref)
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(nil)
 
     @compiler.stubs(:add_resource)
 
     @collector.evaluate
   end
 
   it "should fail if an equivalent resource already exists in the compile" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
     inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 2
 
     Puppet::Rails::Resource.stubs(:find).returns([rails])
 
     resource = mock 'resource'
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(inmemory)
 
     @compiler.stubs(:add_resource)
 
     proc { @collector.evaluate }.should raise_error(Puppet::ParseError)
   end
 
   it "should ignore exported resources that match already-collected resources" do
     stub_rails
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
 
     rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
     inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 1
 
     Puppet::Rails::Resource.stubs(:find).returns([rails])
 
     resource = mock 'resource'
 
     @compiler.stubs(:resources).returns([])
     @scope.stubs(:findresource).returns(inmemory)
 
     @compiler.stubs(:add_resource)
 
     proc { @collector.evaluate }.should_not raise_error(Puppet::ParseError)
   end
 end
 
 describe Puppet::Parser::Collector, "when building its ActiveRecord query for collecting exported resources" do
   confine "Cannot test Rails integration without ActiveRecord" => Puppet.features.rails?
 
   before do
     @scope = stub 'scope', :host => "myhost", :debug => nil
     @compiler = mock 'compile'
     @scope.stubs(:compiler).returns(@compiler)
     @resource_type = "Mytype"
     @equery = nil
     @vquery = proc { |r| true }
 
     @resource = stub_everything 'collected'
 
     @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
     @collector.stubs(:exported_resource).with(@resource).returns(@resource)
     @compiler.stubs(:resources).returns([])
 
     ActiveRecord::Base.stubs(:connected?).returns(false)
 
     Puppet::Rails.stubs(:init)
     Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
     Puppet::Rails::Resource.stubs(:find).returns([])
 
     Puppet.settings.stubs(:value).with(:storeconfigs).returns true
   end
 
   it "should exclude all resources from the host if ActiveRecord contains information for this host" do
     @host = mock 'host'
     @host.stubs(:id).returns 5
 
     Puppet::Rails::Host.expects(:find_by_name).with(@scope.host).returns(@host)
 
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with parameter names, parameter values when querying ActiveRecord" do
     @collector.equery = "param_names.name = title"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should join with tag tables when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:resource_tags => :puppet_tag}
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should not join parameters when querying ActiveRecord with a tag exported query" do
     @collector.equery = "puppet_tags.name = test"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:joins] == {:param_values => :param_name}
     }.returns([@resource])
 
     @collector.evaluate.should be_false
   end
 
   it "should only search for exported resources with the matching type" do
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 
   it "should include the export query if one is provided" do
     @collector.equery = "test = true"
     Puppet::Rails::Resource.stubs(:find).with { |*arguments|
       options = arguments[1]
       options[:conditions][0].include?("test = true")
     }.returns([@resource])
 
     @collector.evaluate.should == [@resource]
   end
 end
diff --git a/spec/unit/parser/templatewrapper_spec.rb b/spec/unit/parser/templatewrapper_spec.rb
index d4d1d1b8e..68d90a1cc 100755
--- a/spec/unit/parser/templatewrapper_spec.rb
+++ b/spec/unit/parser/templatewrapper_spec.rb
@@ -1,144 +1,145 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/parser/templatewrapper'
 
 describe Puppet::Parser::TemplateWrapper do
   before(:each) do
     @known_resource_types = Puppet::Resource::TypeCollection.new("env")
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
 
     @file = "fake_template"
     Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
     FileTest.stubs(:exists?).returns("true")
     File.stubs(:read).with("/tmp/fake_template").returns("template content")
     @tw = Puppet::Parser::TemplateWrapper.new(@scope)
   end
 
   it "should create a new object TemplateWrapper from a scope" do
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
 
     tw.should be_a_kind_of(Puppet::Parser::TemplateWrapper)
   end
 
   it "should check template file existance and read its content" do
     Puppet::Parser::Files.expects(:find_template).with("fake_template", @scope.environment.to_s).returns("/tmp/fake_template")
     File.expects(:read).with("/tmp/fake_template").returns("template content")
 
     @tw.file = @file
   end
 
   it "should mark the file for watching" do
     Puppet::Parser::Files.expects(:find_template).returns("/tmp/fake_template")
     File.stubs(:read)
 
     @known_resource_types.expects(:watch_file).with("/tmp/fake_template")
     @tw.file = @file
   end
 
   it "should fail if a template cannot be found" do
     Puppet::Parser::Files.expects(:find_template).returns nil
 
     lambda { @tw.file = @file }.should raise_error(Puppet::ParseError)
   end
 
   it "should turn into a string like template[name] for file based template" do
     @tw.file = @file
     @tw.to_s.should eql("template[/tmp/fake_template]")
   end
 
   it "should turn into a string like template[inline] for string-based template" do
     @tw.to_s.should eql("template[inline]")
   end
 
   it "should return the processed template contents with a call to result" do
     template_mock = mock("template", :result => "woot!")
     File.expects(:read).with("/tmp/fake_template").returns("template contents")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.file = @file
     @tw.result.should eql("woot!")
   end
 
   it "should return the processed template contents with a call to result and a string" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.result("template contents").should eql("woot!")
   end
 
   it "should return the contents of a variable if called via method_missing" do
     @scope.expects(:lookupvar).with("chicken", false).returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.chicken.should eql("is good")
   end
 
   it "should throw an exception if a variable is called via method_missing and it does not exist" do
     @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     lambda { tw.chicken }.should raise_error(Puppet::ParseError)
   end
 
   it "should allow you to check whether a variable is defined with has_variable?" do
     @scope.expects(:lookupvar).with("chicken", false).returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(true)
   end
 
   it "should allow you to check whether a variable is not defined with has_variable?" do
     @scope.expects(:lookupvar).with("chicken", false).returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(false)
   end
 
   it "should allow you to retrieve the defined classes with classes" do
     catalog = mock 'catalog', :classes => ["class1", "class2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.classes.should == ["class1", "class2"]
   end
 
   it "should allow you to retrieve all the tags with all_tags" do
     catalog = mock 'catalog', :tags => ["tag1", "tag2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.all_tags.should == ["tag1","tag2"]
   end
 
   it "should allow you to retrieve the tags defined in the current scope" do
     @scope.expects(:tags).returns( ["tag1", "tag2"] )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.tags.should == ["tag1","tag2"]
   end
 
   it "should set all of the scope's variables as instance variables" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns("one" => "foo")
     @tw.result("template contents")
 
     @tw.instance_variable_get("@one").should == "foo"
   end
 
   it "should not error out if one of the variables is a symbol" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns(:_timestamp => "1234")
     @tw.result("template contents")
   end
 
   %w{! . ; :}.each do |badchar|
     it "should translate #{badchar} to _ when setting the instance variables" do
     template_mock = mock("template", :result => "woot!")
     ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
     @tw.result("template contents")
 
     @tw.instance_variable_get("@one_").should == "foo"
   end
   end
 end
diff --git a/spec/unit/rails/param_value_spec.rb b/spec/unit/rails/param_value_spec.rb
index d6dc7d57b..243456e89 100755
--- a/spec/unit/rails/param_value_spec.rb
+++ b/spec/unit/rails/param_value_spec.rb
@@ -1,49 +1,50 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/rails'
 
 describe "Puppet::Rails::ParamValue" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/param_value'
 
     name = stub 'param_name', :name => "foo"
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::ParamValue.stubs(:columns).returns([column("value", "string")])
     Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
   end
 
   describe "when creating initial parameter values" do
     it "should return an array of hashes" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, %w{a b})[0].should be_instance_of(Hash)
     end
 
     it "should return hashes for each value with the parameter name set as the ParamName instance" do
       name = stub 'param_name', :name => "foo"
       Puppet::Rails::ParamName.expects(:find_or_create_by_name).returns(name)
 
       result = Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0]
       result[:value].should == "a"
       result[:param_name].should == name
     end
 
     it "should return an array of hashes even when only one parameter is provided" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0].should be_instance_of(Hash)
     end
 
     it "should convert all arguments into strings" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, 50)[0][:value].should == "50"
     end
 
     it "should not convert Resource References into strings" do
       ref = Puppet::Resource.new(:file, "/file")
       Puppet::Rails::ParamValue.from_parser_param(:myparam, ref)[0][:value].should == ref
     end
   end
 end
diff --git a/spec/unit/rails/resource_spec.rb b/spec/unit/rails/resource_spec.rb
index 73c7f7af4..6e23d2020 100755
--- a/spec/unit/rails/resource_spec.rb
+++ b/spec/unit/rails/resource_spec.rb
@@ -1,123 +1,124 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/rails'
 
 describe "Puppet::Rails::Resource" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
   def column(name, type)
     ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
   end
 
   before do
     require 'puppet/rails/resource'
 
     # Stub this so we don't need access to the DB.
     Puppet::Rails::Resource.stubs(:columns).returns([column("title", "string"), column("restype", "string"), column("exported", "boolean")])
   end
 
   describe "when creating initial resource arguments" do
     it "should set the restype to the resource's type" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:restype].should == "File"
     end
 
     it "should set the title to the resource's title" do
       Puppet::Rails::Resource.rails_resource_initial_args(Puppet::Resource.new(:file, "/file"))[:title].should == "/file"
     end
 
     it "should set the line to the resource's line if one is available" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.line = 50
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:line].should == 50
     end
 
     it "should set 'exported' to true of the resource is exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = true
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_true
     end
 
     it "should set 'exported' to false of the resource is not exported" do
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = false
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
 
       resource = Puppet::Resource.new(:file, "/file")
       resource.exported = nil
 
       Puppet::Rails::Resource.rails_resource_initial_args(resource)[:exported].should be_false
     end
   end
 
   describe "when merging in a parser resource" do
     before do
       @parser = mock 'parser resource'
 
       @resource = Puppet::Rails::Resource.new
       [:merge_attributes, :merge_parameters, :merge_tags, :save].each { |m| @resource.stubs(m) }
     end
 
     it "should merge the attributes" do
       @resource.expects(:merge_attributes).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the parameters" do
       @resource.expects(:merge_parameters).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should merge the tags" do
       @resource.expects(:merge_tags).with(@parser)
 
       @resource.merge_parser_resource(@parser)
     end
 
     it "should save itself" do
       @resource.expects(:save)
 
       @resource.merge_parser_resource(@parser)
     end
   end
 
   describe "merge_parameters" do
     it "should replace values that have changed" do
       @resource = Puppet::Rails::Resource.new
       @resource.params_list = [{"name" => "replace", "value" => 1, "id" => 100 }]
 
       Puppet::Rails::ParamValue.expects(:delete).with([100])
       param_values = stub "param_values"
       param_values.expects(:build).with({:value=>nil, :param_name=>nil, :line=>{"replace"=>2}})
       @resource.stubs(:param_values).returns(param_values)
 
       Puppet::Rails::ParamName.stubs(:accumulate_by_name)
 
       merge_resource = stub "merge_resource"
       merge_resource.expects(:line).returns({ "replace" => 2 })
       merge_resource.stubs(:each).yields([["replace", 2]])
 
       @resource.merge_parameters(merge_resource)
     end
   end
 
   describe "#to_resource" do
     it "should instantiate a Puppet::Parser::Resource" do
       scope = stub "scope", :source => nil, :environment => nil, :namespaces => nil
 
       @resource = Puppet::Rails::Resource.new
       @resource.stubs(:attributes).returns({
         "restype" => 'notify',
         "title"   => 'hello'
       })
       @resource.stubs(:param_names).returns([])
 
       @resource.to_resource(scope).should be_a(Puppet::Parser::Resource)
 
     end
   end
 end