diff --git a/lib/puppet.rb b/lib/puppet.rb
index 2cbf7fb29..4e0266703 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -1,181 +1,178 @@
 # Try to load rubygems.  Hey rubygems, I hate you.
 begin
     require 'rubygems'
 rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
 require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
 require 'puppet/util/log'
 require 'puppet/util/autoload'
 require 'puppet/util/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
 
 #------------------------------------------------------------
 # the top-level module
 #
 # all this really does is dictate how the whole system behaves, through
 # preferences for things like debugging
 #
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
     PUPPETVERSION = '0.24.7'
 
     def Puppet.version
         return PUPPETVERSION
     end
 
     class << self
         include Puppet::Util
         attr_reader :features
         attr_writer :name
     end
 
     # the hash that determines how our system behaves
     @@settings = Puppet::Util::Settings.new
 
     # The services running in this process.
     @services ||= []
 
     # define helper messages for each of the message levels
     Puppet::Util::Log.eachlevel { |level|
         define_method(level,proc { |args|
             if args.is_a?(Array)
                 args = args.join(" ")
             end
             Puppet::Util::Log.create(
                 :level => level,
                 :message => args
             )
         })
         module_function level
     }
 
     # I keep wanting to use Puppet.error
     # XXX this isn't actually working right now
     alias :error :err
     
     # The feature collection
     @features = Puppet::Util::Feature.new('puppet/feature')
 
     # Load the base features.
     require 'puppet/feature/base'
 
     # Store a new default value.
     def self.setdefaults(section, hash)
         @@settings.setdefaults(section, hash)
     end
 
 	# configuration parameter access and stuff
 	def self.[](param)
         case param
         when :debug:
             if Puppet::Util::Log.level == :debug
                 return true
             else
                 return false
             end
         else
             return @@settings[param]
         end
 	end
 
 	# configuration parameter access and stuff
 	def self.[]=(param,value)
         @@settings[param] = value
 	end
 
     def self.clear
         @@settings.clear
     end
 
     def self.debug=(value)
         if value
             Puppet::Util::Log.level=(:debug)
         else
             Puppet::Util::Log.level=(:notice)
         end
     end
 
     def self.settings
         @@settings
     end
 
     # Load all of the configuration parameters.
     require 'puppet/defaults'
 
     def self.genmanifest
         if Puppet[:genmanifest]
             puts Puppet.settings.to_manifest
             exit(0)
         end
     end
 
     # Parse the config file for this process.
     def self.parse_config
-        if Puppet[:config] and File.exists? Puppet[:config]
-            Puppet.debug "Parsing %s" % Puppet[:config]
-            Puppet.settings.parse(Puppet[:config])
-        end
+        Puppet.settings.parse
     end
 
     # XXX this should all be done using puppet objects, not using
     # normal mkdir
     def self.recmkdir(dir,mode = 0755)
         if FileTest.exist?(dir)
             return false
         else
             tmp = dir.sub(/^\//,'')
             path = [File::SEPARATOR]
             tmp.split(File::SEPARATOR).each { |dir|
                 path.push dir
                 if ! FileTest.exist?(File.join(path))
                     begin
                         Dir.mkdir(File.join(path), mode)
                     rescue Errno::EACCES => detail
                         Puppet.err detail.to_s
                         return false
                     rescue => detail
                         Puppet.err "Could not create %s: %s" % [path, detail.to_s]
                         return false
                     end
                 elsif FileTest.directory?(File.join(path))
                     next
                 else FileTest.exist?(File.join(path))
                     raise Puppet::Error, "Cannot create %s: basedir %s is a file" %
                         [dir, File.join(path)]
                 end
             }
             return true
         end
     end
 
     # Create a new type.  Just proxy to the Type class.
     def self.newtype(name, options = {}, &block)
         Puppet::Type.newtype(name, options, &block)
     end
 
     # Retrieve a type by name.  Just proxy to the Type class.
     def self.type(name)
         # LAK:DEP Deprecation notice added 12/17/2008
         Puppet.warning "Puppet.type is deprecated; use Puppet::Type.type"
         Puppet::Type.type(name)
     end
 end
 
 require 'puppet/type'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
 require 'puppet/util/storage'
 require 'puppet/parser/interpreter'
 
 if Puppet[:storeconfigs]
     require 'puppet/rails'
 end
 
diff --git a/lib/puppet/application.rb b/lib/puppet/application.rb
index 3f3b2e10e..88ad9d493 100644
--- a/lib/puppet/application.rb
+++ b/lib/puppet/application.rb
@@ -1,302 +1,302 @@
 require 'puppet'
 require 'optparse'
 
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
 # * setting up logs
 # * choosing what to run
 #
 # === Usage
 # The application is a Puppet::Application object that register itself in the list
 # of available application. Each application needs a +name+ and a getopt +options+
 # description array.
 #
 # The executable uses the application object like this:
 #      Puppet::Application[:example].run
 #
 # 
 # Puppet::Application.new(:example) do
 # 
 #     preinit do
 #         # perform some pre initialization
 #         @all = false
 #     end
 # 
 #     # dispatch is called to know to what command to call
 #     dispatch do
 #         ARGV.shift
 #     end
 #
 #     option("--arg ARGUMENT") do |v|
 #         @args << v
 #     end
 # 
 #     option("--debug", "-d") do |v|
 #         @debug = v
 #     end
 # 
 #     option("--all", "-a:) do |v|
 #         @all = v
 #     end
 #     
 #     unknown do |opt,arg|
 #         # last chance to manage an option
 #         ...
 #         # let's say to the framework we finally handle this option
 #         true
 #     end
 #
 #     command(:read) do
 #         # read action
 #     end
 # 
 #     command(:write) do
 #         # writeaction
 #     end
 # 
 # end
 #
 # === Preinit
 # The preinit block is the first code to be called in your application, before option parsing,
 # setup or command execution.
 #
 # === Options
 # Puppet::Application uses +OptionParser+ to manage the application options.
 # Options are defined with the +option+ method to which are passed various 
 # arguments, including the long option, the short option, a description...
 # Refer to +OptionParser+ documentation for the exact format.
 # * If the option method is given a block, this one will be called whenever
 # the option is encountered in the command-line argument.
 # * If the option method has no block, a default functionnality will be used, that
 # stores the argument (or true/false if the option doesn't require an argument) in
 # the global (to the application) options array.
 # * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
 #  * if +unknown+ was used with a block, it will be called with the option name and argument
 #  * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
 #    a default behavior
 #
 # --help is managed directly by the Puppet::Application class, but can be overriden.
 #
 # === Setup
 # Applications can use the setup block to perform any initialization.
 # The defaul +setup+ behaviour is to: read Puppet configuration and manage log level and destination
 #
 # === What and how to run
 # If the +dispatch+ block is defined it is called. This block should return the name of the registered command
 # to be run.
 # If it doesn't exist, it defaults to execute the +main+ command if defined.
 #
 class Puppet::Application
     include Puppet::Util
 
     @@applications = {}
     class << self
         include Puppet::Util
     end
 
     attr_reader :options, :opt_parser
 
     def self.[](name)
         name = symbolize(name)
         @@applications[name]
     end
 
     def should_parse_config
         @parse_config = true
     end
 
     def should_not_parse_config
         @parse_config = false
     end
 
     def should_parse_config?
         unless @parse_config.nil?
             return @parse_config
         end
         @parse_config = true
     end
 
     # used to declare a new command
     def command(name, &block)
         meta_def(symbolize(name), &block)
     end
 
     # used as a catch-all for unknown option
     def unknown(&block)
         meta_def(:handle_unknown, &block)
     end
 
     # used to declare code that handle an option
     def option(*options, &block)
         long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
         fname = "handle_#{long}"
         if (block_given?)
             meta_def(symbolize(fname), &block)
         else
             meta_def(symbolize(fname)) do |value|
                 self.options["#{long}".to_sym] = value
             end
         end
         @opt_parser.on(*options) do |value|
             self.send(symbolize(fname), value)
         end
     end
 
     # used to declare accessor in a more natural way in the 
     # various applications
     def attr_accessor(*args)
         args.each do |arg|
             meta_def(arg) do
                 instance_variable_get("@#{arg}".to_sym)
             end
             meta_def("#{arg}=") do |value|
                 instance_variable_set("@#{arg}".to_sym, value)
             end
         end
     end
 
     # used to declare code run instead the default setup
     def setup(&block)
         meta_def(:run_setup, &block)
     end
 
     # used to declare code to choose which command to run
     def dispatch(&block)
         meta_def(:get_command, &block)
     end
 
     # used to execute code before running anything else
     def preinit(&block)
         meta_def(:run_preinit, &block)
     end
 
     def initialize(name, banner = nil, &block)
         @opt_parser = OptionParser.new(banner)
 
         name = symbolize(name)
 
         init_default
 
         @options = {}
 
         instance_eval(&block) if block_given?
 
         @@applications[name] = self
     end
 
     # initialize default application behaviour
     def init_default
         setup do 
             default_setup
         end
 
         dispatch do
             :main
         end
 
         # empty by default
         preinit do
         end
 
         option("--version", "-V") do |arg|
             puts "%s" % Puppet.version
             exit
         end
 
         option("--help", "-h") do |v|
             help
         end
     end
 
     # This is the main application entry point
     def run
         run_preinit
         parse_options
-        Puppet.parse_config if should_parse_config?
+        Puppet.settings.parse if should_parse_config?
         run_setup
         run_command
     end
 
     def main
         raise NotImplementedError, "No valid command or main"
     end
 
     def run_command
         if command = get_command() and respond_to?(command)
             send(command)
         else
             main
         end
     end
 
     def default_setup
         # Handle the logging settings
         if options[:debug] or options[:verbose]
             Puppet::Util::Log.newdestination(:console)
             if options[:debug]
                 Puppet::Util::Log.level = :debug
             else
                 Puppet::Util::Log.level = :info
             end
         end
 
         unless options[:setdest]
             Puppet::Util::Log.newdestination(:syslog)
         end
     end
 
     def parse_options
         # get all puppet options
         optparse_opt = []
         optparse_opt = Puppet.settings.optparse_addargs(optparse_opt)
 
         # convert them to OptionParser format
         optparse_opt.each do |option|
             @opt_parser.on(*option) do |arg|
                 handlearg(option[0], arg)
             end
         end
 
         # scan command line argument
         begin
             @opt_parser.parse!
         rescue OptionParser::ParseError => detail
             $stderr.puts detail
             $stderr.puts "Try '#{$0} --help'"
             exit(1)
         end
     end
 
     def handlearg(opt, arg)
         # rewrite --[no-]option to --no-option if that's what was given
         if opt =~ /\[no-\]/ and !arg
             opt = opt.gsub(/\[no-\]/,'no-')
         end
         # otherwise remove the [no-] prefix to not confuse everybody
         opt = opt.gsub(/\[no-\]/, '')
         unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
             # Puppet.settings.handlearg doesn't handle direct true/false :-)
             if arg.is_a?(FalseClass)
                 arg = "false"
             elsif arg.is_a?(TrueClass)
                 arg = "true"
             end
             Puppet.settings.handlearg(opt, arg)
         end
     end
 
     # this is used for testing
     def self.exit(code)
         exit(code)
     end
 
     def help
         if Puppet.features.usage?
             ::RDoc::usage && exit
         else
             puts "No help available unless you have RDoc::usage installed"
             exit
         end
     end
 
-end
\ No newline at end of file
+end
diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb
index 27cee8c9f..f84d2f6e2 100644
--- a/lib/puppet/util/settings.rb
+++ b/lib/puppet/util/settings.rb
@@ -1,1149 +1,1161 @@
 require 'puppet'
 require 'sync'
 require 'puppet/transportable'
 require 'getoptlong'
 
 require 'puppet/external/event-loop'
+require 'puppet/util/cacher'
+require 'puppet/util/LoadedFile'
 
 # The class for handling configuration files.
 class Puppet::Util::Settings
     include Enumerable
+    include Puppet::Util::Cacher
 
     attr_accessor :file
     attr_reader :timer
 
     # Retrieve a config value
     def [](param)
         value(param)
     end
 
     # Set a config value.  This doesn't set the defaults, it sets the value itself.
     def []=(param, value)
         param = param.to_sym
         unless element = @config[param]
             raise ArgumentError,
                 "Attempt to assign a value to unknown configuration parameter %s" % param.inspect
         end
         if element.respond_to?(:munge)
             value = element.munge(value)
         end
         if element.respond_to?(:handle)
             element.handle(value)
         end
         # Reset the name, so it's looked up again.
         if param == :name
             @name = nil
         end
         @sync.synchronize do # yay, thread-safe
             @values[:memory][param] = value
             @cache.clear
 
             clearused
         end
 
         return value
     end
 
     # Generate the list of valid arguments, in a format that GetoptLong can
     # understand, and add them to the passed option list.
     def addargs(options)
         # Add all of the config parameters as valid options.
         self.each { |name, element|
             element.getopt_args.each { |args| options << args }
         }
 
         return options
     end
 
     # Generate the list of valid arguments, in a format that OptionParser can
     # understand, and add them to the passed option list.
     def optparse_addargs(options)
         # Add all of the config parameters as valid options.
         self.each { |name, element|
             options << element.optparse_args
         }
 
         return options
     end
 
     # Is our parameter a boolean parameter?
     def boolean?(param)
         param = param.to_sym
         if @config.include?(param) and @config[param].kind_of? CBoolean
             return true
         else
             return false
         end
     end
 
     # Remove all set values, potentially skipping cli values.
     def clear(exceptcli = false)
         @sync.synchronize do
             @values.each do |name, values|
                 @values.delete(name) unless exceptcli and name == :cli
             end
 
             # Don't clear the 'used' in this case, since it's a config file reparse,
             # and we want to retain this info.
             unless exceptcli
                 @used = []
             end
 
             @cache.clear
 
             @name = nil
         end
     end
 
     # This is mostly just used for testing.
     def clearused
         @cache.clear
         @used = []
     end
 
     # Do variable interpolation on the value.
     def convert(value, environment = nil)
         return value unless value
         return value unless value.is_a? String
         newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
             varname = $2 || $1
             if varname == "environment" and environment
                 environment
             elsif pval = self.value(varname)
                 pval
             else
                 raise Puppet::DevError, "Could not find value for %s" % value
             end
         end
 
         return newval
     end
 
     # Return a value's description.
     def description(name)
         if obj = @config[name.to_sym]
             obj.desc
         else
             nil
         end
     end
 
     def each
         @config.each { |name, object|
             yield name, object
         }
     end
 
     # Iterate over each section name.
     def eachsection
         yielded = []
         @config.each do |name, object|
             section = object.section
             unless yielded.include? section
                 yield section
                 yielded << section
             end
         end
     end
 
     # Return an object by name.
     def element(param)
         param = param.to_sym
         @config[param]
     end
 
     # Handle a command-line argument.
     def handlearg(opt, value = nil)
         @cache.clear
         value = munge_value(value) if value
         str = opt.sub(/^--/,'')
         bool = true
         newstr = str.sub(/^no-/, '')
         if newstr != str
             str = newstr
             bool = false
         end
         str = str.intern
         if self.valid?(str)
             @sync.synchronize do
                 if self.boolean?(str)
                     @values[:cli][str] = bool
                 else
                     @values[:cli][str] = value
                 end
             end
         else
             raise ArgumentError, "Invalid argument %s" % opt
         end
     end
 
     def include?(name)
         name = name.intern if name.is_a? String
         @config.include?(name)
     end
 
     # check to see if a short name is already defined
     def shortinclude?(short)
         short = short.intern if name.is_a? String
         @shortnames.include?(short)
     end
 
     # Create a new collection of config settings.
     def initialize
         @config = {}
         @shortnames = {}
         
         @created = []
         @searchpath = nil
 
         # Mutex-like thing to protect @values
         @sync = Sync.new
 
         # Keep track of set values.
         @values = Hash.new { |hash, key| hash[key] = {} }
 
         # And keep a per-environment cache
         @cache = Hash.new { |hash, key| hash[key] = {} }
 
         # A central concept of a name.
         @name = nil
 
         # The list of sections we've used.
         @used = []
     end
 
     # NOTE: ACS ahh the util classes. . .sigh
     # as part of a fix for 1183, I pulled the logic for the following 5 methods out of the executables and puppet.rb
     # They probably deserve their own class, but I don't want to do that until I can refactor environments
     # its a little better than where they were
 
     # Prints the contents of a config file with the available config elements, or it
     # prints a single value of a config element.
     def print_config_options
         env = value(:environment)
         val = value(:configprint)
         if val == "all"
             hash = {}
             each do |name, obj|
                 val = value(name,env)
                 val = val.inspect if val == ""
                 hash[name] = val
             end
             hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
                 puts "%s = %s" % [name, val]
             end
         else
             val.split(/\s*,\s*/).sort.each do |v|
                 if include?(v)
                     #if there is only one value, just print it for back compatibility
                     if v == val
                          puts value(val,env)
                          break
                     end
                     puts "%s = %s" % [v, value(v,env)]
                 else
                     puts "invalid parameter: %s" % v
                     return false
                 end
             end
         end
         true
     end
 
     def generate_config
         puts to_config
         true
     end
 
     def generate_manifest
         puts to_manifest
         true
     end
 
     def print_configs
         return print_config_options if value(:configprint) != ""
         return generate_config if value(:genconfig)
         return generate_manifest if value(:genmanifest)
     end
 
     def print_configs?
         return (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
     end
 
     # Return a given object's file metadata.
     def metadata(param)
         if obj = @config[param.to_sym] and obj.is_a?(CFile)
             return [:owner, :group, :mode].inject({}) do |meta, p|
                 if v = obj.send(p)
                     meta[p] = v
                 end
                 meta
             end
         else
             nil
         end
     end
 
     # Make a directory with the appropriate user, group, and mode
     def mkdir(default)
         obj = get_config_file_default(default)
 
         Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
             mode = obj.mode || 0750
             Dir.mkdir(obj.value, mode)
         end
     end
 
     # Figure out our name.
     def name
         unless @name
             unless @config[:name]
                 return nil
             end
             searchpath.each do |source|
                 next if source == :name
                 @sync.synchronize do
                     @name = @values[source][:name]
                 end
                 break if @name
             end
             unless @name
                 @name = convert(@config[:name].default).intern
             end
         end
         @name
     end
 
     # Return all of the parameters associated with a given section.
     def params(section = nil)
         if section
             section = section.intern if section.is_a? String
             @config.find_all { |name, obj|
                 obj.section == section
             }.collect { |name, obj|
                 name
             }
         else
             @config.keys
         end
     end
 
     # Parse the configuration file.  Just provides
     # thread safety.
-    def parse(file)
+    def parse
+        raise "No :config setting defined; cannot parse unknown config file" unless self[:config]
+
+        # Create a timer so that this file will get checked automatically
+        # and reparsed if necessary.
+        set_filetimeout_timer()
+
+        # Retrieve the value now, so that we don't lose it in the 'clear' call.
+        file = self[:config]
+
+        return unless FileTest.exist?(file)
+
         # We have to clear outside of the sync, because it's
         # also using synchronize().
         clear(true)
 
         @sync.synchronize do
             unsafe_parse(file)
         end
     end
 
     # Unsafely parse the file -- this isn't thread-safe and causes plenty of problems if used directly.
     def unsafe_parse(file)
         parse_file(file).each do |area, values|
             @values[area] = values
         end
         
         # Determine our environment, if we have one.
         if @config[:environment]
             env = self.value(:environment).to_sym
         else
             env = "none"
         end
 
         # Call any hooks we should be calling.
         settings_with_hooks.each do |setting|
             each_source(env) do |source|
                 if value = @values[source][setting.name]
                     # We still have to use value() to retrieve the value, since
                     # we want the fully interpolated value, not $vardir/lib or whatever.
                     # This results in extra work, but so few of the settings
                     # will have associated hooks that it ends up being less work this
                     # way overall.
                     setting.handle(self.value(setting.name, env))
                     break
                 end
             end
         end
 
         # We have to do it in the reverse of the search path,
         # because multiple sections could set the same value
         # and I'm too lazy to only set the metadata once.
         searchpath.reverse.each do |source|
             if meta = @values[source][:_meta]
                 set_metadata(meta)
             end
         end
     end
 
     # Create a new element.  The value is passed in because it's used to determine
     # what kind of element we're creating, but the value itself might be either
     # a default or a value, so we can't actually assign it.
     def newelement(hash)
         klass = nil
         if hash[:section]
             hash[:section] = hash[:section].to_sym
         end
         if type = hash[:type]
             unless klass = {:element => CElement, :file => CFile, :boolean => CBoolean}[type]
                 raise ArgumentError, "Invalid setting type '%s'" % type
             end
             hash.delete(:type)
         else
             case hash[:default]
             when true, false, "true", "false":
                 klass = CBoolean
             when /^\$\w+\//, /^\//:
                 klass = CFile
             when String, Integer, Float: # nothing
                 klass = CElement
             else
                 raise Puppet::Error, "Invalid value '%s' for %s" % [value.inspect, hash[:name]]
             end
         end
         hash[:settings] = self
         element = klass.new(hash)
 
         return element
     end
 
     # This has to be private, because it doesn't add the elements to @config
     private :newelement
 
     # Iterate across all of the objects in a given section.
     def persection(section)
         section = section.to_sym
         self.each { |name, obj|
             if obj.section == section
                 yield obj
             end
         }
     end
 
+    # Cache this in an easily clearable way, since we were
+    # having trouble cleaning it up after tests.
+    cached_attr(:file) do
+        if path = self[:config] and FileTest.exist?(path)
+            Puppet::Util::LoadedFile.new(path)
+        end
+    end
+
     # Reparse our config file, if necessary.
     def reparse
-        if defined? @file and @file.changed?
-            Puppet.notice "Reparsing %s" % @file.file
+        if file and file.changed?
+            Puppet.notice "Reparsing %s" % file.file
             @sync.synchronize do
-                parse(@file)
+                parse
             end
             reuse()
         end
     end
 
     def reuse
         return unless defined? @used
         @sync.synchronize do # yay, thread-safe
             new = @used
             @used = []
             self.use(*new)
         end
     end
 
     # The order in which to search for values.
     def searchpath(environment = nil)
         if environment
             [:cli, :memory, environment, :name, :main]
         else
             [:cli, :memory, :name, :main]
         end
     end
 
     # Get a list of objects per section
     def sectionlist
         sectionlist = []
         self.each { |name, obj|
             section = obj.section || "puppet"
             sections[section] ||= []
             unless sectionlist.include?(section)
                 sectionlist << section
             end
             sections[section] << obj
         }
 
         return sectionlist, sections
     end
 
     # Set a bunch of defaults in a given section.  The sections are actually pretty
     # pointless, but they help break things up a bit, anyway.
     def setdefaults(section, defs)
         section = section.to_sym
         call = []
         defs.each { |name, hash|
             if hash.is_a? Array
                 unless hash.length == 2
                     raise ArgumentError, "Defaults specified as an array must contain only the default value and the decription"
                 end
                 tmp = hash
                 hash = {}
                 [:default, :desc].zip(tmp).each { |p,v| hash[p] = v }
             end
             name = name.to_sym
             hash[:name] = name
             hash[:section] = section
             if @config.include?(name)
                 raise ArgumentError, "Parameter %s is already defined" % name
             end
             tryconfig = newelement(hash)
             if short = tryconfig.short
                 if other = @shortnames[short]
                     raise ArgumentError, "Parameter %s is already using short name '%s'" % [other.name, short]
                 end
                 @shortnames[short] = tryconfig
             end
             @config[name] = tryconfig
 
             # Collect the settings that need to have their hooks called immediately.
             # We have to collect them so that we can be sure we're fully initialized before
             # the hook is called.
             call << tryconfig if tryconfig.call_on_define
         }
 
         call.each { |setting| setting.handle(self.value(setting.name)) }
     end
 
     # Create a timer to check whether the file should be reparsed.
     def set_filetimeout_timer
-        return unless timeout = self[:filetimeout] and timeout > 0
-        EventLoop::Timer.new(:interval => timeout, :tolerance => 1, :start? => true) { self.reparse() }
+        return unless timeout = self[:filetimeout] and timeout = Integer(timeout) and timeout > 0
+        timer = EventLoop::Timer.new(:interval => timeout, :tolerance => 1, :start? => true) { self.reparse() }
     end
 
     # Convert the settings we manage into a catalog full of resources that model those settings.
     # We currently have to go through Trans{Object,Bucket} instances,
     # because this hasn't been ported yet.
     def to_catalog(*sections)
         sections = nil if sections.empty?
 
         catalog = Puppet::Resource::Catalog.new("Settings")
 
         @config.values.find_all { |value| value.is_a?(CFile) }.each do |file|
             next unless (sections.nil? or sections.include?(file.section))
             next unless resource = file.to_resource
             next if catalog.resource(resource.ref)
 
             catalog.add_resource(resource)
         end
 
         add_user_resources(catalog, sections)
 
         catalog
     end
 
     # Convert our list of config elements into a configuration file.
     def to_config
         str = %{The configuration file for #{Puppet[:name]}.  Note that this file
 is likely to have unused configuration parameters in it; any parameter that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
         # Add a section heading that matches our name.
         if @config.include?(:name)
             str += "[%s]\n" % self[:name]
         end
         eachsection do |section|
             persection(section) do |obj|
                 str += obj.to_config + "\n"
             end
         end
 
         return str
     end
 
     # Convert to a parseable manifest
     def to_manifest
         catalog = to_catalog
         # The resource list is a list of references, not actual instances.
         catalog.resources.collect do |ref|
             catalog.resource(ref).to_manifest
         end.join("\n\n")
     end
 
     # Create the necessary objects to use a section.  This is idempotent;
     # you can 'use' a section as many times as you want.
     def use(*sections)
         sections = sections.collect { |s| s.to_sym }
         @sync.synchronize do # yay, thread-safe
             sections = sections.reject { |s| @used.include?(s) }
 
             return if sections.empty?
 
             begin
                 catalog = to_catalog(*sections).to_ral
             rescue => detail
                 puts detail.backtrace if Puppet[:trace]
                 Puppet.err "Could not create resources for managing Puppet's files and directories in sections %s: %s" % [sections.inspect, detail]
 
                 # We need some way to get rid of any resources created during the catalog creation
                 # but not cleaned up.
                 return
             end
 
             begin
                 catalog.host_config = false
                 catalog.apply do |transaction|
                     if transaction.any_failed?
                         report = transaction.report
                         failures = report.logs.find_all { |log| log.level == :err }
                         raise "Got %s failure(s) while initializing: %s" % [failures.length, failures.collect { |l| l.to_s }.join("; ")] 
                     end
                 end
             end
 
             sections.each { |s| @used << s }
             @used.uniq!
         end
     end
 
     def valid?(param)
         param = param.to_sym
         @config.has_key?(param)
     end
 
     # Find the correct value using our search path.  Optionally accept an environment
     # in which to search before the other configuration sections.
     def value(param, environment = nil)
         param = param.to_sym
         environment = environment.to_sym if environment
 
         # Short circuit to nil for undefined parameters.
         return nil unless @config.include?(param)
 
         # Yay, recursion.
-        self.reparse() unless param == :filetimeout
+        #self.reparse() unless [:config, :filetimeout].include?(param)
 
         # Check the cache first.  It needs to be a per-environment
         # cache so that we don't spread values from one env
         # to another.
         if cached = @cache[environment||"none"][param]
             return cached
         end
 
         # See if we can find it within our searchable list of values
         val = catch :foundval do
             each_source(environment) do |source|
                 # Look for the value.  We have to test the hash for whether
                 # it exists, because the value might be false.
                 @sync.synchronize do
                     if @values[source].include?(param)
                         throw :foundval, @values[source][param]
                     end
                 end
             end
             throw :foundval, nil
         end
         
         # If we didn't get a value, use the default
         val = @config[param].default if val.nil?
 
         # Convert it if necessary
         val = convert(val, environment)
 
         # And cache it
         @cache[environment||"none"][param] = val
         return val
     end
 
     # Open a file with the appropriate user, group, and mode
     def write(default, *args, &bloc)
         obj = get_config_file_default(default)
         writesub(default, value(obj.name), *args, &bloc)
     end
 
     # Open a non-default file under a default dir with the appropriate user,
     # group, and mode
     def writesub(default, file, *args, &bloc)
         obj = get_config_file_default(default)
         chown = nil
         if Puppet::Util::SUIDManager.uid == 0
             chown = [obj.owner, obj.group]
         else
             chown = [nil, nil]
         end
 
         Puppet::Util::SUIDManager.asuser(*chown) do
             mode = obj.mode || 0640
             if args.empty?
                 args << "w"
             end
 
             args << mode
 
             # Update the umask to make non-executable files
             Puppet::Util.withumask(File.umask ^ 0111) do
                 File.open(file, *args) do |file|
                     yield file
                 end
             end
         end
     end
 
     def readwritelock(default, *args, &bloc)
         file = value(get_config_file_default(default).name)
         tmpfile = file + ".tmp"
         sync = Sync.new
         unless FileTest.directory?(File.dirname(tmpfile))
             raise Puppet::DevError, "Cannot create %s; directory %s does not exist" %
                 [file, File.dirname(file)]
         end
 
         sync.synchronize(Sync::EX) do
             File.open(file, ::File::CREAT|::File::RDWR, 0600) do |rf|
                 rf.lock_exclusive do
                     if File.exist?(tmpfile)
                         raise Puppet::Error, ".tmp file already exists for %s; Aborting locked write. Check the .tmp file and delete if appropriate" %
                             [file]
                     end
 
                     # If there's a failure, remove our tmpfile
                     begin
                         writesub(default, tmpfile, *args, &bloc)
                     rescue
                         File.unlink(tmpfile) if FileTest.exist?(tmpfile)
                         raise
                     end
 
                     begin
                         File.rename(tmpfile, file)
                     rescue => detail
                         Puppet.err "Could not rename %s to %s: %s" % [file, tmpfile, detail]
                         File.unlink(tmpfile) if FileTest.exist?(tmpfile)
                     end
                 end
             end
         end
     end
 
     private
 
     def get_config_file_default(default)
         obj = nil
         unless obj = @config[default]
             raise ArgumentError, "Unknown default %s" % default
         end
 
         unless obj.is_a? CFile
             raise ArgumentError, "Default %s is not a file" % default
         end
 
         return obj
     end
     
     # Create the transportable objects for users and groups.
     def add_user_resources(catalog, sections)
         return unless Puppet.features.root?
         return unless self[:mkusers]
 
         @config.each do |name, element|
             next unless element.respond_to?(:owner)
             next unless sections.nil? or sections.include?(element.section)
 
             if user = element.owner and user != "root" and catalog.resource(:user, user).nil?
                 resource = Puppet::Resource.new(:user, user, :ensure => :present)
                 if self[:group]
                     resource[:gid] = self[:group]
                 end
                 catalog.add_resource resource
             end
             if group = element.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
                 catalog.add_resource Puppet::Resource.new(:group, group, :ensure => :present)
             end
         end
     end
 
     # Yield each search source in turn.
     def each_source(environment)
         searchpath(environment).each do |source|
             # Modify the source as necessary.
             source = self.name if source == :name
             yield source
         end
     end
 
     # Return all elements that have associated hooks; this is so
     # we can call them after parsing the configuration file.
     def settings_with_hooks
         @config.values.find_all { |setting| setting.respond_to?(:handle) }
     end
 
     # Extract extra setting information for files.
     def extract_fileinfo(string)
         result = {}
         value = string.sub(/\{\s*([^}]+)\s*\}/) do
             params = $1
             params.split(/\s*,\s*/).each do |str|
                 if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
                     param, value = $1.intern, $2
                     result[param] = value
                     unless [:owner, :mode, :group].include?(param)
                         raise ArgumentError, "Invalid file option '%s'" % param
                     end
 
                     if param == :mode and value !~ /^\d+$/
                         raise ArgumentError, "File modes must be numbers"
                     end
                 else
                     raise ArgumentError, "Could not parse '%s'" % string
                 end
             end
             ''
         end
         result[:value] = value.sub(/\s*$/, '')
         return result
 
         return nil
     end
 
     # Convert arguments into booleans, integers, or whatever.
     def munge_value(value)
         # Handle different data types correctly
         return case value
             when /^false$/i: false
             when /^true$/i: true
             when /^\d+$/i: Integer(value)
             else
                 value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
         end
     end
 
     # This is an abstract method that just turns a file in to a hash of hashes.
     # We mostly need this for backward compatibility -- as of May 2007 we need to
     # support parsing old files with any section, or new files with just two
     # valid sections.
     def parse_file(file)
         text = read_file(file)
 
-        # Create a timer so that this file will get checked automatically
-        # and reparsed if necessary.
-        set_filetimeout_timer()
-
         result = Hash.new { |names, name|
             names[name] = {}
         }
 
         count = 0
 
         # Default to 'main' for the section.
         section = :main
         result[section][:_meta] = {}
         text.split(/\n/).each { |line|
             count += 1
             case line
             when /^\s*\[(\w+)\]$/:
                 section = $1.intern # Section names
                 # Add a meta section
                 result[section][:_meta] ||= {}
             when /^\s*#/: next # Skip comments
             when /^\s*$/: next # Skip blanks
             when /^\s*(\w+)\s*=\s*(.*)$/: # settings
                 var = $1.intern
 
                 # We don't want to munge modes, because they're specified in octal, so we'll
                 # just leave them as a String, since Puppet handles that case correctly.
                 if var == :mode
                     value = $2
                 else
                     value = munge_value($2)
                 end
 
                 # Check to see if this is a file argument and it has extra options
                 begin
                     if value.is_a?(String) and options = extract_fileinfo(value)
                         value = options[:value]
                         options.delete(:value)
                         result[section][:_meta][var] = options
                     end
                     result[section][var] = value
                 rescue Puppet::Error => detail
                     detail.file = file
                     detail.line = line
                     raise
                 end
             else
                 error = Puppet::Error.new("Could not match line %s" % line)
                 error.file = file
                 error.line = line
                 raise error
             end
         }
 
         return result
     end
 
     # Read the file in.
     def read_file(file)
-        if file.is_a? Puppet::Util::LoadedFile
-            @file = file
-        else
-            @file = Puppet::Util::LoadedFile.new(file)
-        end
-
         begin
-            return File.read(@file.file)
+            return File.read(file)
         rescue Errno::ENOENT
             raise ArgumentError, "No such file %s" % file
         rescue Errno::EACCES
             raise ArgumentError, "Permission denied to file %s" % file
         end
     end
 
     # Set file metadata.
     def set_metadata(meta)
         meta.each do |var, values|
             values.each do |param, value|
                 @config[var].send(param.to_s + "=", value)
             end
         end
     end
 
     # The base element type.
     class CElement
         attr_accessor :name, :section, :default, :setbycli, :call_on_define
         attr_reader :desc, :short
 
         def desc=(value)
             @desc = value.gsub(/^\s*/, '')
         end
 
         # get the arguments in getopt format
         def getopt_args
             if short
                 [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
             else
                 [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
             end
         end
 
         # get the arguments in OptionParser format
         def optparse_args
             if short
                 ["--#{name}", "-#{short}", desc, :REQUIRED]
             else
                 ["--#{name}", desc, :REQUIRED]
             end
         end
 
         def hook=(block)
             meta_def :handle, &block
         end
 
         # Create the new element.  Pretty much just sets the name.
         def initialize(args = {})
             unless @settings = args.delete(:settings)
                 raise ArgumentError.new("You must refer to a settings object")
             end
 
             args.each do |param, value|
                 method = param.to_s + "="
                 unless self.respond_to? method
                     raise ArgumentError, "%s does not accept %s" % [self.class, param]
                 end
 
                 self.send(method, value)
             end
 
             unless self.desc
                 raise ArgumentError, "You must provide a description for the %s config option" % self.name
             end
         end
 
         def iscreated
             @iscreated = true
         end
 
         def iscreated?
             if defined? @iscreated
                 return @iscreated
             else
                 return false
             end
         end
 
         def set?
             if defined? @value and ! @value.nil?
                 return true
             else
                 return false
             end
         end
 
         # short name for the celement
         def short=(value)
             if value.to_s.length != 1
                 raise ArgumentError, "Short names can only be one character."
             end
             @short = value.to_s
         end
 
         # Convert the object to a config statement.
         def to_config
             str = @desc.gsub(/^/, "# ") + "\n"
 
             # Add in a statement about the default.
             if defined? @default and @default
                 str += "# The default value is '%s'.\n" % @default
             end
 
             # If the value has not been overridden, then print it out commented
             # and unconverted, so it's clear that that's the default and how it
             # works.
             value = @settings.value(self.name)
 
             if value != @default
                 line = "%s = %s" % [@name, value]
             else
                 line = "# %s = %s" % [@name, @default]
             end
 
             str += line + "\n"
 
             str.gsub(/^/, "    ")
         end
 
         # Retrieves the value, or if it's not set, retrieves the default.
         def value
             @settings.value(self.name)
         end
     end
 
     # A file.
     class CFile < CElement
         attr_writer :owner, :group
         attr_accessor :mode, :create
 
         # Should we create files, rather than just directories?
         def create_files?
             create
         end
 
         def group
             if defined? @group
                 return @settings.convert(@group)
             else
                 return nil
             end
         end
 
         def owner
             if defined? @owner
                 return @settings.convert(@owner)
             else
                 return nil
             end
         end
 
         # Set the type appropriately.  Yep, a hack.  This supports either naming
         # the variable 'dir', or adding a slash at the end.
         def munge(value)
             # If it's not a fully qualified path...
             if value.is_a?(String) and value !~ /^\$/ and value !~ /^\// and value != 'false'
                 # Make it one
                 value = File.join(Dir.getwd, value)
             end
             if value.to_s =~ /\/$/
                 @type = :directory
                 return value.sub(/\/$/, '')
             end
             return value
         end
 
         # Return the appropriate type.
         def type
             value = @settings.value(self.name)
             if @name.to_s =~ /dir/
                 return :directory
             elsif value.to_s =~ /\/$/
                 return :directory
             elsif value.is_a? String
                 return :file
             else
                 return nil
             end
         end
 
         # Turn our setting thing into a Puppet::Resource instance.
         def to_resource
             return nil unless type = self.type
 
             path = self.value
 
             return nil unless path.is_a?(String)
 
             # Make sure the paths are fully qualified.
             path = File.join(Dir.getwd, path) unless path =~ /^\//
 
             return nil unless type == :directory or create_files? or File.exist?(path)
             return nil if path =~ /^\/dev/
 
             resource = Puppet::Resource.new(:file, path)
             resource[:mode] = self.mode if self.mode
 
             if Puppet.features.root?
                 resource[:owner] = self.owner if self.owner
                 resource[:group] = self.group if self.group
             end
 
             resource[:ensure] = type
             resource[:loglevel] = :debug
             resource[:backup] = false
 
             resource.tag(self.section, self.name, "settings")
 
             resource
         end
 
         # Make sure any provided variables look up to something.
         def validate(value)
             return true unless value.is_a? String
             value.scan(/\$(\w+)/) { |name|
                 name = $1
                 unless @settings.include?(name)
                     raise ArgumentError,
                         "Settings parameter '%s' is undefined" %
                         name
                 end
             }
         end
     end
 
     # A simple boolean.
     class CBoolean < CElement
         # get the arguments in getopt format
         def getopt_args
             if short
                 [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT],
                  ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
             else
                 [["--#{name}", GetoptLong::NO_ARGUMENT],
                  ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
             end
         end
 
         def optparse_args
             if short
                 ["--[no-]#{name}", "-#{short}", desc, :NONE ]
             else
                 ["--[no-]#{name}", desc, :NONE]
             end
         end
 
         def munge(value)
             case value
             when true, "true": return true
             when false, "false": return false
             else
                 raise ArgumentError, "Invalid value '%s' for %s" %
                     [value.inspect, @name]
             end
         end
     end
 end
diff --git a/spec/unit/application.rb b/spec/unit/application.rb
index e1f9362c4..5c3df0999 100755
--- a/spec/unit/application.rb
+++ b/spec/unit/application.rb
@@ -1,417 +1,417 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 
 describe Puppet::Application do
 
     before :each do
         @app = Puppet::Application.new(:test)
     end
 
     it "should have a run entry-point" do
         @app.should respond_to(:run)
     end
 
     it "should have a read accessor to options" do
         @app.should respond_to(:options)
     end
 
     it "should create a default run_setup method" do
         @app.should respond_to(:run_setup)
     end
 
     it "should create a default run_preinit method" do
         @app.should respond_to(:run_preinit)
     end
 
     it "should create a default get_command method" do
         @app.should respond_to(:get_command)
     end
 
     it "should return :main as default get_command" do
         @app.get_command.should == :main
     end
 
     describe "when parsing command-line options" do
 
         before :each do
             @argv_bak = ARGV.dup
             ARGV.clear
 
             Puppet.settings.stubs(:optparse_addargs).returns([])
             @app = Puppet::Application.new(:test)
         end
 
         after :each do
             ARGV.clear
             ARGV << @argv_bak
         end
 
         it "should get options from Puppet.settings.optparse_addargs" do
             Puppet.settings.expects(:optparse_addargs).returns([])
 
             @app.parse_options
         end
 
         it "should add Puppet.settings options to OptionParser" do
             Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
 
             @app.opt_parser.expects(:on).with { |*arg| arg == ["--option","-o", "Funny Option"] }
 
             @app.parse_options
         end
 
         it "should ask OptionParser to parse the command-line argument" do
             @app.opt_parser.expects(:parse!)
 
             @app.parse_options
         end
 
         describe "when using --help" do
             confine "rdoc" => Puppet.features.usage?
 
             it "should call RDoc::usage and exit" do
                 @app.expects(:exit)
                 RDoc.expects(:usage).returns(true)
 
                 @app.handle_help(nil)
             end
 
         end
 
         describe "when using --version" do
             it "should declare a version option" do
                 @app.should respond_to(:handle_version)
             end
 
             it "should exit after printing the version" do
                 @app.stubs(:puts)
 
                 lambda { @app.handle_version(nil) }.should raise_error(SystemExit)
             end
         end
 
         describe "when dealing with an argument not declared directly by the application" do
             it "should pass it to handle_unknown if this method exists" do
                 Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled"]])
                 @app.opt_parser.stubs(:on).yields("value")
 
                 @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
 
                 @app.parse_options
             end
 
             it "should pass it to Puppet.settings if handle_unknown says so" do
                 Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
                 @app.opt_parser.stubs(:on).yields("value")
 
                 @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
 
                 Puppet.settings.expects(:handlearg).with("--topuppet", "value")
                 @app.parse_options
             end
 
             it "should pass it to Puppet.settings if there is no handle_unknown method" do
                 Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
                 @app.opt_parser.stubs(:on).yields("value")
 
                 @app.stubs(:respond_to?).returns(false)
 
                 Puppet.settings.expects(:handlearg).with("--topuppet", "value")
                 @app.parse_options
             end
 
             it "should transform boolean false value to string for Puppet.settings" do
                 Puppet.settings.expects(:handlearg).with("--option", "false")
                 @app.handlearg("--option", false)
             end
 
             it "should transform boolean true value to string for Puppet.settings" do
                 Puppet.settings.expects(:handlearg).with("--option", "true")
                 @app.handlearg("--option", true)
             end
 
             it "should transform boolean option to normal form for Puppet.settings" do
                 Puppet.settings.expects(:handlearg).with("--option", "true")
                 @app.handlearg("--[no-]option", true)
             end
 
             it "should transform boolean option to no- form for Puppet.settings" do
                 Puppet.settings.expects(:handlearg).with("--no-option", "false")
                 @app.handlearg("--[no-]option", false)
             end
 
         end
 
         it "should exit if OptionParser raises an error" do
             $stderr.stubs(:puts)
             @app.opt_parser.stubs(:parse!).raises(OptionParser::ParseError.new("blah blah"))
 
             @app.expects(:exit)
 
             lambda { @app.parse_options }.should_not raise_error
         end
 
     end
 
     describe "when calling default setup" do
 
         before :each do
             @app = Puppet::Application.new(:test)
             @app.stubs(:should_parse_config?).returns(false)
             @app.options.stubs(:[])
         end
 
         [ :debug, :verbose ].each do |level|
             it "should honor option #{level}" do
                 @app.options.stubs(:[]).with(level).returns(true)
                 Puppet::Util::Log.stubs(:newdestination)
 
                 Puppet::Util::Log.expects(:level=).with(level == :verbose ? :info : :debug)
 
                 @app.run_setup
             end
         end
 
         it "should honor setdest option" do
             @app.options.stubs(:[]).with(:setdest).returns(false)
 
             Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
             @app.run_setup
         end
 
     end
 
     describe "when running" do
 
         before :each do
             @app = Puppet::Application.new(:test)
             @app.stubs(:run_preinit)
             @app.stubs(:run_setup)
             @app.stubs(:parse_options)
         end
 
         it "should call run_preinit" do
             @app.stubs(:run_command)
 
             @app.expects(:run_preinit)
 
             @app.run
         end
 
         it "should call parse_options" do
             @app.stubs(:run_command)
 
             @app.expects(:parse_options)
 
             @app.run
         end
 
         it "should call run_command" do
 
             @app.expects(:run_command)
 
             @app.run
         end
 
         it "should parse Puppet configuration if should_parse_config is called" do
             @app.stubs(:run_command)
             @app.should_parse_config
 
-            Puppet.expects(:parse_config)
+            Puppet.settings.expects(:parse)
 
             @app.run
         end
 
         it "should not parse_option if should_not_parse_config is called" do
             @app.stubs(:run_command)
             @app.should_not_parse_config
 
-            Puppet.expects(:parse_config).never
+            Puppet.settings.expects(:parse).never
 
             @app.run
         end
 
         it "should parse Puppet configuration if needed" do
             @app.stubs(:run_command)
             @app.stubs(:should_parse_config?).returns(true)
 
-            Puppet.expects(:parse_config)
+            Puppet.settings.expects(:parse)
 
             @app.run
         end
 
         it "should call the action matching what returned command" do
             @app.stubs(:get_command).returns(:backup)
             @app.stubs(:respond_to?).with(:backup).returns(true)
 
             @app.expects(:backup)
 
             @app.run
         end
 
         it "should call main as the default command" do
             @app.expects(:main)
 
             @app.run
         end
 
         it "should raise an error if no command can be called" do
             lambda { @app.run }.should raise_error(NotImplementedError)
         end
 
         it "should raise an error if dispatch returns no command" do
             @app.stubs(:get_command).returns(nil)
 
             lambda { @app.run }.should raise_error(NotImplementedError)
         end
 
         it "should raise an error if dispatch returns an invalid command" do
             @app.stubs(:get_command).returns(:this_function_doesnt_exist)
 
             lambda { @app.run }.should raise_error(NotImplementedError)
         end
 
     end
 
     describe "when metaprogramming" do
 
         before :each do
             @app = Puppet::Application.new(:test)
         end
 
         it "should create a new method with command" do
             @app.command(:test) do
             end
 
             @app.should respond_to(:test)
         end
 
         describe "when calling attr_accessor" do
             it "should create a reader method" do
                 @app.attr_accessor(:attribute)
 
                 @app.should respond_to(:attribute)
             end
 
             it "should create a reader that delegates to instance_variable_get" do
                 @app.attr_accessor(:attribute)
 
                 @app.expects(:instance_variable_get).with(:@attribute)
                 @app.attribute
             end
 
             it "should create a writer method" do
                 @app.attr_accessor(:attribute)
 
                 @app.should respond_to(:attribute=)
             end
 
             it "should create a writer that delegates to instance_variable_set" do
                 @app.attr_accessor(:attribute)
 
                 @app.expects(:instance_variable_set).with(:@attribute, 1234)
                 @app.attribute=1234
             end
         end
 
         describe "when calling option" do
             it "should create a new method named after the option" do
                 @app.option("--test1","-t") do
                 end
 
                 @app.should respond_to(:handle_test1)
             end
 
             it "should transpose in option name any '-' into '_'" do
                 @app.option("--test-dashes-again","-t") do
                 end
 
                 @app.should respond_to(:handle_test_dashes_again)
             end
 
             it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
                 @app.option("--[no-]test2","-t") do
                 end
 
                 @app.should respond_to(:handle_test2)
             end
 
             describe "when a block is passed" do
                 it "should create a new method with it" do
                     @app.option("--[no-]test2","-t") do
                         raise "I can't believe it, it works!"
                     end
 
                     lambda { @app.handle_test2 }.should raise_error
                 end
 
                 it "should declare the option to OptionParser" do
                     @app.opt_parser.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
                     @app.option("--[no-]test3","-t") do
                     end
                 end
 
                 it "should pass a block that calls our defined method" do
                     @app.opt_parser.stubs(:on).yields(nil)
 
                     @app.expects(:send).with(:handle_test4, nil)
 
                     @app.option("--test4","-t") do
                     end
                 end
             end
 
             describe "when no block is given" do
                 it "should declare the option to OptionParser" do
                     @app.opt_parser.expects(:on).with("--test4","-t")
 
                     @app.option("--test4","-t")
                 end
 
                 it "should give to OptionParser a block that adds the the value to the options array" do
                     @app.opt_parser.stubs(:on).with("--test4","-t").yields(nil)
 
                     @app.options.expects(:[]=).with(:test4,nil)
 
                     @app.option("--test4","-t")
                 end
             end
         end
 
         it "should create a method called run_setup with setup" do
             @app.setup do
             end
 
             @app.should respond_to(:run_setup)
         end
 
         it "should create a method called run_preinit with preinit" do
             @app.preinit do
             end
 
             @app.should respond_to(:run_preinit)
         end
 
         it "should create a method called handle_unknown with unknown" do
             @app.unknown do
             end
 
             @app.should respond_to(:handle_unknown)
         end
 
 
         it "should create a method called get_command with dispatch" do
             @app.dispatch do
             end
 
             @app.should respond_to(:get_command)
         end
     end
 end
diff --git a/spec/unit/parser/interpreter.rb b/spec/unit/parser/interpreter.rb
index 211f42df0..fe63bbd65 100755
--- a/spec/unit/parser/interpreter.rb
+++ b/spec/unit/parser/interpreter.rb
@@ -1,149 +1,147 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Parser::Interpreter do
     before do
         @interp = Puppet::Parser::Interpreter.new
         @parser = mock 'parser'
     end
 
     describe "when creating parser instances" do
         it "should create a parser with code if there is code defined in the :code setting" do
             Puppet.settings.stubs(:value).with(:code, :myenv).returns("mycode")
             @parser.expects(:string=).with("mycode")
             @parser.expects(:parse)
             Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).returns(@parser)
             @interp.send(:create_parser, :myenv).object_id.should equal(@parser.object_id)
         end
 
         it "should create a parser with the main manifest when the code setting is an empty string" do
             Puppet.settings.stubs(:value).with(:code, :myenv).returns("")
             Puppet.settings.stubs(:value).with(:manifest, :myenv).returns("/my/file")
             @parser.expects(:parse)
             @parser.expects(:file=).with("/my/file")
             Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).returns(@parser)
             @interp.send(:create_parser, :myenv).should equal(@parser)
         end
 
         it "should return nothing when new parsers fail" do
             Puppet::Parser::Parser.expects(:new).with(:environment => :myenv).raises(ArgumentError)
             proc { @interp.send(:create_parser, :myenv) }.should raise_error(Puppet::Error)
         end
 
         it "should create parsers with environment-appropriate manifests" do
             # Set our per-environment values.  We can't just stub :value, because
             # it's called by too much of the rest of the code.
             text = "[env1]\nmanifest = /t/env1.pp\n[env2]\nmanifest = /t/env2.pp"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            Puppet.settings.stubs(:read_file).with(file).returns(text)
-            Puppet.settings.parse(file)
+            FileTest.stubs(:exist?).returns true
+            Puppet.settings.stubs(:read_file).returns(text)
+            Puppet.settings.parse
 
             parser1 = mock 'parser1'
             Puppet::Parser::Parser.expects(:new).with(:environment => :env1).returns(parser1)
             parser1.expects(:file=).with("/t/env1.pp")
             parser1.expects(:parse)
             @interp.send(:create_parser, :env1)
 
             parser2 = mock 'parser2'
             Puppet::Parser::Parser.expects(:new).with(:environment => :env2).returns(parser2)
             parser2.expects(:file=).with("/t/env2.pp")
             parser2.expects(:parse)
             @interp.send(:create_parser, :env2)
         end
     end
 
     describe "when managing parser instances" do
         it "should use the same parser when the parser does not need reparsing" do
             @interp.expects(:create_parser).with(:myenv).returns(@parser)
             @interp.send(:parser, :myenv).should equal(@parser)
 
             @parser.expects(:reparse?).returns(false)
             @interp.send(:parser, :myenv).should equal(@parser)
         end
 
         it "should fail intelligently if a parser cannot be created and one does not already exist" do
             @interp.expects(:create_parser).with(:myenv).raises(ArgumentError)
             proc { @interp.send(:parser, :myenv) }.should raise_error(ArgumentError)
         end
 
         it "should use different parsers for different environments" do
             # get one for the first env
             @interp.expects(:create_parser).with(:first_env).returns(@parser)
             @interp.send(:parser, :first_env).should equal(@parser)
 
             other_parser = mock('otherparser')
             @interp.expects(:create_parser).with(:second_env).returns(other_parser)
             @interp.send(:parser, :second_env).should equal(other_parser)
         end
 
         describe "when files need reparsing" do
             it "should create a new parser" do
                 oldparser = mock('oldparser')
                 newparser = mock('newparser')
                 oldparser.expects(:reparse?).returns(true)
 
                 @interp.expects(:create_parser).with(:myenv).returns(oldparser)
                 @interp.send(:parser, :myenv).should equal(oldparser)
                 @interp.expects(:create_parser).with(:myenv).returns(newparser)
                 @interp.send(:parser, :myenv).should equal(newparser)
             end
 
             it "should raise an exception if a new parser cannot be created" do
                 # Get the first parser in the hash.
                 @interp.expects(:create_parser).with(:myenv).returns(@parser)
                 @interp.send(:parser, :myenv).should equal(@parser)
 
                 @parser.expects(:reparse?).returns(true)
 
                 @interp.expects(:create_parser).with(:myenv).raises(Puppet::Error, "Could not parse")
 
                 lambda { @interp.parser(:myenv) }.should raise_error(Puppet::Error) 
             end
         end
     end
 
     describe "when compiling a catalog" do
         before do
             @node = stub 'node', :environment => :myenv
             @compiler = mock 'compile'
         end
 
         it "should create a compile with the node and parser" do
             catalog = stub 'catalog', :to_resource => nil
             @compiler.expects(:compile).returns(catalog)
             @interp.expects(:parser).with(:myenv).returns(@parser)
             Puppet::Parser::Compiler.expects(:new).with(@node, @parser).returns(@compiler)
             @interp.compile(@node)
         end
 
         it "should fail intelligently when no parser can be found" do
             @node.stubs(:name).returns("whatever")
             @interp.expects(:parser).with(:myenv).returns(nil)
             proc { @interp.compile(@node) }.should raise_error(Puppet::ParseError)
         end
 
         it "should return the results of the compile, converted to a plain resource catalog" do
             catalog = mock 'catalog'
             @compiler.expects(:compile).returns(catalog)
             @interp.stubs(:parser).returns(@parser)
             Puppet::Parser::Compiler.stubs(:new).returns(@compiler)
 
             catalog.expects(:to_resource).returns "my_resource_catalog"
             @interp.compile(@node).should == "my_resource_catalog"
         end
     end
 
     describe "when returning catalog version" do
         it "should ask the appropriate parser for the catalog version" do
             node = mock 'node'
             node.expects(:environment).returns(:myenv)
             parser = mock 'parser'
             parser.expects(:version).returns(:myvers)
             @interp.expects(:parser).with(:myenv).returns(parser)
             @interp.configuration_version(node).should equal(:myvers)
         end
     end
 end
diff --git a/spec/unit/util/settings.rb b/spec/unit/util/settings.rb
index f84c467e2..c1d74a88b 100755
--- a/spec/unit/util/settings.rb
+++ b/spec/unit/util/settings.rb
@@ -1,999 +1,1048 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Util::Settings do 
     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 allow specification of default values associated with a section as an array" do
             @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"])
         end
 
         it "should not allow duplicate parameter specifications" do
             @settings.setdefaults(:section, :myvalue => ["a", "b"])
             lambda { @settings.setdefaults(:section, :myvalue => ["c", "d"]) }.should raise_error(ArgumentError)
         end
 
         it "should allow specification of default values associated with a section as a hash" do
             @settings.setdefaults(:section, :myvalue => {:default => "defaultval", :desc => "my description"})
         end
 
         it "should consider defined parameters to be valid" do
             @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"])
             @settings.valid?(:myvalue).should be_true
         end
 
         it "should require a description when defaults are specified with an array" do
             lambda { @settings.setdefaults(:section, :myvalue => ["a value"]) }.should raise_error(ArgumentError)
         end
 
         it "should require a description when defaults are specified with a hash" do
             lambda { @settings.setdefaults(:section, :myvalue => {:default => "a value"}) }.should raise_error(ArgumentError)
         end
 
         it "should support specifying owner, group, and mode when specifying files" do
             @settings.setdefaults(:section, :myvalue => {:default => "/some/file", :owner => "blah", :mode => "boo", :group => "yay", :desc => "whatever"})
         end
 
         it "should support specifying a short name" do
             @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
         end
 
         it "should support specifying the setting type" do
             @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :type => :element})
             @settings.element(:myvalue).should be_instance_of(Puppet::Util::Settings::CElement)
         end
 
         it "should fail if an invalid setting type is specified" do
             lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :type => :foo}) }.should raise_error(ArgumentError)
         end
 
         it "should fail when short names conflict" do
             @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
             lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError)
         end
     end
 
     describe "when setting values" do
         before do
             @settings = Puppet::Util::Settings.new
             @settings.setdefaults :main, :myval => ["val", "desc"]
             @settings.setdefaults :main, :bool => [true, "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.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 clear the cache when setting getopt-specific values" do
             @settings.setdefaults :mysection, :one => ["whah", "yay"], :two => ["$one yay", "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.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
             values.should == []
 
             @settings[:hooker] = "something"
             values.should == %w{something}
         end
 
         it "should provide an option to call passed blocks during definition" do
             values = []
             @settings.setdefaults(: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.setdefaults(:section, :one => ["test", "a"])
             @settings.setdefaults(: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 element-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
     end
 
     describe "when returning values" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "d"]
+            @settings.setdefaults :section, :config => ["/my/file", "eh"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "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 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"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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 name determined by the 'name' parameter" do
             @settings.setdefaults(:whatever, :name => ["something", "yayness"])
             @settings.name.should == :something
             @settings[:name] = :other
             @settings.name.should == :other
         end
     end
 
     describe "when choosing which value to return" do
         before do
             @settings = Puppet::Util::Settings.new
             @settings.setdefaults :section,
+                :config => ["/my/file", "a"],
                 :one => ["ONE", "a"],
                 :name => ["myname", "w"]
+            FileTest.stubs(:exist?).returns true
         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"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:parse_file).returns(text)
+            @settings.stubs(:read_file).returns(text)
             @settings.handlearg("--one", "clival")
-            @settings.parse(file)
+            @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 executable-specific section before values set in the main section" do
             text = "[main]\none = mainval\n[myname]\none = nameval\n"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
 
             @settings[:one].should == "nameval"
         end
 
         it "should not return values outside of its search path" do
             text = "[other]\none = oval\n"
             file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(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"
-            file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
             @settings.value(:one, "env").should == "envval"
         end
 
         it "should interpolate found values using the current environment" do
             @settings.setdefaults :main, :myval => ["$environment/foo", "mydocs"]
 
             @settings.value(:myval, "myenv").should == "myenv/foo"
         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"
-            file = "/some/file"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/whatever")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.stubs(:read_file).returns(text)
+            @settings.parse
             @settings.value(:one, "env").should == "envval"
         end
     end
 
     describe "when parsing its configuration" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            @file = "/some/file"
+            @settings.setdefaults :section, :config => ["/some/file", "eh"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            FileTest.stubs(:exist?).returns true
         end
 
-        it "should set a timer that triggers reparsing" do
+        it "should use its current ':config' value for the file to parse" do
+            @settings[:config] = "/my/file"
+
+            File.expects(:read).with("/my/file").returns("[main]")
+
+            @settings.parse
+        end
+
+        it "should fail if no configuration setting is defined" do
+            @settings = Puppet::Util::Settings.new
+            lambda { @settings.parse }.should raise_error(RuntimeError)
+        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 set a timer that triggers reparsing, even if the file does not exist" do
+            FileTest.expects(:exist?).returns false
             @settings.expects(:set_filetimeout_timer)
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns("[main]")
 
-            @settings.parse(file)
+            @settings.parse
         end
 
         it "should return values set in the configuration file" do
             text = "[main]
             one = fileval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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"
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            lambda { @settings.parse(file) }.should_not raise_error
+            @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
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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.setdefaults :section, :myfile => ["/myfile", "a"]
 
             text = "[main]
             myfile = /other/file {owner = luke, group = luke, mode = 644}
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:myfile].should == "/other/file"
             @settings.metadata(:myfile).should == {:owner => "luke", :group => "luke", :mode => "644"}
         end
 
         it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do
             @settings.setdefaults :section, :myfile => ["/myfile", "a"]
 
             text = "[main]
             myfile = /other/file {owner = luke}
             "
             file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             @settings[:myfile].should == "/other/file"
             @settings.metadata(:myfile).should == {:owner => "luke"}
         end
 
         it "should call hooks associated with values set in the configuration file" do
             values = []
             @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
             text = "[main]
             mysetting = setval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
             text = "[main]
             mysetting = setval
             [puppet]
             mysetting = other
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
             @settings.setdefaults :section, :environment => ["yay", "a"]
             @settings.setdefaults :section, :environments => ["yay,foo", "a"]
 
             text = "[main]
             mysetting = setval
             [yay]
             mysetting = other
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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.setdefaults :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }}
             @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
             text = "[main]
             mysetting = $base/setval
             "
-            file = "/some/file"
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             values.should == ["yay/setval"]
         end
 
         it "should allow empty values" do
             @settings.setdefaults :section, :myarg => ["myfile", "a"]
 
             text = "[main]
             myarg =
             "
             @settings.stubs(:read_file).returns(text)
-            @settings.parse("/some/file")
+            @settings.parse
             @settings[:myarg].should == ""
         end
     end
 
     describe "when reparsing its configuration" do
         before do
             @settings = Puppet::Util::Settings.new
-            @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            @settings.setdefaults :section, :config => ["/test/file", "a"], :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"]
+            FileTest.stubs(:exist?).returns true
+        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 use a cached LoadedFile instance" do
+            first = mock 'first'
+            second = mock 'second'
+            Puppet::Util::LoadedFile.expects(:new).times(2).with("/test/file").returns(first).then.returns(second)
+
+            @settings.file.should equal(first)
+            Puppet::Util::Cacher.expire
+            @settings.file.should equal(second)
         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.file = 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.expects(:read_file).with(file).returns(text).times(2)
+            @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"
-            file = mock 'file'
-            file.stubs(:file).returns("/test/file")
-            @settings.stubs(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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"
-            file = mock 'file'
-            file.stubs(:changed?).returns(true)
-            file.stubs(:file).returns("/test/file")
-            @settings.expects(:read_file).with(file).returns(text)
-            @settings.parse(file)
+            @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).with(file).returns(text)
-            @settings.parse(file)
+            @settings.expects(:read_file).returns(text)
+            @settings.parse
             #@settings.reparse
 
             # 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
     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
         end
 
         it "should add all file resources to the catalog if no sections have been specified" do
             @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
             @settings.setdefaults :other, :otherdir => ["/otherdir", "a"]
             catalog = @settings.to_catalog
             %w{/maindir /seconddir /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.setdefaults :main, :maindir => ["/maindir", "a"]
             @settings.setdefaults :other, :otherdir => ["/otherdir", "a"]
             catalog = @settings.to_catalog(:main)
             catalog.resource(:file, "/otherdir").should be_nil
             catalog.resource(:file, "/maindir").should be_instance_of(Puppet::Resource)
         end
 
         it "should not try to add the same file twice" do
             @settings.setdefaults :main, :maindir => ["/maindir", "a"]
             @settings.setdefaults :other, :otherdir => ["/maindir", "a"]
             lambda { @settings.to_catalog }.should_not raise_error
         end
 
         it "should ignore files whose :to_resource method returns nil" do
             @settings.setdefaults :main, :maindir => ["/maindir", "a"]
             @settings.element(:maindir).expects(:to_resource).returns nil
 
             Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
             @settings.to_catalog
         end
 
         describe "when adding users and groups to the catalog" do
             before do
                 Puppet.features.stubs(:root?).returns true
                 @settings.setdefaults :foo, :mkusers => [true, "e"]
                 @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny"}
 
                 @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, "luke").should be_instance_of(Puppet::Resource)
                 @catalog.resource(:group, "johnny").should be_instance_of(Puppet::Resource)
             end
 
             it "should only add users and groups to the catalog from specified sections" do
                 @settings.setdefaults :yay, :yaydir => {:default => "/yaydir", :desc => "a", :owner => "jane", :group => "billy"}
                 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, "luke").should be_nil
                 catalog.resource(:group, "johnny").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.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny"}
 
                 catalog = settings.to_catalog
                 catalog.resource(:user, "luke").should be_nil
                 catalog.resource(:group, "johnny").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, "luke").should be_nil
                 catalog.resource(:group, "johnny").should be_nil
             end
 
             it "should not try to add users or groups to the catalog twice" do
                 @settings.setdefaults :yay, :yaydir => {:default => "/yaydir", :desc => "a", :owner => "luke", :group => "johnny"}
 
                 # 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, "luke")[:ensure].should == :present
                 @catalog.resource(:group, "johnny")[:ensure].should == :present
             end
 
             it "should set each created user's :gid to the main group if one is available" do
                 @settings.setdefaults :foo, :group => ["yay", 'eh']
 
                 @settings.to_catalog.resource(:user, "luke")[:gid].should == "yay"
             end
 
             it "should not set each created user's :gid if no main group is available" do
                 @settings.to_catalog.resource(:user, "luke")[:gid].should be_nil
             end
 
             it "should not attempt to manage the root user" do
                 Puppet.features.stubs(:root?).returns true
                 @settings.setdefaults :foo, :foodir => {:default => "/foodir", :desc => "a", :owner => "root", :group => "johnny"}
 
                 @settings.to_catalog.resource(:user, "root").should be_nil
             end
 
             it "should not attempt to manage the wheel or root groups" do
                 @settings.setdefaults :foo, :foodir => {:default => "/foodir", :desc => "a", :owner => "root", :group => "root"}
                 @settings.setdefaults :fee, :feedir => {:default => "/feedir", :desc => "a", :owner => "root", :group => "wheel"}
 
                 catalog = @settings.to_catalog
                 catalog.resource(:group, "root").should be_nil
                 catalog.resource(:group, "wheel").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.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "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.element(:maindir).expects(:to_resource).returns main
             @settings.element(: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.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"]
             @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny", :mode => 0755}
             @settings.setdefaults :third, :thirddir => ["/thirddir", "b"]
             @settings.setdefaults :files, :myfile => {: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("luke", "johnny").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")
             @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 setting a timer to trigger configuration file reparsing" do
         before do
             @settings = Puppet::Util::Settings.new
             @settings.setdefaults :foo, :filetimeout => [5, "eh"]
         end
 
         it "should do nothing if no filetimeout setting is available" do
             @settings.expects(:value).with(:filetimeout).returns nil
             EventLoop::Timer.expects(:new).never
             @settings.set_filetimeout_timer
         end
 
+        it "should always convert the timer interval to an integer" do
+            @settings.expects(:value).with(:filetimeout).returns "10"
+            EventLoop::Timer.expects(:new).with(:interval => 10, :start? => true, :tolerance => 1)
+            @settings.set_filetimeout_timer
+        end
+
         it "should do nothing if the filetimeout setting is not greater than 0" do
             @settings.expects(:value).with(:filetimeout).returns -2
             EventLoop::Timer.expects(:new).never
             @settings.set_filetimeout_timer
         end
 
         it "should create a timer with its interval set to the filetimeout, start? set to true, and a tolerance of 1" do
             @settings.expects(:value).with(:filetimeout).returns 5
             EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1)
 
             @settings.set_filetimeout_timer
         end
 
         it "should reparse when the timer goes off" do
             EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).yields
 
             @settings.expects(:reparse)
 
             @settings.set_filetimeout_timer
         end
     end
 end
 
 describe Puppet::Util::Settings::CFile do
     it "should be able to be converted into a resource" do
         Puppet::Util::Settings::CFile.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
     end
 
     describe "when being converted to a resource" do
         before do
             @settings = mock 'settings'
             @file = Puppet::Util::Settings::CFile.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
             @settings.stubs(:value).with(:mydir).returns "/my/file"
         end
 
         it "should skip files that cannot determine their types" do
             @file.expects(:type).returns nil
             @file.to_resource.should be_nil
         end
 
         it "should skip non-existent files if 'create_files' is not enabled" do
             @file.expects(:create_files?).returns false
             @file.expects(:type).returns :file
             File.expects(:exist?).with("/my/file").returns false
             @file.to_resource.should be_nil
         end
 
         it "should manage existent files even if 'create_files' is not enabled" do
             @file.expects(:create_files?).returns false
             @file.expects(:type).returns :file
             File.expects(:exist?).with("/my/file").returns true
             @file.to_resource.should be_instance_of(Puppet::Resource)
         end
 
         it "should skip files in /dev" do
             @settings.stubs(:value).with(:mydir).returns "/dev/file"
             @file.to_resource.should be_nil
         end
 
         it "should skip files whose paths are not strings" do
             @settings.stubs(:value).with(:mydir).returns :foo
             @file.to_resource.should be_nil
         end
 
         it "should return a file resource with the path set appropriately" do
             resource = @file.to_resource
             resource.type.should == "File"
             resource.title.should == "/my/file"
         end
 
         it "should fully qualified returned files if necessary (#795)" do
             @settings.stubs(:value).with(:mydir).returns "myfile"
             @file.to_resource.title.should == File.join(Dir.getwd, "myfile")
         end
 
         it "should set the mode on the file if a mode is provided" do
             @file.mode = 0755
 
             @file.to_resource[:mode].should == 0755
         end
 
         it "should set the owner if running as root and the owner is provided" do
             Puppet.features.expects(:root?).returns true
             @file.stubs(:owner).returns "foo"
             @file.to_resource[:owner].should == "foo"
         end
 
         it "should set the group if running as root and the group is provided" do
             Puppet.features.expects(:root?).returns true
             @file.stubs(:group).returns "foo"
             @file.to_resource[:group].should == "foo"
         end
 
         it "should not set owner if not running as root" do
             Puppet.features.expects(:root?).returns false
             @file.stubs(:owner).returns "foo"
             @file.to_resource[:owner].should be_nil
         end
 
         it "should not set group if not running as root" do
             Puppet.features.expects(:root?).returns false
             @file.stubs(:group).returns "foo"
             @file.to_resource[:group].should be_nil
         end
 
         it "should set :ensure to the file type" do
             @file.expects(:type).returns :directory
             @file.to_resource[:ensure].should == :directory
         end
 
         it "should set the loglevel to :debug" do
             @file.to_resource[:loglevel].should == :debug
         end
 
         it "should set the backup to false" do
             @file.to_resource[:backup].should be_false
         end
 
         it "should tag the resource with the settings section" do
             @file.expects(:section).returns "mysect"
             @file.to_resource.should be_tagged("mysect")
         end
 
         it "should tag the resource with the setting name" do
             @file.to_resource.should be_tagged("mydir")
         end
 
         it "should tag the resource with 'settings'" do
             @file.to_resource.should be_tagged("settings")
         end
     end
 end