diff --git a/lib/puppet/network/server.rb b/lib/puppet/network/server.rb
index 275eaf726..ae0a932a2 100644
--- a/lib/puppet/network/server.rb
+++ b/lib/puppet/network/server.rb
@@ -1,137 +1,136 @@
 require 'puppet/network/http'
 require 'puppet/util/pidlock'
 
 class Puppet::Network::Server
   attr_reader :server_type, :address, :port
 
 
   # TODO: does anything actually call this?  It seems like it's a duplicate of the code in Puppet::Daemon, but that
   #  it's not actually called anywhere.
 
   # Put the daemon into the background.
   def daemonize
     if pid = fork
       Process.detach(pid)
       exit(0)
     end
 
     # Get rid of console logging
     Puppet::Util::Log.close(:console)
 
     Process.setsid
     Dir.chdir("/")
   end
 
   def close_streams()
     Puppet::Daemon.close_streams()
   end
 
   # Create a pidfile for our daemon, so we can be stopped and others
   # don't try to start.
   def create_pidfile
     Puppet::Util.synchronize_on(Puppet.run_mode.name,Sync::EX) do
       raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
     end
   end
 
   # Remove the pid file for our daemon.
   def remove_pidfile
     Puppet::Util.synchronize_on(Puppet.run_mode.name,Sync::EX) do
       Puppet::Util::Pidlock.new(pidfile).unlock
     end
   end
 
   # Provide the path to our pidfile.
   def pidfile
     Puppet[:pidfile]
   end
 
   def initialize(args = {})
     valid_args = [:handlers, :port]
     bad_args = args.keys.find_all { |p| ! valid_args.include?(p) }.collect { |p| p.to_s }.join(",")
     raise ArgumentError, "Invalid argument(s) #{bad_args}" unless bad_args == ""
     @server_type = Puppet[:servertype] or raise "No servertype configuration found."  # e.g.,  WEBrick, Mongrel, etc.
     http_server_class || raise(ArgumentError, "Could not determine HTTP Server class for server type [#{@server_type}]")
 
     @port = args[:port] || Puppet[:masterport] || raise(ArgumentError, "Must specify :port or configure Puppet :masterport")
     @address = determine_bind_address
 
     @listening = false
     @routes = {}
     self.register(args[:handlers]) if args[:handlers]
 
     # Make sure we have all of the directories we need to function.
-    #Puppet.settings.use(:main, :ssl, Puppet[:name])
     Puppet.settings.use(:main, :ssl, :application)
   end
 
   # Register handlers for REST networking, based on the Indirector.
   def register(*indirections)
     raise ArgumentError, "Indirection names are required." if indirections.empty?
     indirections.flatten.each do |name|
       Puppet::Indirector::Indirection.model(name) || raise(ArgumentError, "Cannot locate indirection '#{name}'.")
       @routes[name.to_sym] = true
     end
   end
 
   # Unregister Indirector handlers.
   def unregister(*indirections)
     raise "Cannot unregister indirections while server is listening." if listening?
     indirections = @routes.keys if indirections.empty?
 
     indirections.flatten.each do |i|
       raise(ArgumentError, "Indirection [#{i}] is unknown.") unless @routes[i.to_sym]
     end
 
     indirections.flatten.each do |i|
       @routes.delete(i.to_sym)
     end
   end
 
   def listening?
     @listening
   end
 
   def listen
     raise "Cannot listen -- already listening." if listening?
     @listening = true
     http_server.listen(:address => address, :port => port, :handlers => @routes.keys)
   end
 
   def unlisten
     raise "Cannot unlisten -- not currently listening." unless listening?
     http_server.unlisten
     @listening = false
   end
 
   def http_server_class
     http_server_class_by_type(@server_type)
   end
 
   def start
     create_pidfile
     close_streams if Puppet[:daemonize]
     listen
   end
 
   def stop
     unlisten
     remove_pidfile
   end
 
   private
 
   def http_server
     @http_server ||= http_server_class.new
   end
 
   def http_server_class_by_type(kind)
     Puppet::Network::HTTP.server_class_by_type(kind)
   end
 
   def determine_bind_address
     tmp = Puppet[:bindaddress]
     return tmp if tmp != ""
     server_type.to_s == "webrick" ? "0.0.0.0" : "127.0.0.1"
   end
 end
diff --git a/lib/puppet/test/test_helper.rb b/lib/puppet/test/test_helper.rb
index d56112624..1761c131f 100644
--- a/lib/puppet/test/test_helper.rb
+++ b/lib/puppet/test/test_helper.rb
@@ -1,170 +1,169 @@
 module Puppet::Test
   # This class is intended to provide an API to be used by external projects
   #  when they are running tests that depend on puppet core.  This should
   #  allow us to vary the implementation details of managing puppet's state
   #  for testing, from one version of puppet to the next--without forcing
   #  the external projects to do any of that state management or be aware of
   #  the implementation details.
   #
   # For now, this consists of a few very simple signatures.  The plan is
   #  that it should be the responsibility of the puppetlabs_spec_helper
   #  to broker between external projects and this API; thus, if any
   #  hacks are required (e.g. to determine whether or not a particular)
   #  version of puppet supports this API, those hacks will be consolidated in
   #  one place and won't need to be duplicated in every external project.
   #
   # This should also alleviate the anti-pattern that we've been following,
   #  wherein each external project starts off with a copy of puppet core's
   #  test_helper.rb and is exposed to risk of that code getting out of
   #  sync with core.
   #
   # Since this class will be "library code" that ships with puppet, it does
   #  not use API from any existing test framework such as rspec.  This should
   #  theoretically allow it to be used with other unit test frameworks in the
   #  future, if desired.
   #
   # Note that in the future this API could potentially be expanded to handle
   #  other features such as "around_test", but we didn't see a compelling
   #  reason to deal with that right now.
   class TestHelper
     # Call this method once, when beginning a test run--prior to running
     #  any individual tests.
     # @return nil
     def self.before_all_tests()
 
     end
 
     # Call this method once, at the end of a test run, when no more tests
     #  will be run.
     # @return nil
     def self.after_all_tests()
 
     end
 
     # Call this method once per test, prior to execution of each invididual test.
     # @return nil
     def self.before_each_test()
       # We need to preserve the current state of all our indirection cache and
       # terminus classes.  This is pretty important, because changes to these
       # are global and lead to order dependencies in our testing.
       #
       # We go direct to the implementation because there is no safe, sane public
       # API to manage restoration of these to their default values.  This
       # should, once the value is proved, be moved to a standard API on the
       # indirector.
       #
       # To make things worse, a number of the tests stub parts of the
       # indirector.  These stubs have very specific expectations that what
       # little of the public API we could use is, well, likely to explode
       # randomly in some tests.  So, direct access.  --daniel 2011-08-30
       $saved_indirection_state = {}
       indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
       indirections.each do |indirector|
         $saved_indirection_state[indirector.name] = {
             :@terminus_class => indirector.instance_variable_get(:@terminus_class),
             :@cache_class    => indirector.instance_variable_get(:@cache_class)
         }
       end
 
       # The process environment is a shared, persistent resource.
       $old_env = ENV.to_hash
 
       # So is the load_path
       $old_load_path = $LOAD_PATH.dup
 
       initialize_settings_before_each()
     end
 
     # Call this method once per test, after execution of each individual test.
     # @return nil
     def self.after_each_test()
       Puppet.settings.send(:clear_everything_for_tests)
 
       Puppet::Node::Environment.clear
       Puppet::Util::Storage.clear
       Puppet::Util::ExecutionStub.reset
 
       Puppet.clear_deprecation_warnings
 
       # uncommenting and manipulating this can be useful when tracking down calls to deprecated code
       #Puppet.log_deprecations_to_file("deprecations.txt", /^Puppet::Util.exec/)
 
       # Restore the indirector configuration.  See before hook.
       indirections = Puppet::Indirector::Indirection.send(:class_variable_get, :@@indirections)
       indirections.each do |indirector|
         $saved_indirection_state.fetch(indirector.name, {}).each do |variable, value|
           indirector.instance_variable_set(variable, value)
         end
       end
       $saved_indirection_state = nil
 
       # Restore the global process environment.  Can't just assign because this
       # is a magic variable, sadly, and doesn't do that™.  It is sufficiently
       # faster to use the compare-then-set model to avoid excessive work that it
       # justifies the complexity.  --daniel 2012-03-15
       unless ENV.to_hash == $old_env
         ENV.clear
         $old_env.each {|k, v| ENV[k] = v }
       end
 
 
       # Some tests can cause us to connect, in which case the lingering
       # connection is a resource that can cause unexpected failure in later
       # tests, as well as sharing state accidentally.
       # We're testing if ActiveRecord::Base is defined because some test cases
       # may stub Puppet.features.rails? which is how we should normally
       # introspect for this functionality.
       ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
 
       # Restore the load_path late, to avoid messing with stubs from the test.
       $LOAD_PATH.clear
       $old_load_path.each {|x| $LOAD_PATH << x }
 
     end
 
 
     #########################################################################################
     # PRIVATE METHODS (not part of the public TestHelper API--do not call these from outside
     #  of this class!)
     #########################################################################################
 
     def self.app_defaults_for_tests()
       {
           :run_mode   => :user,
-          :name       => :apply,
           :logdir     => "/dev/null",
           :confdir    => "/dev/null",
           :vardir     => "/dev/null",
           :rundir     => "/dev/null",
       }
     end
     private_class_method :app_defaults_for_tests
 
     def self.initialize_settings_before_each()
       # Initialize "app defaults" settings to a good set of test values
       app_defaults_for_tests.each do |key, value|
         Puppet.settings.set_value(key, value, :application_defaults)
       end
 
       # Avoid opening ports to the outside world
       Puppet.settings[:bindaddress] = "127.0.0.1"
 
       # We don't want to depend upon the reported domain name of the
       # machine running the tests, nor upon the DNS setup of that
       # domain.
       Puppet.settings[:use_srv_records] = false
 
       # Longer keys are secure, but they sure make for some slow testing - both
       # in terms of generating keys, and in terms of anything the next step down
       # the line doing validation or whatever.  Most tests don't care how long
       # or secure it is, just that it exists, so these are better and faster
       # defaults, in testing only.
       #
       # I would make these even shorter, but OpenSSL doesn't support anything
       # below 512 bits.  Sad, really, because a 0 bit key would be just fine.
       Puppet[:req_bits]  = 512
       Puppet[:keylength] = 512
     end
     private_class_method :initialize_settings_before_each
   end
 end
diff --git a/spec/unit/network/http/webrick_spec.rb b/spec/unit/network/http/webrick_spec.rb
index 8310ee08f..b7340d6d4 100755
--- a/spec/unit/network/http/webrick_spec.rb
+++ b/spec/unit/network/http/webrick_spec.rb
@@ -1,265 +1,263 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 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, :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 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
 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")
+    it "should use the settings for :main, :ssl, and :application" do
       Puppet.settings.expects(:use).with(:main, :ssl, :application)
 
       @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 the close-on-exec flag if supported" do
         if defined? Fcntl::FD_CLOEXEC
           @filehandle.expects(:fcntl).with(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
         else
           @filehandle.expects(:fcntl).never
         end
 
         @server.setup_logger
       end
 
       it "should sync the filehandle" do
         @filehandle.expects(:sync=).with(true)
 
         @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.indirection.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.indirection.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/server_spec.rb b/spec/unit/network/server_spec.rb
index 00fca4288..6cc07851f 100755
--- a/spec/unit/network/server_spec.rb
+++ b/spec/unit/network/server_spec.rb
@@ -1,411 +1,410 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/network/server'
 
 describe Puppet::Network::Server do
   before do
     @mock_http_server_class = mock('http server class')
     Puppet.settings.stubs(:use)
     Puppet.run_mode.stubs(:name).returns "me"
     Puppet.settings.stubs(:value).with(:servertype).returns(:suparserver)
     Puppet.settings.stubs(:value).with(:bindaddress).returns("")
     Puppet.settings.stubs(:value).with(:masterport).returns(8140)
     Puppet.settings.stubs(:value).with(:daemonize).returns(true)
     Puppet::Network::HTTP.stubs(:server_class_by_type).returns(@mock_http_server_class)
     Puppet.settings.stubs(:value).with(:servertype).returns(:suparserver)
     @server = Puppet::Network::Server.new(:port => 31337)
     @server.stubs(:close_streams).returns(nil)
   end
 
   describe "when initializing" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
       Puppet.settings.stubs(:value).with(:bindaddress).returns("")
       Puppet.settings.stubs(:value).with(:masterport).returns('')
     end
 
     it 'should fail if an unknown option is provided' do
       lambda { Puppet::Network::Server.new(:foo => 31337) }.should raise_error(ArgumentError)
     end
 
     it "should allow specifying a listening port" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns('')
       @server = Puppet::Network::Server.new(:port => 31337)
       @server.port.should == 31337
     end
 
     it "should use the :bindaddress setting to determine the default listening address" do
       Puppet.settings.stubs(:value).with(:masterport).returns('')
       Puppet.settings.expects(:value).with(:bindaddress).returns("10.0.0.1")
       @server = Puppet::Network::Server.new
       @server.address.should == "10.0.0.1"
     end
 
     it "should set the bind address to '127.0.0.1' if the default address is an empty string and the server type is mongrel" do
       Puppet.settings.stubs(:value).with(:servertype).returns("mongrel")
       Puppet.settings.expects(:value).with(:bindaddress).returns("")
       @server = Puppet::Network::Server.new
       @server.address.should == '127.0.0.1'
     end
 
     it "should set the bind address to '0.0.0.0' if the default address is an empty string and the server type is webrick" do
       Puppet.settings.stubs(:value).with(:servertype).returns("webrick")
       Puppet.settings.expects(:value).with(:bindaddress).returns("")
       @server = Puppet::Network::Server.new
       @server.address.should == '0.0.0.0'
     end
 
     it "should use the Puppet configurator to find a default listening port" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns('')
       Puppet.settings.expects(:value).with(:masterport).returns(6667)
       @server = Puppet::Network::Server.new
       @server.port.should == 6667
     end
 
     it "should fail to initialize if no listening port can be found" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns("127.0.0.1")
       Puppet.settings.stubs(:value).with(:masterport).returns(nil)
       lambda { Puppet::Network::Server.new }.should raise_error(ArgumentError)
     end
 
     it "should use the Puppet configurator to determine which HTTP server will be used to provide access to clients" do
       Puppet.settings.expects(:value).with(:servertype).returns(:suparserver)
       @server = Puppet::Network::Server.new(:port => 31337)
       @server.server_type.should == :suparserver
     end
 
     it "should fail to initialize if there is no HTTP server known to the Puppet configurator" do
       Puppet.settings.expects(:value).with(:servertype).returns(nil)
       lambda { Puppet::Network::Server.new(:port => 31337) }.should raise_error
     end
 
     it "should ask the Puppet::Network::HTTP class to fetch the proper HTTP server class" do
       Puppet::Network::HTTP.expects(:server_class_by_type).with(:suparserver).returns(@mock_http_server_class)
       @server = Puppet::Network::Server.new(:port => 31337)
     end
 
     it "should fail if the HTTP server class is unknown" do
       Puppet::Network::HTTP.stubs(:server_class_by_type).returns(nil)
       lambda { Puppet::Network::Server.new(:port => 31337) }.should raise_error(ArgumentError)
     end
 
     it "should allow registering REST handlers" do
       @server = Puppet::Network::Server.new(:port => 31337, :handlers => [ :foo, :bar, :baz])
       lambda { @server.unregister(:foo, :bar, :baz) }.should_not raise_error
     end
 
     it "should not be listening after initialization" do
       Puppet::Network::Server.new(:port => 31337).should_not be_listening
     end
 
     it "should use the :main setting section" do
       Puppet.settings.expects(:use).with { |*args| args.include?(:main) }
       @server = Puppet::Network::Server.new(:port => 31337)
     end
 
     it "should use the :application setting section" do
-      #Puppet.settings.expects(:value).with(:name).returns "me"
       Puppet.settings.expects(:use).with { |*args| args.include?(:application) }
 
       @server = Puppet::Network::Server.new(:port => 31337)
     end
   end
 
   # We don't test the method, because it's too much of a Unix-y pain.
   it "should be able to daemonize" do
     @server.should respond_to(:daemonize)
   end
 
   describe "when being started" do
     before do
       @server.stubs(:listen)
       @server.stubs(:create_pidfile)
     end
 
     it "should listen" do
       @server.expects(:listen)
       @server.start
     end
 
     it "should create its PID file" do
       @server.expects(:create_pidfile)
       @server.start
     end
   end
 
   describe "when being stopped" do
     before do
       @server.stubs(:unlisten)
       @server.stubs(:remove_pidfile)
     end
 
     it "should unlisten" do
       @server.expects(:unlisten)
       @server.stop
     end
 
     it "should remove its PID file" do
       @server.expects(:remove_pidfile)
       @server.stop
     end
   end
 
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.run_mode.expects(:name).returns "me"
       Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.create_pidfile
     end
 
     it "should lock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile'
 
       Puppet.run_mode.expects(:name).returns "eh"
       Puppet.settings.expects(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns true
       @server.create_pidfile
     end
 
     it "should fail if it cannot lock" do
       pidfile = mock 'pidfile'
 
       Puppet.run_mode.stubs(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns false
 
       lambda { @server.create_pidfile }.should raise_error
     end
   end
 
   describe "when removing its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.run_mode.expects(:name).returns "me"
       Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.remove_pidfile
     end
 
     it "should do nothing if the pidfile is not present" do
       pidfile = mock 'pidfile', :unlock => false
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       @server.remove_pidfile
     end
 
     it "should unlock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile', :unlock => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       @server.remove_pidfile
     end
   end
 
   describe "when managing indirection registrations" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
     end
 
     it "should allow registering an indirection for client access by specifying its indirection name" do
       lambda { @server.register(:foo) }.should_not raise_error
     end
 
     it "should require that the indirection be valid" do
       Puppet::Indirector::Indirection.expects(:model).with(:foo).returns nil
       lambda { @server.register(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should require at least one indirection name when registering indirections for client access" do
       lambda { @server.register }.should raise_error(ArgumentError)
     end
 
     it "should allow for numerous indirections to be registered at once for client access" do
       lambda { @server.register(:foo, :bar, :baz) }.should_not raise_error
     end
 
     it "should allow the use of indirection names to specify which indirections are to be no longer accessible to clients" do
       @server.register(:foo)
       lambda { @server.unregister(:foo) }.should_not raise_error
     end
 
     it "should leave other indirections accessible to clients when turning off indirections" do
       @server.register(:foo, :bar)
       @server.unregister(:foo)
       lambda { @server.unregister(:bar)}.should_not raise_error
     end
 
     it "should allow specifying numerous indirections which are to be no longer accessible to clients" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:foo, :bar) }.should_not raise_error
     end
 
     it "should not turn off any indirections if given unknown indirection names to turn off" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:foo, :bar, :baz) }.should raise_error(ArgumentError)
       lambda { @server.unregister(:foo, :bar) }.should_not raise_error
     end
 
     it "should not allow turning off unknown indirection names" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:baz) }.should raise_error(ArgumentError)
     end
 
     it "should disable client access immediately when turning off indirections" do
       @server.register(:foo, :bar)
       @server.unregister(:foo)
       lambda { @server.unregister(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should allow turning off all indirections at once" do
       @server.register(:foo, :bar)
       @server.unregister
       [ :foo, :bar, :baz].each do |indirection|
         lambda { @server.unregister(indirection) }.should raise_error(ArgumentError)
       end
     end
   end
 
   it "should provide a means of determining whether it is listening" do
     @server.should respond_to(:listening?)
   end
 
   it "should provide a means of determining which HTTP server will be used to provide access to clients" do
     @server.server_type.should == :suparserver
   end
 
   it "should provide a means of determining the listening address" do
     @server.address.should == "127.0.0.1"
   end
 
   it "should provide a means of determining the listening port" do
     @server.port.should == 31337
   end
 
   it "should allow for multiple configurations, each handling different indirections" do
     Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
     @server2 = Puppet::Network::Server.new(:port => 31337)
     @server.register(:foo, :bar)
     @server2.register(:foo, :xyzzy)
     @server.unregister(:foo, :bar)
     @server2.unregister(:foo, :xyzzy)
     lambda { @server.unregister(:xyzzy) }.should raise_error(ArgumentError)
     lambda { @server2.unregister(:bar) }.should raise_error(ArgumentError)
   end
 
   describe "when listening is off" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @server.stubs(:http_server).returns(@mock_http_server)
     end
 
     it "should indicate that it is not listening" do
       @server.should_not be_listening
     end
 
     it "should not allow listening to be turned off" do
       lambda { @server.unlisten }.should raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned on" do
       lambda { @server.listen }.should_not raise_error
     end
 
   end
 
   describe "when listening is on" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @mock_http_server.stubs(:unlisten)
       @server.stubs(:http_server).returns(@mock_http_server)
       @server.listen
     end
 
     it "should indicate that it is listening" do
       @server.should be_listening
     end
 
     it "should not allow listening to be turned on" do
       lambda { @server.listen }.should raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned off" do
       lambda { @server.unlisten }.should_not raise_error
     end
   end
 
   describe "when listening is being turned on" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
       @server = Puppet::Network::Server.new(:port => 31337, :handlers => [:node])
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
     end
 
     it "should fetch an instance of an HTTP server" do
       @server.stubs(:http_server_class).returns(@mock_http_server_class)
       @mock_http_server_class.expects(:new).returns(@mock_http_server)
       @server.listen
     end
 
     it "should cause the HTTP server to listen" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen)
       @server.listen
     end
 
     it "should pass the listening address to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:address] == '127.0.0.1'
       end
       @server.listen
     end
 
     it "should pass the listening port to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:port] == 31337
       end
       @server.listen
     end
 
     it "should pass a list of REST handlers to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:handlers] == [ :node ]
       end
       @server.listen
     end
   end
 
   describe "when listening is being turned off" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @server.stubs(:http_server).returns(@mock_http_server)
       @server.listen
     end
 
     it "should cause the HTTP server to stop listening" do
       @mock_http_server.expects(:unlisten)
       @server.unlisten
     end
 
     it "should not allow for indirections to be turned off" do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
       @server.register(:foo)
       lambda { @server.unregister(:foo) }.should raise_error(RuntimeError)
     end
   end
 end
diff --git a/spec/unit/util/settings_spec.rb b/spec/unit/util/settings_spec.rb
index d8b3af2d6..57f94f430 100755
--- a/spec/unit/util/settings_spec.rb
+++ b/spec/unit/util/settings_spec.rb
@@ -1,1245 +1,1241 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'ostruct'
 
 describe Puppet::Util::Settings do
   include PuppetSpec::Files
 
   MAIN_CONFIG_FILE_DEFAULT_LOCATION = File.join(Puppet::Util::Settings.default_global_config_dir, "puppet.conf")
   USER_CONFIG_FILE_DEFAULT_LOCATION = File.join(Puppet::Util::Settings.default_user_config_dir, "puppet.conf")
 
   describe "when specifying defaults" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     it "should start with no defined parameters" do
       @settings.params.length.should == 0
     end
 
     it "should not allow specification of default values associated with a section as an array" do
       expect {
         @settings.define_settings(:section, :myvalue => ["defaultval", "my description"])
       }.to raise_error
     end
 
     it "should not allow duplicate parameter specifications" do
       @settings.define_settings(:section, :myvalue => { :default => "a", :desc => "b" })
       lambda { @settings.define_settings(:section, :myvalue => { :default => "c", :desc => "d" }) }.should raise_error(ArgumentError)
     end
 
     it "should allow specification of default values associated with a section as a hash" do
       @settings.define_settings(:section, :myvalue => {:default => "defaultval", :desc => "my description"})
     end
 
     it "should consider defined parameters to be valid" do
       @settings.define_settings(:section, :myvalue => { :default => "defaultval", :desc => "my description" })
       @settings.valid?(:myvalue).should be_true
     end
 
     it "should require a description when defaults are specified with a hash" do
       lambda { @settings.define_settings(:section, :myvalue => {:default => "a value"}) }.should raise_error(ArgumentError)
     end
 
     it "should support specifying owner, group, and mode when specifying files" do
       @settings.define_settings(:section, :myvalue => {:type => :file, :default => "/some/file", :owner => "service", :mode => "boo", :group => "service", :desc => "whatever"})
     end
 
     it "should support specifying a short name" do
       @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
     end
 
     it "should support specifying the setting type" do
       @settings.define_settings(:section, :myvalue => {:default => "/w", :desc => "b", :type => :string})
       @settings.setting(:myvalue).should be_instance_of(Puppet::Util::Settings::StringSetting)
     end
 
     it "should fail if an invalid setting type is specified" do
       lambda { @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :type => :foo}) }.should raise_error(ArgumentError)
     end
 
     it "should fail when short names conflict" do
       @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
       lambda { @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError)
     end
   end
 
 
   describe "when initializing application defaults do" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     it "should fail if someone attempts to initialize app defaults more than once" do
       @settings.expects(:app_defaults_initialized?).returns(true)
       expect {
         @settings.initialize_app_defaults({})
       }.to raise_error(Puppet::DevError)
     end
 
     it "should fail if the app defaults hash is missing any required values" do
       expect {
         @settings.initialize_app_defaults({})
       }.to raise_error(Puppet::SettingsError)
     end
 
     # ultimately I'd like to stop treating "run_mode" as a normal setting, because it has so many special
     #  case behaviors / uses.  However, until that time... we need to make sure that our private run_mode=
     #  setter method gets properly called during app initialization.
     it "should call the hacky run mode setter method until we do a better job of separating run_mode" do
       app_defaults = {}
       Puppet::Util::Settings::REQUIRED_APP_SETTINGS.each do |key|
         app_defaults[key] = "foo"
       end
 
       @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
       @settings.expects(:run_mode=).with("foo")
       @settings.initialize_app_defaults(app_defaults)
     end
   end
 
   describe "when setting values" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :main, :myval => { :default => "val", :desc => "desc" }
       @settings.define_settings :main, :bool => { :type => :boolean, :default => true, :desc => "desc" }
     end
 
     it "should provide a method for setting values from other objects" do
       @settings[:myval] = "something else"
       @settings[:myval].should == "something else"
     end
 
     it "should support a getopt-specific mechanism for setting values" do
       @settings.handlearg("--myval", "newval")
       @settings[:myval].should == "newval"
     end
 
     it "should support a getopt-specific mechanism for turning booleans off" do
       @settings[:bool] = true
       @settings.handlearg("--no-bool", "")
       @settings[:bool].should == false
     end
 
     it "should support a getopt-specific mechanism for turning booleans on" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with no argument to be a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with an empty string as an argument to be a boolean, if the setting itself is a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with an empty string as an argument to be an empty argument, if the setting itself is not a boolean" do
       @settings[:myval] = "bob"
       @settings.handlearg("--myval", "")
       @settings[:myval].should == ""
     end
 
     it "should consider a cli setting with a boolean as an argument to be a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "true")
       @settings[:bool].should == true
     end
 
     it "should not consider a cli setting of a non boolean with a boolean as an argument to be a boolean" do
       # Turn it off first
       @settings[:myval] = "bob"
       @settings.handlearg("--no-myval", "")
       @settings[:myval].should == ""
     end
 
     it "should flag string settings from the CLI" do
       @settings.handlearg("--myval", "12")
       @settings.set_by_cli?(:myval).should be_true
     end
 
     it "should flag bool settings from the CLI" do
       @settings[:bool] = false
       @settings.handlearg("--bool")
       @settings.set_by_cli?(:bool).should be_true
     end
 
     it "should not flag settings memory as from CLI" do
       @settings[:myval] = "12"
       @settings.set_by_cli?(:myval).should be_false
     end
     
     describe "setbycli" do
       it "should generate a deprecation warning" do
         Puppet.expects(:deprecation_warning)
         @settings.setting(:myval).setbycli = true
       end
       it "should set the value" do
         @settings[:myval] = "blah"
         @settings.setting(:myval).setbycli = true
         @settings.set_by_cli?(:myval).should be_true
       end
       it "should raise error if trying to unset value" do
         @settings.handlearg("--myval", "blah")
         expect do
           @settings.setting(:myval).setbycli = nil
         end.to raise_error ArgumentError, /unset/
       end
     end
 
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
           :two => { :default => "$one yay", :desc => "bah" }
       @settings[:two].should == "whah yay"
       @settings.handlearg("--one", "else")
       @settings[:two].should == "else yay"
     end
 
     it "should not clear other values when setting getopt-specific values" do
       @settings[:myval] = "yay"
       @settings.handlearg("--no-bool", "")
       @settings[:myval].should == "yay"
     end
 
     it "should clear the list of used sections" do
       @settings.expects(:clearused)
       @settings[:myval] = "yay"
     end
 
     it "should call passed blocks when values are set" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       values.should == []
 
       @settings[:hooker] = "something"
       values.should == %w{something}
     end
 
     it "should call passed blocks when values are set via the command line" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       values.should == []
 
       @settings.handlearg("--hooker", "yay")
 
       values.should == %w{yay}
     end
 
     it "should provide an option to call passed blocks during definition" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }})
       values.should == %w{yay}
     end
 
     it "should pass the fully interpolated value to the hook when called on definition" do
       values = []
       @settings.define_settings(:section, :one => { :default => "test", :desc => "a" })
       @settings.define_settings(:section, :hooker => {:default => "$one/yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }})
       values.should == %w{test/yay}
     end
 
     it "should munge values using the setting-specific methods" do
       @settings[:bool] = "false"
       @settings[:bool].should == false
     end
 
     it "should prefer cli values to values set in Ruby code" do
       @settings.handlearg("--myval", "cliarg")
       @settings[:myval] = "memarg"
       @settings[:myval].should == "cliarg"
     end
 
     it "should clear the list of environments" do
       Puppet::Node::Environment.expects(:clear).at_least(1)
       @settings[:myval] = "memarg"
     end
 
-    it "should raise an error if we try to set 'name'" do
-      lambda{ @settings[:name] = "foo" }.should raise_error(ArgumentError)
-    end
-
     it "should raise an error if we try to set 'run_mode'" do
       lambda{ @settings[:run_mode] = "foo" }.should raise_error(ArgumentError)
     end
 
     it "should warn and use [master] if we ask for [puppetmasterd]" do
       Puppet.expects(:deprecation_warning)
       @settings.set_value(:myval, "foo", :puppetmasterd)
 
       @settings.stubs(:run_mode).returns(:master)
       @settings.value(:myval).should == "foo"
     end
 
     it "should warn and use [agent] if we ask for [puppetd]" do
       Puppet.expects(:deprecation_warning)
       @settings.set_value(:myval, "foo", :puppetd)
 
       @settings.stubs(:run_mode).returns(:agent)
       @settings.value(:myval).should == "foo"
     end
   end
 
   describe "when returning values" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/my/file", :desc => "eh" },
           :one    => { :default => "ONE", :desc => "a" },
           :two    => { :default => "$one TWO", :desc => "b"},
           :three  => { :default => "$one $two THREE", :desc => "c"},
           :four   => { :default => "$two $three FOUR", :desc => "d"}
       FileTest.stubs(:exist?).returns true
     end
 
     it "should provide a mechanism for returning set values" do
       @settings[:one] = "other"
       @settings[:one].should == "other"
     end
 
     it "should interpolate default values for other parameters into returned parameter values" do
       @settings[:one].should == "ONE"
       @settings[:two].should == "ONE TWO"
       @settings[:three].should == "ONE ONE TWO THREE"
     end
 
     it "should interpolate default values that themselves need to be interpolated" do
       @settings[:four].should == "ONE TWO ONE ONE TWO THREE FOUR"
     end
 
     it "should provide a method for returning uninterpolated values" do
       @settings[:two] = "$one tw0"
       @settings.uninterpolated_value(:two).should  == "$one tw0"
       @settings.uninterpolated_value(:four).should == "$two $three FOUR"
     end
 
     it "should interpolate set values for other parameters into returned parameter values" do
       @settings[:one] = "on3"
       @settings[:two] = "$one tw0"
       @settings[:three] = "$one $two thr33"
       @settings[:four] = "$one $two $three f0ur"
       @settings[:one].should == "on3"
       @settings[:two].should == "on3 tw0"
       @settings[:three].should == "on3 on3 tw0 thr33"
       @settings[:four].should == "on3 on3 tw0 on3 on3 tw0 thr33 f0ur"
     end
 
     it "should not cache interpolated values such that stale information is returned" do
       @settings[:two].should == "ONE TWO"
       @settings[:one] = "one"
       @settings[:two].should == "one TWO"
     end
 
     it "should not cache values such that information from one environment is returned for another environment" do
       text = "[env1]\none = oneval\n[env2]\none = twoval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
 
       @settings.value(:one, "env1").should == "oneval"
       @settings.value(:one, "env2").should == "twoval"
     end
 
     it "should have a run_mode that defaults to user" do
       @settings.run_mode.should == :user
     end
     describe "setbycli" do
       it "should generate a deprecation warning" do
         @settings.handlearg("--one", "blah")
         Puppet.expects(:deprecation_warning)
         @settings.setting(:one).setbycli
       end
       it "should be true" do
         @settings.handlearg("--one", "blah")
         @settings.setting(:one).setbycli.should be_true
       end
     end
   end
 
   describe "when choosing which value to return" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
         :config => { :type => :file, :default => "/my/file", :desc => "a" },
         :one => { :default => "ONE", :desc => "a" },
         :two => { :default => "TWO", :desc => "b" }
       FileTest.stubs(:exist?).returns true
       @settings.stubs(:run_mode).returns :mymode
     end
 
     it "should return default values if no values have been set" do
       @settings[:one].should == "ONE"
     end
 
     it "should return values set on the cli before values set in the configuration file" do
       text = "[main]\none = fileval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.handlearg("--one", "clival")
       @settings.parse
 
       @settings[:one].should == "clival"
     end
 
     it "should return values set on the cli before values set in Ruby" do
       @settings[:one] = "rubyval"
       @settings.handlearg("--one", "clival")
       @settings[:one].should == "clival"
     end
 
     it "should return values set in the mode-specific section before values set in the main section" do
       text = "[main]\none = mainval\n[mymode]\none = modeval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
 
       @settings[:one].should == "modeval"
     end
 
     it "should not return values outside of its search path" do
       text = "[other]\none = oval\n"
       file = "/some/file"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
       @settings[:one].should == "ONE"
     end
 
     it "should return values in a specified environment" do
       text = "[env]\none = envval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
       @settings.value(:one, "env").should == "envval"
     end
 
     it 'should use the current environment for $environment' do
       @settings.define_settings :main, :myval => { :default => "$environment/foo", :desc => "mydocs" }
 
       @settings.value(:myval, "myenv").should == "myenv/foo"
     end
 
     it "should interpolate found values using the current environment" do
       text = "[main]\none = mainval\n[myname]\none = nameval\ntwo = $one/two\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
 
       @settings.value(:two, "myname").should == "nameval/two"
     end
 
     it "should return values in a specified environment before values in the main or name sections" do
       text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
       @settings.value(:one, "env").should == "envval"
     end
   end
 
 
   describe "when locating config files" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     describe "when root" do
       it "should look for #{MAIN_CONFIG_FILE_DEFAULT_LOCATION} if config settings haven't been overridden'" do
         Puppet.features.stubs(:root?).returns(true)
         FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(false)
         FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).never
 
         @settings.parse()
       end
     end
 
     describe "when not root" do
       it "should look for #{MAIN_CONFIG_FILE_DEFAULT_LOCATION} and #{USER_CONFIG_FILE_DEFAULT_LOCATION} if config settings haven't been overridden'" do
         Puppet.features.stubs(:root?).returns(false)
 
         seq = sequence "load config files"
         FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(false).in_sequence(seq)
         FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(false).in_sequence(seq)
 
         @settings.parse()
       end
     end
   end
 
   describe "when parsing its configuration" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @file = "/some/file"
       @settings.define_settings :section, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/some/file", :desc => "eh" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
       @settings.stubs(:user_config_file).returns("/test/userconfigfile")
       FileTest.stubs(:exist?).with("/some/file").returns true
       FileTest.stubs(:exist?).with("/test/userconfigfile").returns false
     end
 
     it "should not ignore the report setting" do
       @settings.define_settings :section, :report => { :default => "false", :desc => "a" }
       # This is needed in order to make sure we pass on windows
       myfile = File.expand_path("/my/file")
       @settings[:config] = myfile
       text = <<-CONF
         [puppetd]
           report=true
       CONF
       FileTest.expects(:exist?).with(myfile).returns(true)
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:report].should be_true
     end
 
     it "should use its current ':config' value for the file to parse" do
       myfile = make_absolute("/my/file") # do not stub expand_path here, as this leads to a stack overflow, when mocha tries to use it
       @settings[:config] = myfile
 
       FileTest.expects(:exist?).with(myfile).returns(true)
 
       File.expects(:read).with(myfile).returns "[main]"
 
       @settings.parse
     end
 
     it "should not try to parse non-existent files" do
       FileTest.expects(:exist?).with("/some/file").returns false
 
       File.expects(:read).with("/some/file").never
 
       @settings.parse
     end
 
     it "should return values set in the configuration file" do
       text = "[main]
       one = fileval
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:one].should == "fileval"
     end
 
     #484 - this should probably be in the regression area
     it "should not throw an exception on unknown parameters" do
       text = "[main]\nnosuchparam = mval\n"
       @settings.expects(:read_file).returns(text)
       lambda { @settings.parse }.should_not raise_error
     end
 
     it "should convert booleans in the configuration file into Ruby booleans" do
       text = "[main]
       one = true
       two = false
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:one].should == true
       @settings[:two].should == false
     end
 
     it "should convert integers in the configuration file into Ruby Integers" do
       text = "[main]
       one = 65
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:one].should == 65
     end
 
     it "should support specifying all metadata (owner, group, mode) in the configuration file" do
       @settings.define_settings :section, :myfile => { :type => :file, :default => "/myfile", :desc => "a" }
 
       otherfile = make_absolute("/other/file")
       text = "[main]
       myfile = #{otherfile} {owner = service, group = service, mode = 644}
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:myfile].should == otherfile
       @settings.metadata(:myfile).should == {:owner => "suser", :group => "sgroup", :mode => "644"}
     end
 
     it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do
       @settings.define_settings :section, :myfile => { :type => :file, :default => "/myfile", :desc => "a" }
 
       otherfile = make_absolute("/other/file")
       text = "[main]
       myfile = #{otherfile} {owner = service}
       "
       file = "/some/file"
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:myfile].should == otherfile
       @settings.metadata(:myfile).should == {:owner => "suser"}
     end
 
     it "should call hooks associated with values set in the configuration file" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[main]
       mysetting = setval
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       values.should == ["setval"]
     end
 
     it "should not call the same hook for values set multiple times in the configuration file" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[user]
       mysetting = setval
       [main]
       mysetting = other
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       values.should == ["setval"]
     end
 
     it "should pass the environment-specific value to the hook when one is available" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
       @settings.define_settings :section, :environment => { :default => "yay", :desc => "a" }
       @settings.define_settings :section, :environments => { :default => "yay,foo", :desc => "a" }
 
       text = "[main]
       mysetting = setval
       [yay]
       mysetting = other
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       values.should == ["other"]
     end
 
     it "should pass the interpolated value to the hook when one is available" do
       values = []
       @settings.define_settings :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }}
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[main]
       mysetting = $base/setval
       "
       @settings.expects(:read_file).returns(text)
       @settings.parse
       values.should == ["yay/setval"]
     end
 
     it "should allow empty values" do
       @settings.define_settings :section, :myarg => { :default => "myfile", :desc => "a" }
 
       text = "[main]
       myarg =
       "
       @settings.stubs(:read_file).returns(text)
       @settings.parse
       @settings[:myarg].should == ""
     end
 
     describe "and when reading a non-positive filetimeout value from the config file" do
       before do
         @settings.define_settings :foo, :filetimeout => { :default => 5, :desc => "eh" }
 
         somefile = "/some/file"
         text = "[main]
         filetimeout = -1
         "
         File.expects(:read).with(somefile).returns(text)
         File.expects(:expand_path).with(somefile).returns somefile
         @settings[:config] = somefile
       end
     end
 
   end
 
 
   describe "when there are multiple config files" do
     let(:main_config_text) { "[main]\none = main\ntwo = main2" }
     let(:user_config_text) { "[main]\none = user\n" }
     let(:seq) { sequence "config_file_sequence" }
 
     before do
       Puppet.features.stubs(:root?).returns(false)
       @settings = Puppet::Util::Settings.new
       @settings.define_settings(:section,
           { :one => { :default => "ONE", :desc => "a" },
             :two => { :default => "TWO", :desc => "b" }, })
       FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(true).in_sequence(seq)
       @settings.expects(:read_file).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(main_config_text).in_sequence(seq)
       FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(true).in_sequence(seq)
       @settings.expects(:read_file).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(user_config_text).in_sequence(seq)
     end
 
     it "should return values from the config file in the user's home dir before values set in the main configuration file" do
       @settings.parse
       @settings[:one].should == "user"
     end
 
     it "should return values from the main config file if they aren't overridden in the config file in the user's home dir" do
       @settings.parse
       @settings[:two].should == "main2"
     end
 
   end
 
   describe "when reparsing its configuration" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/test/file", :desc => "a" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
       FileTest.stubs(:exist?).with("/test/file").returns true
       FileTest.stubs(:exist?).with("/test/userconfigfile").returns false
       @settings.stubs(:user_config_file).returns("/test/userconfigfile")
     end
 
     it "should use a LoadedFile instance to determine if the file has changed" do
       file = mock 'file'
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?)
 
       @settings.stubs(:parse)
       @settings.reparse
     end
 
     it "should not create the LoadedFile instance and should not parse if the file does not exist" do
       FileTest.expects(:exist?).with("/test/file").returns false
       Puppet::Util::LoadedFile.expects(:new).never
 
       @settings.expects(:parse).never
 
       @settings.reparse
     end
 
     it "should not reparse if the file has not changed" do
       file = mock 'file'
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?).returns false
 
       @settings.expects(:parse).never
 
       @settings.reparse
     end
 
     it "should reparse if the file has changed" do
       file = stub 'file', :file => "/test/file"
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?).returns true
 
       @settings.expects(:parse)
 
       @settings.reparse
     end
 
     it "should replace in-memory values with on-file values" do
       # Init the value
       text = "[main]\none = disk-init\n"
       file = mock 'file'
       file.stubs(:changed?).returns(true)
       file.stubs(:file).returns("/test/file")
       @settings[:one] = "init"
       @settings.files = [file]
 
       # Now replace the value
       text = "[main]\none = disk-replace\n"
 
       # This is kinda ridiculous - the reason it parses twice is that
       # it goes to parse again when we ask for the value, because the
       # mock always says it should get reparsed.
       @settings.stubs(:read_file).returns(text)
       @settings.reparse
       @settings[:one].should == "disk-replace"
     end
 
     it "should retain parameters set by cli when configuration files are reparsed" do
       @settings.handlearg("--one", "clival")
 
       text = "[main]\none = on-disk\n"
       @settings.stubs(:read_file).returns(text)
       @settings.parse
 
       @settings[:one].should == "clival"
     end
 
     it "should remove in-memory values that are no longer set in the file" do
       # Init the value
       text = "[main]\none = disk-init\n"
       @settings.expects(:read_file).returns(text)
       @settings.parse
       @settings[:one].should == "disk-init"
 
       # Now replace the value
       text = "[main]\ntwo = disk-replace\n"
       @settings.expects(:read_file).returns(text)
       @settings.parse
 
       # The originally-overridden value should be replaced with the default
       @settings[:one].should == "ONE"
 
       # and we should now have the new value in memory
       @settings[:two].should == "disk-replace"
     end
 
     it "should retain in-memory values if the file has a syntax error" do
       # Init the value
       text = "[main]\none = initial-value\n"
       @settings.expects(:read_file).with("/test/file").returns(text)
       @settings.parse
       @settings[:one].should == "initial-value"
 
       # Now replace the value with something bogus
       text = "[main]\nkenny = killed-by-what-follows\n1 is 2, blah blah florp\n"
       @settings.expects(:read_file).with("/test/file").returns(text)
       @settings.parse
 
       # The originally-overridden value should not be replaced with the default
       @settings[:one].should == "initial-value"
 
       # and we should not have the new value in memory
       @settings[:kenny].should be_nil
     end
   end
 
   it "should provide a method for creating a catalog of resources from its configuration" do
     Puppet::Util::Settings.new.should respond_to(:to_catalog)
   end
 
   describe "when creating a catalog" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @prefix = Puppet.features.posix? ? "" : "C:"
     end
 
     it "should add all file resources to the catalog if no sections have been specified" do
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => @prefix+"/seconddir", :desc => "a"}
       @settings.define_settings :other,
           :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
 
       catalog = @settings.to_catalog
 
       [@prefix+"/maindir", @prefix+"/seconddir", @prefix+"/otherdir"].each do |path|
         catalog.resource(:file, path).should be_instance_of(Puppet::Resource)
       end
     end
 
     it "should add only files in the specified sections if section names are provided" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
       catalog = @settings.to_catalog(:main)
       catalog.resource(:file, @prefix+"/otherdir").should be_nil
       catalog.resource(:file, @prefix+"/maindir").should be_instance_of(Puppet::Resource)
     end
 
     it "should not try to add the same file twice" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       lambda { @settings.to_catalog }.should_not raise_error
     end
 
     it "should ignore files whose :to_resource method returns nil" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.setting(:maindir).expects(:to_resource).returns nil
 
       Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
       @settings.to_catalog
     end
 
     describe "on Microsoft Windows" do
       before :each do
         Puppet.features.stubs(:root?).returns true
         Puppet.features.stubs(:microsoft_windows?).returns true
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
             :user => { :default => "suser", :desc => "doc" },
             :group => { :default => "sgroup", :desc => "doc" }
         @settings.define_settings :other,
             :otherdir => { :type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         @catalog = @settings.to_catalog
       end
 
       it "it should not add users and groups to the catalog" do
         @catalog.resource(:user, "suser").should be_nil
         @catalog.resource(:group, "sgroup").should be_nil
       end
     end
 
     describe "when adding users and groups to the catalog" do
       before do
         Puppet.features.stubs(:root?).returns true
         Puppet.features.stubs(:microsoft_windows?).returns false
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
             :user => { :default => "suser", :desc => "doc" },
             :group => { :default => "sgroup", :desc => "doc" }
         @settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         @catalog = @settings.to_catalog
       end
 
       it "should add each specified user and group to the catalog if :mkusers is a valid setting, is enabled, and we're running as root" do
         @catalog.resource(:user, "suser").should be_instance_of(Puppet::Resource)
         @catalog.resource(:group, "sgroup").should be_instance_of(Puppet::Resource)
       end
 
       it "should only add users and groups to the catalog from specified sections" do
         @settings.define_settings :yay, :yaydir => { :type => :directory, :default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
         catalog = @settings.to_catalog(:other)
         catalog.resource(:user, "jane").should be_nil
         catalog.resource(:group, "billy").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers not running as root" do
         Puppet.features.stubs(:root?).returns false
 
         catalog = @settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers is not a valid setting" do
         Puppet.features.stubs(:root?).returns true
         settings = Puppet::Util::Settings.new
         settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         catalog = settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers is a valid setting but is disabled" do
         @settings[:mkusers] = false
 
         catalog = @settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not try to add users or groups to the catalog twice" do
         @settings.define_settings :yay, :yaydir => {:type => :directory, :default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
 
         # This would fail if users/groups were added twice
         lambda { @settings.to_catalog }.should_not raise_error
       end
 
       it "should set :ensure to :present on each created user and group" do
         @catalog.resource(:user, "suser")[:ensure].should == :present
         @catalog.resource(:group, "sgroup")[:ensure].should == :present
       end
 
       it "should set each created user's :gid to the service group" do
         @settings.to_catalog.resource(:user, "suser")[:gid].should == "sgroup"
       end
 
       it "should not attempt to manage the root user" do
         Puppet.features.stubs(:root?).returns true
         @settings.define_settings :foo, :foodir => {:type => :directory, :default => "/foodir", :desc => "a", :owner => "root", :group => "service"}
 
         @settings.to_catalog.resource(:user, "root").should be_nil
       end
     end
   end
 
   it "should be able to be converted to a manifest" do
     Puppet::Util::Settings.new.should respond_to(:to_manifest)
   end
 
   describe "when being converted to a manifest" do
     it "should produce a string with the code for each resource joined by two carriage returns" do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
 
       main = stub 'main_resource', :ref => "File[/maindir]"
       main.expects(:to_manifest).returns "maindir"
       second = stub 'second_resource', :ref => "File[/seconddir]"
       second.expects(:to_manifest).returns "seconddir"
       @settings.setting(:maindir).expects(:to_resource).returns main
       @settings.setting(:seconddir).expects(:to_resource).returns second
 
       @settings.to_manifest.split("\n\n").sort.should == %w{maindir seconddir}
     end
   end
 
   describe "when using sections of the configuration to manage the local host" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @settings.define_settings :main, :noop => { :default => false, :desc => "", :type => :boolean }
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a" },
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
       @settings.define_settings :main, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
       @settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service", :mode => 0755}
       @settings.define_settings :third, :thirddir => { :type => :directory, :default => "/thirddir", :desc => "b"}
       @settings.define_settings :files, :myfile => {:type => :file, :default => "/myfile", :desc => "a", :mode => 0755}
     end
 
     it "should provide a method that writes files with the correct modes" do
       @settings.should respond_to(:write)
     end
 
     it "should provide a method that creates directories with the correct modes" do
       Puppet::Util::SUIDManager.expects(:asuser).with("suser", "sgroup").yields
       Dir.expects(:mkdir).with("/otherdir", 0755)
       @settings.mkdir(:otherdir)
     end
 
     it "should create a catalog with the specified sections" do
       @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main, :other)
     end
 
     it "should canonicalize the sections" do
       @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use("main", "other")
     end
 
     it "should ignore sections that have already been used" do
       @settings.expects(:to_catalog).with(:main).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main)
       @settings.expects(:to_catalog).with(:other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main, :other)
     end
 
     it "should ignore tags and schedules when creating files and directories"
 
     it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do
       pending "Not converted from test/unit yet"
     end
 
     it "should convert the created catalog to a RAL catalog" do
       @catalog = Puppet::Resource::Catalog.new("foo")
       @settings.expects(:to_catalog).with(:main).returns @catalog
 
       @catalog.expects(:to_ral).returns @catalog
       @settings.use(:main)
     end
 
     it "should specify that it is not managing a host catalog" do
       catalog = Puppet::Resource::Catalog.new("foo")
       catalog.expects(:apply)
       @settings.expects(:to_catalog).returns catalog
 
       catalog.stubs(:to_ral).returns catalog
 
       catalog.expects(:host_config=).with false
 
       @settings.use(:main)
     end
 
     it "should support a method for re-using all currently used sections" do
       @settings.expects(:to_catalog).with(:main, :third).times(2).returns Puppet::Resource::Catalog.new("foo")
 
       @settings.use(:main, :third)
       @settings.reuse
     end
 
     it "should fail with an appropriate message if any resources fail" do
       @catalog = Puppet::Resource::Catalog.new("foo")
       @catalog.stubs(:to_ral).returns @catalog
       @settings.expects(:to_catalog).returns @catalog
 
       @trans = mock("transaction")
       @catalog.expects(:apply).yields(@trans)
 
       @trans.expects(:any_failed?).returns(true)
 
       report = mock 'report'
       @trans.expects(:report).returns report
 
       log = mock 'log', :to_s => "My failure", :level => :err
       report.expects(:logs).returns [log]
 
       @settings.expects(:raise).with { |msg| msg.include?("My failure") }
       @settings.use(:whatever)
     end
   end
 
   describe "when dealing with printing configs" do
     before do
       @settings = Puppet::Util::Settings.new
       #these are the magic default values
       @settings.stubs(:value).with(:configprint).returns("")
       @settings.stubs(:value).with(:genconfig).returns(false)
       @settings.stubs(:value).with(:genmanifest).returns(false)
       @settings.stubs(:value).with(:environment).returns(nil)
     end
 
     describe "when checking print_config?" do
       it "should return false when the :configprint, :genconfig and :genmanifest are not set" do
         @settings.print_configs?.should be_false
       end
 
       it "should return true when :configprint has a value" do
         @settings.stubs(:value).with(:configprint).returns("something")
         @settings.print_configs?.should be_true
       end
 
       it "should return true when :genconfig has a value" do
         @settings.stubs(:value).with(:genconfig).returns(true)
         @settings.print_configs?.should be_true
       end
 
       it "should return true when :genmanifest has a value" do
         @settings.stubs(:value).with(:genmanifest).returns(true)
         @settings.print_configs?.should be_true
       end
     end
 
     describe "when printing configs" do
       describe "when :configprint has a value" do
         it "should call print_config_options" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.expects(:print_config_options)
           @settings.print_configs
         end
 
         it "should get the value of the option using the environment" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.expects(:value).with(:environment).returns("env")
           @settings.expects(:value).with("something", "env").returns("foo")
           @settings.stubs(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value of the option" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.stubs(:value).with("something", nil).returns("foo")
           @settings.expects(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value pairs if there are multiple options" do
           @settings.stubs(:value).with(:configprint).returns("bar,baz")
           @settings.stubs(:include?).with("bar").returns(true)
           @settings.stubs(:include?).with("baz").returns(true)
           @settings.stubs(:value).with("bar", nil).returns("foo")
           @settings.stubs(:value).with("baz", nil).returns("fud")
           @settings.expects(:puts).with("bar = foo")
           @settings.expects(:puts).with("baz = fud")
           @settings.print_configs
         end
 
         it "should print a whole bunch of stuff if :configprint = all"
 
         it "should return true after printing" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.stubs(:value).with("something", nil).returns("foo")
           @settings.stubs(:puts).with("foo")
           @settings.print_configs.should be_true
         end
 
         it "should return false if a config param is not found" do
           @settings.stubs :puts
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(false)
           @settings.print_configs.should be_false
         end
       end
 
       describe "when genconfig is true" do
         before do
           @settings.stubs :puts
         end
 
         it "should call to_config" do
           @settings.stubs(:value).with(:genconfig).returns(true)
           @settings.expects(:to_config)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
           @settings.stubs(:value).with(:genconfig).returns(true)
           @settings.stubs(:to_config)
           @settings.print_configs.should be_true
         end
       end
 
       describe "when genmanifest is true" do
         before do
           @settings.stubs :puts
         end
 
         it "should call to_config" do
           @settings.stubs(:value).with(:genmanifest).returns(true)
           @settings.expects(:to_manifest)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
           @settings.stubs(:value).with(:genmanifest).returns(true)
           @settings.stubs(:to_manifest)
           @settings.print_configs.should be_true
         end
       end
     end
   end
 
   describe "when determining if the service user is available" do
     it "should return false if there is no user setting" do
       Puppet::Util::Settings.new.should_not be_service_user_available
     end
 
     it "should return false if the user provider says the user is missing" do
       settings = Puppet::Util::Settings.new
       settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
 
       user = mock 'user'
       user.expects(:exists?).returns false
 
       Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
 
       settings.should_not be_service_user_available
     end
 
     it "should return true if the user provider says the user is present" do
       settings = Puppet::Util::Settings.new
       settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
 
       user = mock 'user'
       user.expects(:exists?).returns true
 
       Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
 
       settings.should be_service_user_available
     end
 
     it "should cache the result"
   end
 
   describe "#writesub" do
     it "should only pass valid arguments to File.open" do
       settings = Puppet::Util::Settings.new
       settings.stubs(:get_config_file_default).with(:privatekeydir).returns(OpenStruct.new(:mode => "750"))
 
       File.expects(:open).with("/path/to/keydir", "w", 750).returns true
       settings.writesub(:privatekeydir, "/path/to/keydir")
     end
   end
 end